mobile|Selected Template|1
mobile|Available Feature List|1|1000|4|5|6|7|8|9|100|101|1001|301|200|201|202|203|204|206
mobile|Selected Feature List|1|5|1000:1000|100|101|1001:10
-mobile|Available Chart List|CPU|CPU core|CPU frequency|Heap allocation|Process Size|Memory|Screenshot|UI event|Disk IO|Network IO|Device|Energy
+mobile|Available Chart List|CPU|CPU core|CPU frequency|Memory|Process Size|Heap allocation|Screenshot|UI event|Disk IO|Network IO|Device|Energy
wearable|Protocol Version|3.0
wearable|Available Template List|1|2|3|4|5|6|7|8|9|10
wearable|Selected Template|1
wearable|Available Feature List|1|1000|4|5|6|7|8|9|100|101|1001|301|200|201|202|203|204
wearable|Selected Feature List|1|5|1000:1000|100|101|1001:10
-wearable|Available Chart List|CPU|CPU core|CPU frequency|Heap allocation|Process Size|Memory|Screenshot|UI event|Disk IO|Network IO|Device|Energy
+wearable|Available Chart List|CPU|CPU core|CPU frequency|Memory|Process Size|Heap allocation|Screenshot|UI event|Disk IO|Network IO|Device|Energy
tv|Protocol Version|3.0
tv|Available Template List|1|3|9|10
tv|Selected Template|1
tv|Available Feature List|1|1000|4|5|6|7|8|9|100|101|1001|204
tv|Selected Feature List|1|5|1000:1000|100|101|1001:10
-tv|Available Chart List|CPU|CPU core|CPU frequency|Heap allocation|Process Size|Memory|Screenshot|UI event|Disk IO|Network IO|Device|Energy
+tv|Available Chart List|CPU|CPU core|CPU frequency|Memory|Process Size|Heap allocation|Screenshot|UI event|Disk IO|Network IO|Device|Energy
private static PackageInfo currentApplication = null;
private static Project currentProject = null;
private static RuntimeCallstackManager temporaryCallstackManager = new RuntimeCallstackManager();
+
+ public final static boolean MEMPSENABLE = true;
public static DeviceInfo getCurrentDeviceInfo() {
return currentDevice;
public static String PROCESS_MEMORY_CHART_PSS;
public static String PROCESS_MEMORY_CHART_RSS;
public static String PROCESS_MEMORY_CHART_VSS;
+ public static String PROCESS_MEMORY_CHART_THREED;
+ public static String PROCESS_MEMORY_CHART_GEM;
public static String PROCESS_MEMORY_CHART_TITLE;
public static String PROCESS_MEMORY_CHART_DESCRIPTOR;
HEAP_CHART_TITLE=Heap allocation
HEAP_CHART_DESCRIPTOR=Shows heap memory allocation.
-PROCESS_MEMORY_CHART_PSS=Proportional set size
-PROCESS_MEMORY_CHART_RSS=Resident set size
-PROCESS_MEMORY_CHART_VSS=Virtual set size
+PROCESS_MEMORY_CHART_PSS=PSS
+PROCESS_MEMORY_CHART_RSS=RSS
+PROCESS_MEMORY_CHART_VSS=VSS
+PROCESS_MEMORY_CHART_THREED=3D
+PROCESS_MEMORY_CHART_GEM=GEM(ALLOC)
PROCESS_MEMORY_CHART_TITLE=Process Size
PROCESS_MEMORY_CHART_DESCRIPTOR=Shows process memory usage. \nvirtual memory, resident memory, proportional memory.
if (processInfos.size() == 0) {
pinfo.setMainOrNot(true);
}
- processInfos.put(Integer.valueOf(pid), pinfo);
+ processInfos.put(Integer.valueOf(pid), pinfo);
}
}
public void run() {
DebugLog.openDataChannelWriter();
Thread curThread = Thread.currentThread();
-
try {
synchronized (AnalyzerManager.waitStartAck) {
try {
break;
case ProtocolConstants.MSG_PROCESS_MAP:
case ProtocolConstants.MSG_PROCESS_UNMAP:
+ try {
memoryMapChanged(log);
+ }
+ catch (Exception ex) {}
break;
case ProtocolConstants.MSG_DATA_TERMINATE:
processTerminate();
ProcessInformation pinfo = project.getProcessInformation(pid);
if (null == pinfo) {
pinfo = new ProcessInformation();
+
+ int ppid = log.getPpid();
+
pinfo.setPid(pid);
- pinfo.setPpid(log.getPpid());
+ pinfo.setPpid(ppid);
pinfo.setStartTime(starttime);
pinfo.setProcessName(log.getCmdname());
+
project.putProcessInformation(pinfo);
pinfo.setDropLog(true);
BinaryInfo bininfo = project.getDeviceStatusInfo().getBinaryInfo(libPath);
LibraryObject libObj = new LibraryObject(bininfo.getID(), lowAddr, highAddr);
if (!lastMap.addLibraryMap(libObj)) {
- Logger.error("exist library");
+ Logger.error("exist library - PID #" + pid + ", lib : " + libPath);
}
pinfo.setMappingState(true);
private long residentMemory; // protocol 3.0
private long sharedMemory; // protocol 3.0
private long pssMemory; // protocol 3.0
+ private long threeDMemory = -1; // protocol 4.2
+ private long gemMemory = -1; // protocol 4.2
private long totalAllocSize; // protocol 3.0
private int threadCount; // protocol 3.0
private String threadLoad; // protocol 3.0
this.pssMemory = pssMemory;
}
+ public long getThreeDMemory() {
+ return threeDMemory;
+ }
+
+ public void setThreeDMemory(long threeDMemory) {
+ this.threeDMemory = threeDMemory;
+ }
+
+ public long getGemMemory() {
+ return gemMemory;
+ }
+
+ public void setGemMemory(long gemMemory) {
+ this.gemMemory = gemMemory;
+ }
+
public long getTotalAllocSize() {
return totalAllocSize;
}
import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.model.DATime;
+import org.tizen.dynamicanalyzer.project.Project;
+import org.tizen.dynamicanalyzer.protocol.Protocol;
import org.tizen.dynamicanalyzer.util.Logger;
import org.tizen.dynamicanalyzer.util.UnsignedInt;
}
private void parseTargetProcessInfo(int targetProcessCount) {
+ String protocolversion = Global.getProject().getProtocolVersion();
+
processProfileDataList = new ProcessProfileData[targetProcessCount];
for (int i = 0; i < targetProcessCount; i++) {
ProcessProfileData processData = new ProcessProfileData();
processData.setResidentMemory(getLong());
processData.setSharedMemory(getLong());
processData.setPssMemory(getLong());
+
+ if(Global.MEMPSENABLE) {
+ processData.setGemMemory(getLong());
+ processData.setThreeDMemory(getLong());
+ }
+
processData.setTotalAllocSize(getLong());
processData.setThreadCount(getInt());
processData.setThreadLoad(parseLoad(processData.getThreadCount()));
private boolean firstUpdate;
private boolean tableVisible;
- private boolean[] columnVisibilityEnable = { true, true, true, true, true, true, true, true, false };
+ private boolean[] columnVisibilityEnable = { false, true, true, true, true, true, true, true, false };
private boolean[] columnVisibilityDisable = { false, false, false, false, false, false, false, false, true };
public MemoryAllocationTraceTableView(Composite parent, int style) {
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.ScrollBar;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.nl.MemoryPageLabels;
import org.tizen.dynamicanalyzer.resources.ColorResources;
import org.tizen.dynamicanalyzer.resources.FontResources;
} else {
memoryChartBoard.setTotalEndTime(Toolbar.INSTANCE.getTime(), false);
}
+
+ if(Global.getProject() == null)
+ return;
memoryChartBoard.updateChartBoard();
memoryChartBoard.setTimelineMarkerStartTime(rangeDataManager.getMarkerStartTime()
return;\r
}\r
\r
+ /*\r
+ * index 0 : system memory\r
+ * index 1 : process memory\r
+ */\r
@SuppressWarnings("unchecked")\r
- Map<Integer, List<List<Object>>> processDataMap = (Map<Integer, List<List<Object>>>)dataList.get(TimelineConstants.TARGET_PROCESS_DB_DATA);\r
+ Map<Integer, List<List<Object>>> processDataMap = (Map<Integer, List<List<Object>>>)dataList.get(1);\r
List<List<Object>> processData = processDataMap.get(pid);\r
\r
if(processData == null) {\r
\r
for(int i = 0; i < processData.size(); i++) {\r
List<Object> row = processData.get(i);\r
- double time = (Long) row.get(ProcessMemoryDBTable.COLUMN.SAMPLING_TIME.ordinal())\r
+ double time = (Long) row.get(ProcessMemoryDBTable.COLUMN.SAMPLING_TIME.index)\r
/ TimelineConstants.MEGA_DOUBLE;\r
\r
- if(totalSeries != null) {\r
- long totalAlloc = (Long) row\r
- .get(ProcessMemoryDBTable.COLUMN.HEAP_ALLOCATION_TOTAL_BYTE.ordinal());\r
- totalSeries.addSeriesItem(new DAChartSeriesItem(time, totalAlloc, Formatter\r
- .toByteFormat(totalAlloc)));\r
- }\r
+ long totalAlloc = 0;\r
\r
+ @SuppressWarnings("unchecked")\r
+ List<Integer> libIdList = (List<Integer>) row.get(ProcessMemoryDBTable.COLUMN.HEAP_ALLOCATION_BINARY_ID.index);\r
\r
@SuppressWarnings("unchecked")\r
- List<Integer> libIdList = (List<Integer>) row.get(ProcessMemoryDBTable.COLUMN.HEAP_ALLOCATION_BINARY_ID.ordinal());\r
+ List<Long> libByteList = (List<Long>) row.get(ProcessMemoryDBTable.COLUMN.HEAP_ALLOCATION_BYTE.index);\r
+ \r
int index = libIdList.indexOf(libId);\r
\r
if(index != -1) {\r
- @SuppressWarnings("unchecked")\r
- List<Long> libByteList = (List<Long>) row.get(ProcessMemoryDBTable.COLUMN.HEAP_ALLOCATION_BYTE.ordinal());\r
long targetAlloc = (Long) libByteList.get(index);\r
appSeries.addSeriesItem(new DAChartSeriesItem(time, targetAlloc, Formatter.toByteFormat(targetAlloc)));\r
}\r
+ \r
+ for(Long libbyte : libByteList) {\r
+ totalAlloc += libbyte;\r
+ }\r
+ \r
+ if(totalSeries != null) { \r
+ totalSeries.addSeriesItem(new DAChartSeriesItem(time, totalAlloc, Formatter\r
+ .toByteFormat(totalAlloc)));\r
+ }\r
}\r
}\r
\r
package org.tizen.dynamicanalyzer.ui.memory.chart;\r
\r
import java.util.ArrayList;\r
-import java.util.HashSet;\r
import java.util.Iterator;\r
import java.util.List;\r
import java.util.Map;\r
private int allProcessPID = 0;\r
private int preSelectedPID = -1;\r
\r
- private final int HEAP_DB_LIB_ID_INDEX = 9;\r
private final int appAllocSeriesID = -10;\r
private final String libNameMainExecutable = "Main Executable";\r
private final String libNameUnknown = "Unknown";\r
private void createChartItem() {\r
long startTime = AnalyzerUtil.translateSecToMicroSec(getVisibleStartTime());\r
long endTime = AnalyzerUtil.translateSecToMicroSec(getVisibleEndTime());\r
+ \r
+ String pidliststring = getTargetPIDString();\r
+ \r
Map<Integer, List<List<Object>>> allProcessDBData = MemoryDataManager.getInstance()\r
- .getTargetProcessDataMapFromDB(startTime, endTime, allProcessPID);\r
+ .getTargetProcessDataMapFromDB(startTime, endTime, pidliststring);\r
\r
Set<Integer> pidSet = allProcessDBData.keySet();\r
Object[] pidList = pidSet.toArray();\r
\r
List<List<Object>> targetProcessDBData = allProcessDBData.get(pid);\r
\r
- Set<Integer> libIDSet = new HashSet<Integer>();\r
+ List<Integer> libIDSet = new ArrayList<Integer>();\r
for(List<Object> targetProcessDBDataBy1Sec : targetProcessDBData) {\r
- Object tmp = targetProcessDBDataBy1Sec.get(HEAP_DB_LIB_ID_INDEX);\r
+ Object tmp = targetProcessDBDataBy1Sec.get(ProcessMemoryDBTable.COLUMN.HEAP_ALLOCATION_BINARY_ID.index);\r
@SuppressWarnings("unchecked")\r
List<Object> tmplibIDList = (List<Object>)tmp;\r
for(Object oLibID : tmplibIDList) {\r
- int libID = (Integer)oLibID;\r
- libIDSet.add(libID);\r
+ libIDSet.add((Integer)oLibID);\r
}\r
}\r
\r
- Object[] libIDList = libIDSet.toArray();\r
- for(Object oLibID : libIDList) {\r
- int libId = (Integer)oLibID;\r
+ for(Integer libId : libIDSet) {\r
if(!isExistHeapChart(pid, libId)) {\r
addHeapChartItemList(pid, libId);\r
}\r
private String getChartName(String libPath) {\r
int index = libPath.lastIndexOf("/");\r
\r
+ if(index < 1) {\r
+ return libPath;\r
+ }\r
+ \r
return libPath.substring(0, index) + "\n" + libPath.substring(index+1);\r
}\r
\r
for(int i = 0; i < processData.size(); i++) {\r
List<Object> row = processData.get(i);\r
@SuppressWarnings("unchecked")\r
- List<Long> libByteList = (List<Long>) row.get(ProcessMemoryDBTable.COLUMN.HEAP_ALLOCATION_BYTE.ordinal());\r
+ List<Long> libByteList = (List<Long>) row.get(ProcessMemoryDBTable.COLUMN.HEAP_ALLOCATION_BYTE.index);\r
for(Long libByte : libByteList) {\r
if(max < libByte) {\r
max = libByte;\r
preSelectedPID = selectedPid;\r
}\r
\r
+ private String getTargetPIDString(){\r
+ List<Integer> pidlist = new ArrayList<Integer>();\r
+\r
+ int[] pids = Global.getProject().getProcessIDs();\r
+ int targetPID = Toolbar.INSTANCE.getSelectedPid();\r
+\r
+ if(targetPID > 0) {\r
+ pidlist.add(targetPID);\r
+ }\r
+ else {\r
+ for (int i = 0; i < pids.length; i++) {\r
+ pidlist.add(pids[i]);\r
+ } \r
+ }\r
+\r
+ String pidliststring = "(";\r
+\r
+ for(int i = 0 ; i < pidlist.size() ; i++) {\r
+ pidliststring += Integer.toString(pidlist.get(i));\r
+\r
+ if(i != pidlist.size() - 1) {\r
+ pidliststring += ", ";\r
+ }\r
+ }\r
+\r
+ pidliststring += ")";\r
+\r
+ return pidliststring;\r
+ }\r
+ \r
}\r
\r
private DAChartSeries vssSeries;\r
private DAChartSeries rssSeries;\r
private DAChartSeries pssSeries;\r
+ private DAChartSeries threeDSeries;\r
+ private DAChartSeries gemSeries;\r
\r
private Map<Integer, DAChartBoardItem> processChartboardMap = new HashMap<Integer, DAChartBoardItem>();\r
private Map<Integer, String> processNameMap = new HashMap<Integer, String>();\r
pssSeries = new DAChartSeries(\r
TimelineChartLabels.PROCESS_MEMORY_CHART_PSS,\r
DAChartSeries.SERIES_STYLE_AREA, ColorResources.SERIES_COLOR_PROCESS_PSS);\r
+ threeDSeries = new DAChartSeries(\r
+ TimelineChartLabels.PROCESS_MEMORY_CHART_THREED,\r
+ DAChartSeries.SERIES_STYLE_AREA, ColorResources.SERIES_COLOR_PROCESS_VSS);\r
+ gemSeries = new DAChartSeries(\r
+ TimelineChartLabels.PROCESS_MEMORY_CHART_GEM,\r
+ DAChartSeries.SERIES_STYLE_AREA, ColorResources.SERIES_COLOR_PROCESS_RSS);\r
\r
- chart.addSeries(vssSeries);\r
- chart.addSeries(rssSeries);\r
- chart.addSeries(pssSeries);\r
+ if(Global.MEMPSENABLE) {\r
+ chart.addSeries(pssSeries);\r
+ chart.addSeries(threeDSeries);\r
+ chart.addSeries(gemSeries);\r
+ }\r
+ else {\r
+ chart.addSeries(vssSeries);\r
+ chart.addSeries(rssSeries);\r
+ chart.addSeries(pssSeries); \r
+ } \r
}\r
\r
@Override\r
vssSeries.clear();\r
rssSeries.clear();\r
pssSeries.clear();\r
+ threeDSeries.clear();\r
+ gemSeries.clear();\r
\r
if(Global.getProject() == null) {\r
return;\r
return;\r
}\r
\r
+ /*\r
+ * index 0 : system memory\r
+ * index 1 : process memory\r
+ */ \r
@SuppressWarnings("unchecked")\r
- Map<Integer, List<List<Object>>> processDataMap = (Map<Integer, List<List<Object>>>)dataList.get(TimelineConstants.TARGET_PROCESS_DB_DATA); \r
+ Map<Integer, List<List<Object>>> processDataMap = (Map<Integer, List<List<Object>>>)dataList.get(1); \r
List<List<Object>> processData = processDataMap.get(pid);\r
\r
if(processData == null) {\r
\r
for(int i = 0; i < processData.size(); i++) {\r
List<Object> row = processData.get(i);\r
- double time = (Long) row.get(ProcessMemoryDBTable.COLUMN.SAMPLING_TIME.ordinal())\r
- / TimelineConstants.MEGA_DOUBLE;\r
- long vssMemory = (Long) row\r
- .get(ProcessMemoryDBTable.COLUMN.MEMORY_VIRTUAL.ordinal());\r
- long rssMemory = (Long) row\r
- .get(ProcessMemoryDBTable.COLUMN.MEMORY_RESIDENT.ordinal());\r
- long pssMemory = (Long) row.get(ProcessMemoryDBTable.COLUMN.MEMORY_PSS\r
- .ordinal());\r
- vssSeries.addSeriesItem(\r
- new DAChartSeriesItem(time, vssMemory, Formatter\r
- .toByteFormat(vssMemory)));\r
- rssSeries.addSeriesItem(\r
- new DAChartSeriesItem(time, rssMemory, Formatter\r
- .toByteFormat(rssMemory)));\r
- pssSeries.addSeriesItem(\r
- new DAChartSeriesItem(time, pssMemory, Formatter\r
- .toByteFormat(pssMemory)));\r
+ double time = (Long) row.get(ProcessMemoryDBTable.COLUMN.SAMPLING_TIME.index) / TimelineConstants.MEGA_DOUBLE;\r
+ long vssMemory = (Long) row.get(ProcessMemoryDBTable.COLUMN.MEMORY_VIRTUAL.index);\r
+ long rssMemory = (Long) row.get(ProcessMemoryDBTable.COLUMN.MEMORY_RESIDENT.index);\r
+ long pssMemory = (Long) row.get(ProcessMemoryDBTable.COLUMN.MEMORY_PSS.index);\r
+ \r
+ if(Global.MEMPSENABLE) {\r
+ long threeDMemory = (Long) row.get(ProcessMemoryDBTable.COLUMN.MEMORY_THREED.index);\r
+ long gemMemory = (Long) row.get(ProcessMemoryDBTable.COLUMN.MEMORY_GEM.index);\r
+\r
+ pssSeries.addSeriesItem(\r
+ new DAChartSeriesItem(time, pssMemory, Formatter\r
+ .toByteFormat(pssMemory)));\r
+ threeDSeries.addSeriesItem(\r
+ new DAChartSeriesItem(time, threeDMemory, Formatter\r
+ .toByteFormat(threeDMemory)));\r
+ gemSeries.addSeriesItem(\r
+ new DAChartSeriesItem(time, gemMemory, Formatter\r
+ .toByteFormat(gemMemory)));\r
+\r
+ } \r
+ else {\r
+ vssSeries.addSeriesItem(\r
+ new DAChartSeriesItem(time, vssMemory, Formatter\r
+ .toByteFormat(vssMemory)));\r
+ rssSeries.addSeriesItem(\r
+ new DAChartSeriesItem(time, rssMemory, Formatter\r
+ .toByteFormat(rssMemory)));\r
+ pssSeries.addSeriesItem(\r
+ new DAChartSeriesItem(time, pssMemory, Formatter\r
+ .toByteFormat(pssMemory))); \r
+ } \r
}\r
}\r
\r
List<List<Object>> data = targetProcessDataMap.get(pid);\r
for (int i = 0; i < data.size(); i++) {\r
List<Object> oneTime = data.get(i);\r
- Long time = (Long) oneTime.get(ProcessMemoryDBTable.COLUMN.SAMPLING_TIME\r
- .ordinal());\r
- Long processMemorySize = (Long) oneTime\r
- .get(ProcessMemoryDBTable.COLUMN.MEMORY_RESIDENT\r
- .ordinal());\r
+ Long time = (Long) oneTime.get(ProcessMemoryDBTable.COLUMN.SAMPLING_TIME.index);\r
+ Long processMemorySize = (Long) oneTime.get(ProcessMemoryDBTable.COLUMN.MEMORY_RESIDENT.index);\r
Long processMemorySizeSum = processLoadSumMap.get(time);\r
if (processMemorySizeSum == null) {\r
processLoadSumMap.put(time, processMemorySize);\r
} else {\r
- processLoadSumMap.put(time, processMemorySizeSum\r
- + processMemorySize);\r
+ processLoadSumMap.put(time, processMemorySizeSum + processMemorySize);\r
}\r
}\r
}\r
private HashSet<Long> addressMap = new HashSet<Long> ();
+ private HashSet<Long> previousSeq = new HashSet<Long> ();
+
public HeapDataManager() {
allocateDBTable = new MemAllocDBTable();
freeDBTable = new MemFreeDBTable();
allocateDBInserter = makeInserter(allocateDBTable);
freeDBInserter = makeInserter(freeDBTable);
+
+ previousSeq.clear();;
}
public static HeapDataManager getInstance() {
memoryfreeDataList.clear();
addressMap.clear();
+
+ previousSeq.clear();
}
@Override
return output;
}
- public List<String> getHeapLibNames(long start, long end, String targetIds) {
- List<String> output = new ArrayList<String>();
-
- String where = "";
- if (start != 0 || end != 0) {
- where += String.format("%s BETWEEN %s AND %s AND ", MemHeapDBTable.COLUMN.CALL_TIME.name, Long.toString(start), Long.toString(end));
- }
-
- where += String.format("%s IN %s", MemHeapDBTable.COLUMN.PID.name, targetIds);
-
- String query = String.format("SELECT DISTINCT %s FROM %s WHERE %s",
- MemHeapDBTable.COLUMN.CALLER_LIBRARY_ID.name, heapDBTable.getTableName(), where);
-
- ResultSet rs = SqlConnectionManager.executeQueryRS(query);
- if (rs != null) {
- try {
- while (rs.next()) {
- output.add(rs.getString(1));
- }
- } catch (SQLException e) {
- Logger.exception(e);
- } finally {
- SqlConnectionManager.releaseResultSet(rs);
- }
- }
- return output;
- }
-
public int getColumnCount(String tablename, String column, String timestring, long start, long end, String targetIds) {
int count = 0;
memoryAllocDataList.add(dbAllocData);
- if(!addressMap.contains(address)) {
- addressMap.add(address);
- }
+ //if(!addressMap.contains(address)) {
+ // addressMap.add(address);
+ //}
}
private void makeFreeData(MemoryData mData, int binaryid) {
}
private void makeFreeData(MemoryData mData, Long address, int binaryid) {
- if(!addressMap.contains(address)) {
- return;
- }
+ //if(!addressMap.contains(address)) {
+ // return;
+ //}
ArrayList<Object> dbFreeData = new ArrayList<Object>();
int pid = mData.getPid();
-
+
dbFreeData.add(Long.valueOf(mData.getSeq()));
dbFreeData.add(Integer.valueOf(pid));
dbFreeData.add(Integer.valueOf(mData.getMsgID()));
addColumn(new DBColumn(COLUMN.PID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
addColumn(new DBColumn(COLUMN.API_ID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
addColumn(new DBColumn(COLUMN.API_TYPE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
- addColumn(new DBColumn(COLUMN.ALLOCATED_ADDRESS.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG)); // default:-1
+ addColumn(new DBColumn(COLUMN.ALLOCATED_ADDRESS.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
addColumn(new DBColumn(COLUMN.ALLOCATED_TIME.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
addColumn(new DBColumn(COLUMN.CALLER_PC_ADDRESS.name, DBConstants.EMPTY, DBConstants.DBTYPE_LONG));
addColumn(new DBColumn(COLUMN.CALLER_LIBRARY_ID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
addColumn(new DBColumn(COLUMN.MESSAGE_ID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
addColumn(new DBColumn(COLUMN.ALLOCATED_MEMORY_SIZE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
-
+
setIndexColumn(COLUMN.PID.index);
- setIndexColumn(COLUMN.ALLOCATED_ADDRESS.index);
setIndexColumn(COLUMN.SEQUENCE_NUMBER.index);
+ setIndexColumn(COLUMN.ALLOCATED_TIME.index);
}
@Override
prep.setInt(8, (Integer) (rowData.get(COLUMN.CALLER_LIBRARY_ID.index)));
prep.setInt(9, (Integer) (rowData.get(COLUMN.MESSAGE_ID.index)));
prep.setLong(10, (Long) (rowData.get(COLUMN.ALLOCATED_MEMORY_SIZE.index)));
-
} catch (SQLException e) {
Logger.exception(e);
isPrepared = false;
import org.tizen.dynamicanalyzer.constant.CommonConstants;\r
import org.tizen.dynamicanalyzer.database.DBInserter;\r
import org.tizen.dynamicanalyzer.database.SqlConnectionManager;\r
-import org.tizen.dynamicanalyzer.project.LibraryObject;\r
-import org.tizen.dynamicanalyzer.project.ProcessMemoryMap;\r
-import org.tizen.dynamicanalyzer.project.Project;\r
import org.tizen.dynamicanalyzer.protocol.ProtocolConstants;\r
import org.tizen.dynamicanalyzer.swap.logparser.LogPackage;\r
import org.tizen.dynamicanalyzer.swap.logparser.Logs;\r
\r
private static final int appAllocSeriesID = -10;\r
\r
+ private int REALLOC_ID;\r
+ \r
// Map<PID, target Allocation Byte>\r
- private Map<Integer, Long> allocByteMap = new HashMap<Integer, Long>(); \r
+ private Map<Integer, Long> mainAllocByteMap = new HashMap<Integer, Long>(); \r
// Map<PID, Map<binaryID, Allocation Byte>>\r
private Map<Integer, Map<Integer, Long>> libraryAllocByteMap = new HashMap<Integer, Map<Integer, Long>>();\r
// Map<Address, Allocation Byte>\r
- private HashMap<String, List<List<Object>>> allocationSeriesDataSetMap = new HashMap<String, List<List<Object>>>();\r
+ private HashMap<String, List<List<Object>>> allocAddressDataMap = new HashMap<String, List<List<Object>>>();\r
+ \r
+ private List<MemoryData> freedatalist = new ArrayList<MemoryData>();\r
\r
private SystemMemoryDBTable systemMemoryDBTable = null;\r
private ProcessMemoryDBTable processMemoryDBTable = null;\r
}\r
\r
public void clear() {\r
- allocByteMap = new HashMap<Integer, Long>();\r
+ mainAllocByteMap = new HashMap<Integer, Long>();\r
libraryAllocByteMap = new HashMap<Integer, Map<Integer, Long>>();\r
- allocationSeriesDataSetMap.clear();\r
+ allocAddressDataMap.clear();\r
+ freedatalist.clear();\r
}\r
\r
public void saveData(Map<String, String> dataMap) {\r
@Override\r
protected void makeData(LogPackage pack) {\r
Logs systemmemorylogs = getLogsFromLogPackage(pack, ProtocolConstants.MSG_DATA_SYSTEM);\r
- Logs allocatedlogs = getLogsFromLogPackage(pack, ProtocolConstants.MSG_PROBE_MEMORY); \r
+ Logs allocatedlogs = getLogsFromLogPackage(pack, ProtocolConstants.MSG_PROBE_MEMORY);\r
+ \r
+ REALLOC_ID = Global.getFunctionID("realloc");\r
\r
makeSystemMemoryData(systemmemorylogs, allocatedlogs);\r
}\r
GetSystemMemoryData(systemLogList);\r
}\r
}\r
-\r
- private void addNewSeriesUserAllocData(int fdApiType, MemoryData log, int binaryId) {\r
- long allocsize = 0;\r
- Long allocByte = allocByteMap.get(log.getPid());\r
-\r
+ \r
+ private void plusAllocData(MemoryData log) {\r
+ int pid = log.getPid();\r
long address = log.getAddress();\r
- long seqnum = log.getSeq();\r
+ long tracetime = log.getTime();\r
\r
if (address == 0) {\r
return;\r
}\r
\r
- String keystring = String.format("%d-%d", address, binaryId);\r
-\r
- if (MEM_API_TYPE_ALLOC == fdApiType) {\r
+ String keystring = String.format("%d-%d", pid, address);\r
+ \r
+ int binaryId = Global.getBinaryID(pid, tracetime, log.getCallerPcAddr());\r
+ String appname = Global.getCurrentDeviceInfo().getSelectedPackageLabel();\r
+ \r
+ if(log.getLibName().endsWith(appname)) {\r
+ binaryId = appAllocSeriesID;\r
+ }\r
+ \r
+ if(REALLOC_ID == log.getApiId()) {\r
try {\r
- allocsize = log.getSize();\r
- if (binaryId == appAllocSeriesID) {\r
- allocByteMap.put(log.getPid(), allocByte + allocsize);\r
- } else {\r
- Long libraryAllocByte;\r
- \r
- if(libraryAllocByteMap.get(log.getPid()).containsKey(binaryId)) {\r
- libraryAllocByte = libraryAllocByteMap.get(log.getPid()).get(binaryId);\r
- if (libraryAllocByte == null) {\r
- libraryAllocByte = new Long(0);\r
- }\r
- }\r
- else {\r
- libraryAllocByte = new Long(0);\r
- }\r
- \r
- libraryAllocByteMap.get(log.getPid()).put(binaryId,libraryAllocByte + allocsize);\r
- }\r
+ Long freeaddress = Long.parseLong(log.getArgs().replace("0x", "").split(",")[0], 16);\r
+ MemoryData freetempdata = log.clone();\r
+ freetempdata.setAddress(freeaddress);\r
+ freedatalist.add(freetempdata);\r
+ }\r
+ catch(NumberFormatException ex) {\r
+ Logger.warning("realloc address invalide : %s", log.getArgs());\r
+ } catch (CloneNotSupportedException e) {\r
\r
- if(allocationSeriesDataSetMap.containsKey(keystring)) {\r
- if(allocationSeriesDataSetMap.get(keystring) == null) {\r
- List<List<Object>> newlist = new ArrayList<List<Object>>();\r
- allocationSeriesDataSetMap.put(keystring, newlist);\r
- }\r
- }\r
+ }\r
+ }\r
+ \r
+ try {\r
+ long allocsize = log.getSize();\r
+ \r
+ if (binaryId == appAllocSeriesID) {\r
+ mainAllocByteMap.put(pid, mainAllocByteMap.get(pid) + allocsize);\r
+ } else {\r
+ Long libraryAllocByte;\r
\r
- if(allocationSeriesDataSetMap.containsKey(keystring)) {\r
- List<Object> onedata = new ArrayList<Object>();\r
- onedata.add(seqnum);\r
- onedata.add(allocsize);\r
- \r
- allocationSeriesDataSetMap.get(keystring).add(onedata);\r
+ if(libraryAllocByteMap.get(pid).containsKey(binaryId)) {\r
+ libraryAllocByte = libraryAllocByteMap.get(pid).get(binaryId);\r
+ if (libraryAllocByte == null) {\r
+ libraryAllocByte = new Long(0);\r
+ }\r
}\r
else {\r
- List<List<Object>> newlist = new ArrayList<List<Object>>();\r
- \r
- List<Object> onedata = new ArrayList<Object>();\r
- onedata.add(seqnum);\r
- onedata.add(allocsize);\r
- \r
- newlist.add(onedata);\r
- allocationSeriesDataSetMap.put(keystring, newlist);\r
+ libraryAllocByte = new Long(0);\r
}\r
\r
- } catch (NumberFormatException ne) {\r
- Logger.exception(ne);\r
- }\r
- } else if (MEM_API_TYPE_FREE == fdApiType) {\r
- if (!allocationSeriesDataSetMap.containsKey(keystring)) {\r
- return;\r
+ libraryAllocByteMap.get(pid).put(binaryId,libraryAllocByte + allocsize);\r
}\r
\r
- if(allocationSeriesDataSetMap.containsKey(keystring)) {\r
- int listsize = allocationSeriesDataSetMap.get(keystring).size();\r
- for(int j = 0; j < listsize ; j++) {\r
- List<Object> onedata = allocationSeriesDataSetMap.get(keystring).get(j);\r
- \r
- if((Long) onedata.get(0) <= seqnum) {\r
- allocsize = (Long) onedata.get(1);\r
- allocationSeriesDataSetMap.get(keystring).remove(j);\r
- break;\r
- }\r
+ if(!allocAddressDataMap.containsKey(keystring)) {\r
+ List<List<Object>> newlist = new ArrayList<List<Object>>();\r
+ List<Object> onedata = new ArrayList<Object>();\r
+ onedata.add(tracetime);\r
+ onedata.add(allocsize);\r
+ onedata.add(binaryId);\r
+ \r
+ newlist.add(onedata);\r
+ allocAddressDataMap.put(keystring, newlist);\r
+ }\r
+ else {\r
+ List<Object> onedata = new ArrayList<Object>();\r
+ onedata.add(tracetime);\r
+ onedata.add(allocsize);\r
+ onedata.add(binaryId);\r
+ \r
+ allocAddressDataMap.get(keystring).add(onedata);\r
+ }\r
+ } catch (NumberFormatException ne) {\r
+ Logger.exception(ne);\r
+ }\r
+ }\r
+ \r
+ private void minusFreeData(MemoryData log) {\r
+ int pid = log.getPid();\r
+ long address = log.getAddress();\r
+ long tracetime = log.getTime();\r
+ \r
+ String keystring = String.format("%d-%d", pid, address);\r
+ \r
+ if (!allocAddressDataMap.containsKey(keystring)) {\r
+ return;\r
+ }\r
+ \r
+ long allocsize = -1;\r
+ int alloclib = 0;\r
+ \r
+ if(allocAddressDataMap.containsKey(keystring)) {\r
+ int listsize = allocAddressDataMap.get(keystring).size();\r
+ for(int j = 0; j < listsize ; j++) {\r
+ List<Object> onedata = allocAddressDataMap.get(keystring).get(j);\r
+ \r
+ if((Long) onedata.get(0) <= tracetime) {\r
+ allocsize = (Long) onedata.get(1);\r
+ alloclib = (Integer) onedata.get(2);\r
+ allocAddressDataMap.get(keystring).remove(j);\r
+ break;\r
}\r
}\r
- \r
- if (binaryId == appAllocSeriesID) {\r
- allocByteMap.put(log.getPid(), allocByte - allocsize);\r
- } else {\r
- if(libraryAllocByteMap.get(log.getPid()).containsKey(binaryId)) {\r
- Long libraryAllocByte = libraryAllocByteMap.get(log.getPid()).get(binaryId);\r
- if (libraryAllocByte != null) {\r
- long calsize = libraryAllocByte - allocsize;\r
- \r
- if (calsize < 0){\r
- calsize = 0;\r
- }\r
- libraryAllocByteMap.get(log.getPid()).put(binaryId,calsize);\r
- }\r
- else {\r
- libraryAllocByte = new Long(0);\r
- libraryAllocByteMap.get(log.getPid()).put(binaryId,libraryAllocByte);\r
+ }\r
+ \r
+ if(allocsize == -1)\r
+ return;\r
+ \r
+ if (alloclib == appAllocSeriesID) {\r
+ Long allocByte = mainAllocByteMap.get(pid);\r
+ mainAllocByteMap.put(pid, allocByte - allocsize);\r
+ } else {\r
+ if(libraryAllocByteMap.get(pid).containsKey(alloclib)) {\r
+ Long libraryAllocByte = libraryAllocByteMap.get(pid).get(alloclib);\r
+ if (libraryAllocByte != null) {\r
+ long calsize = libraryAllocByte - allocsize;\r
+ \r
+ if (calsize < 0){\r
+ calsize = 0;\r
}\r
+ libraryAllocByteMap.get(pid).put(alloclib,calsize);\r
+ }\r
+ else {\r
+ libraryAllocByte = new Long(0);\r
+ libraryAllocByteMap.get(pid).put(alloclib,libraryAllocByte);\r
}\r
}\r
}\r
int pid = logData.getPid();\r
int memApiType = logData.getMemoryApiType();\r
\r
- if (allocByteMap.get(pid) == null) {\r
- allocByteMap.put(Integer.valueOf(pid), new Long(0));\r
+ if (mainAllocByteMap.get(pid) == null) {\r
+ mainAllocByteMap.put(Integer.valueOf(pid), new Long(0));\r
libraryAllocByteMap.put(Integer.valueOf(pid), new HashMap<Integer, Long>());\r
}\r
\r
- int binaryid = appAllocSeriesID;\r
- \r
- Project project = Global.getProject();\r
- ProcessMemoryMap pmap = project.getProcessInformation(pid).getProcessMemoryMap(logData.getTime());\r
-\r
- if (pmap != null) {\r
- LibraryObject lib = pmap.getLibraryByAddress(logData.getCallerPcAddr());\r
- if (lib != null && lib != pmap.getMainbinary()) {\r
- binaryid = project.getDeviceStatusInfo().getBinaryInfo(lib.getBinaryID()).getID();\r
- }\r
+ if(memApiType == MEM_API_TYPE_ALLOC) {\r
+ plusAllocData(logData);\r
}\r
-\r
- addNewSeriesUserAllocData(memApiType, logData, binaryid); \r
+ else if(memApiType == MEM_API_TYPE_FREE) {\r
+ freedatalist.add(logData);\r
+ } \r
}\r
\r
}\r
+ \r
+ private void calculateFreeData(){\r
+ for(MemoryData freelog : freedatalist) {\r
+ minusFreeData(freelog);\r
+ }\r
+ freedatalist.clear();\r
+ }\r
\r
private void GetSystemMemoryData(List<LogData> systemLogList) {\r
ArrayList<List<Object>> systemDataList = new ArrayList<List<Object>>();\r
dbSystemData.add(pIDList);\r
dbSystemData.add(processLoadList);\r
systemDataList.add(dbSystemData);\r
-\r
+ \r
/*\r
* Make target Process Table data\r
*/\r
ProcessProfileData process = targetProcessList[j];\r
\r
ArrayList<Object> dbTargetProcessData = new ArrayList<Object>();\r
- dbTargetProcessData.add(new Long(log.getTime()));\r
- dbTargetProcessData.add(new Integer(process.getPid()));\r
- dbTargetProcessData.add(new Float(process.getProcessLoad()));\r
- dbTargetProcessData.add(new Long(process.getVirtualMemory()));\r
- dbTargetProcessData.add(new Long(process.getResidentMemory()));\r
- dbTargetProcessData.add(new Long(process.getSharedMemory()));\r
- dbTargetProcessData.add(new Long(process.getPssMemory()));\r
- dbTargetProcessData.add(new Integer(process.getThreadCount()));\r
- dbTargetProcessData.add(new Long(process.getTotalAllocSize()));\r
\r
/*\r
* Set inform for Heap allocation\r
*/\r
+ \r
+ calculateFreeData();\r
+ \r
List<Object> binaryIDList = new ArrayList<Object>();\r
List<Object> allocByteList = new ArrayList<Object>();\r
binaryIDList.add(appAllocSeriesID);\r
- if (allocByteMap.get(process.getPid()) == null) {\r
+ if (mainAllocByteMap.get(process.getPid()) == null) {\r
allocByteList.add(new Long(0));\r
} else {\r
- allocByteList.add(allocByteMap.get(process.getPid()));\r
+ allocByteList.add(mainAllocByteMap.get(process.getPid()));\r
}\r
\r
Map<Integer, Long> libraryList = libraryAllocByteMap.get(process.getPid());\r
binaryIDList.add(binaryID);\r
allocByteList.add(libraryList.get(binaryID));\r
}\r
- dbTargetProcessData.add(binaryIDList);\r
- dbTargetProcessData.add(allocByteList);\r
\r
/*\r
* Set inform for Thread\r
threadIdList.add(new Integer(threadLoad));\r
threadLoadList.add(threadLoads[++iii]);\r
}\r
+ \r
+ dbTargetProcessData.add(new Long(log.getTime()));\r
+ dbTargetProcessData.add(new Integer(process.getPid()));\r
+ dbTargetProcessData.add(new Float(process.getProcessLoad()));\r
+ dbTargetProcessData.add(new Long(process.getVirtualMemory()));\r
+ dbTargetProcessData.add(new Long(process.getResidentMemory()));\r
+ dbTargetProcessData.add(new Long(process.getSharedMemory()));\r
+ dbTargetProcessData.add(new Long(process.getPssMemory()));\r
+ // for new version\r
+ dbTargetProcessData.add(new Long(process.getThreeDMemory()));\r
+ dbTargetProcessData.add(new Long(process.getGemMemory()));\r
+ \r
+ dbTargetProcessData.add(new Integer(process.getThreadCount()));\r
+ dbTargetProcessData.add(new Long(process.getTotalAllocSize()));\r
+ \r
+ dbTargetProcessData.add(binaryIDList);\r
+ dbTargetProcessData.add(allocByteList);\r
dbTargetProcessData.add(threadIdList);\r
dbTargetProcessData.add(threadLoadList);\r
\r
\r
String where = "WHERE"; \r
if (start != 0 || end != 0) {\r
- where += String.format(" %s BETWEEN %s AND %s", ProcessMemoryDBTable.SAMPLING_TIME, Long.toString(start), Long.toString(end));\r
+ where += String.format(" %s BETWEEN %s AND %s", ProcessMemoryDBTable.COLUMN.SAMPLING_TIME.name, Long.toString(start), Long.toString(end));\r
}\r
\r
if (targetPID > 0) {\r
if (start != 0 || end != 0) \r
where += " AND";\r
\r
- where += String.format(" %s = %s", ProcessMemoryDBTable.PID, Integer.toString(targetPID));\r
+ where += String.format(" %s = %s", ProcessMemoryDBTable.COLUMN.PID.name, Integer.toString(targetPID));\r
} else {\r
// Do nothing. Get information from all processes.\r
}\r
where = "";\r
}\r
\r
- where += " ORDER BY " + ProcessMemoryDBTable.SAMPLING_TIME;\r
+ where += " ORDER BY " + ProcessMemoryDBTable.COLUMN.SAMPLING_TIME.name;\r
\r
List<List<Object>> queryResult = processMemoryDBTable.selectAllColumnData(where);\r
if (queryResult == null) {\r
return processedResult;\r
}\r
\r
+ public Map<Integer, List<List<Object>>> getTargetProcessDataMapFromDB(long start, long end, String targetPIDs) {\r
+ Map<Integer, List<List<Object>>> processedResult = new HashMap<Integer, List<List<Object>>>();\r
+ String where = "WHERE";\r
+ if (start != 0 || end != 0) { \r
+ where += String.format(" SAMPLING_TIME BETWEEN %s AND %s AND", Long.toString(start), Long.toString(end));\r
+ }\r
+ \r
+ where += String.format(" PID IN %s", targetPIDs);\r
+ where += " ORDER BY SAMPLING_TIME";\r
+\r
+ List<List<Object>> queryResult = processMemoryDBTable.selectAllColumnData(where);\r
+ if (queryResult == null) {\r
+ return processedResult;\r
+ }\r
+\r
+ for (int i = 0; i < queryResult.size(); i++) {\r
+ List<Object> row = queryResult.get(i);\r
+ Integer pid = (Integer) row.get(TargetProcessDBTable.COLUMN.PID.ordinal());\r
+ List<List<Object>> processData = processedResult.get(pid);\r
+ if (processData == null) {\r
+ processData = new ArrayList<List<Object>>();\r
+ processedResult.put(pid, processData);\r
+ }\r
+ processData.add(row);\r
+ }\r
+ return processedResult;\r
+ }\r
+ \r
public long getSystemMemoriesFromDB(long time) {\r
long processMemories = 0;\r
String tableName = systemMemoryDBTable.getTableName();\r
*
*/
-
package org.tizen.dynamicanalyzer.ui.memory.data;
import java.sql.PreparedStatement;
public class ProcessMemoryDBTable extends DBTable {
private static final String TABLENAME = "MEMORY_PROCESS_DATA";
- public static enum COLUMN {
- SAMPLING_TIME,
- PID,
- CPU_LOAD,
- MEMORY_VIRTUAL,
- MEMORY_RESIDENT,
- MEMORY_SHARED,
- MEMORY_PSS,
- THREAD_COUNT,
- HEAP_ALLOCATION_TOTAL_BYTE,
- HEAP_ALLOCATION_BINARY_ID,
- HEAP_ALLOCATION_BYTE,
- TID,
- THREAD_LOAD
- }
+ public enum COLUMN {
+ SAMPLING_TIME(0, "SAMPLING_TIME"),
+ PID(1, DBConstants.DBCOLUMN_PID),
+ CPU_LOAD(2, "CPU_LOAD"),
+ MEMORY_VIRTUAL(3, "MEMORY_VIRTUAL"),
+ MEMORY_RESIDENT(4, "MEMORY_RESIDENT"),
+ MEMORY_SHARED(5, "MEMORY_SHARED"),
+ MEMORY_PSS(6, "MEMORY_PSS"),
+ MEMORY_THREED(7, "MEMORY_THREED"),
+ MEMORY_GEM(8, "MEMORY_GEM"),
+ THREAD_COUNT(9, "THREAD_COUNT"),
+ HEAP_ALLOCATION_TOTAL_BYTE(10, "HEAP_ALLOCATION_TOTAL_BYTE"),
+ HEAP_ALLOCATION_BINARY_ID(11, "HEAP_ALLOCATION_BINARY_ID"),
+ HEAP_ALLOCATION_BYTE(12, "HEAP_ALLOCATION_BYTE"),
+ TID(13, "TID"),
+ THREAD_LOAD(14, "THREAD_LOAD");
- public static final String SAMPLING_TIME = "SAMPLING_TIME";
- public static final String PID = "PID";
- public static final String CPU_LOAD = "CPU_LOAD";
- public static final String MEMORY_VIRTUAL = "MEMORY_VIRTUAL";
- public static final String MEMORY_RESIDENT = "MEMORY_RESIDENT";
- public static final String MEMORY_SHARED = "MEMORY_SHARED";
- public static final String MEMORY_PSS = "MEMORY_PSS";
- public static final String THREAD_COUNT = "THREAD_COUNT";
- public static final String HEAP_ALLOCATION_TOTAL_BYTE = "HEAP_ALLOCATION_TOTAL_BYTE";
- public static final String HEAP_ALLOCATION_BINARY_ID = "HEAP_ALLOCATION_BINARY_ID";
- public static final String HEAP_ALLOCATION_BYTE = "HEAP_ALLOCATION_BYTE";
- public static final String TID = "TID";
- public static final String THREAD_LOAD = "THREAD_LOAD";
+ public final int index;
+ public final String name;
+ COLUMN(int index, String name) {
+ this.index = index;
+ this.name = name;
+ }
+ }
+
@Override
public String getTableName() {
return TABLENAME;
}
public ProcessMemoryDBTable() {
- addColumn(new DBColumn(SAMPLING_TIME, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
- addColumn(new DBColumn(PID, DBConstants.EMPTY, DBConstants.DBTYPE_INT4));
- addColumn(new DBColumn(CPU_LOAD, DBConstants.EMPTY, DBConstants.DBTYPE_FLOAT));
- addColumn(new DBColumn(MEMORY_VIRTUAL, DBConstants.EMPTY, DBConstants.DBTYPE_LONG));
- addColumn(new DBColumn(MEMORY_RESIDENT, DBConstants.EMPTY, DBConstants.DBTYPE_LONG));
- addColumn(new DBColumn(MEMORY_SHARED, DBConstants.EMPTY, DBConstants.DBTYPE_LONG));
- addColumn(new DBColumn(MEMORY_PSS, DBConstants.EMPTY, DBConstants.DBTYPE_LONG));
- addColumn(new DBColumn(THREAD_COUNT, DBConstants.EMPTY, DBConstants.DBTYPE_INT4));
- addColumn(new DBColumn(HEAP_ALLOCATION_TOTAL_BYTE, DBConstants.EMPTY, DBConstants.DBTYPE_LONG));
- addColumn(new DBColumn(HEAP_ALLOCATION_BINARY_ID, DBConstants.EMPTY, DBConstants.INTEGER_ARRAY));
- addColumn(new DBColumn(HEAP_ALLOCATION_BYTE, DBConstants.EMPTY, DBConstants.BIGINT_ARRAY));
- addColumn(new DBColumn(TID, DBConstants.EMPTY, DBConstants.INTEGER_ARRAY));
- addColumn(new DBColumn(THREAD_LOAD, DBConstants.EMPTY, DBConstants.FLOAT_ARRAY));
- setIndexColumn(COLUMN.SAMPLING_TIME.ordinal());
+ addColumn(new DBColumn(COLUMN.SAMPLING_TIME.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.PID.name, DBConstants.EMPTY, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.CPU_LOAD.name, DBConstants.EMPTY, DBConstants.DBTYPE_FLOAT));
+ addColumn(new DBColumn(COLUMN.MEMORY_VIRTUAL.name, DBConstants.EMPTY, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.MEMORY_RESIDENT.name, DBConstants.EMPTY, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.MEMORY_SHARED.name, DBConstants.EMPTY, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.MEMORY_PSS.name, DBConstants.EMPTY, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.MEMORY_THREED.name, DBConstants.EMPTY, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.MEMORY_GEM.name, DBConstants.EMPTY, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.THREAD_COUNT.name, DBConstants.EMPTY, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.HEAP_ALLOCATION_TOTAL_BYTE.name, DBConstants.EMPTY, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.HEAP_ALLOCATION_BINARY_ID.name, DBConstants.EMPTY, DBConstants.INTEGER_ARRAY));
+ addColumn(new DBColumn(COLUMN.HEAP_ALLOCATION_BYTE.name, DBConstants.EMPTY, DBConstants.BIGINT_ARRAY));
+ addColumn(new DBColumn(COLUMN.TID.name, DBConstants.EMPTY, DBConstants.INTEGER_ARRAY));
+ addColumn(new DBColumn(COLUMN.THREAD_LOAD.name, DBConstants.EMPTY, DBConstants.FLOAT_ARRAY));
+
+ setIndexColumn(COLUMN.SAMPLING_TIME.index);
+ setIndexColumn(COLUMN.PID.index);
}
@Override
isPrepared = false;
} else {
try {
- int index = 0;
- prep.setLong(++index, (Long) (rowData.get(COLUMN.SAMPLING_TIME.ordinal())));
- prep.setInt(++index, (Integer) (rowData.get(COLUMN.PID.ordinal())));
- prep.setFloat(++index, (Float) (rowData.get(COLUMN.CPU_LOAD.ordinal())));
- prep.setLong(++index, (Long) (rowData.get(COLUMN.MEMORY_VIRTUAL.ordinal())));
- prep.setLong(++index, (Long) (rowData.get(COLUMN.MEMORY_RESIDENT.ordinal())));
- prep.setLong(++index, (Long) (rowData.get(COLUMN.MEMORY_SHARED.ordinal())));
- prep.setLong(++index, (Long) (rowData.get(COLUMN.MEMORY_PSS.ordinal())));
- prep.setInt(++index, (Integer) (rowData.get(COLUMN.THREAD_COUNT.ordinal())));
- prep.setLong(++index, (Long) (rowData.get(COLUMN.HEAP_ALLOCATION_TOTAL_BYTE.ordinal())));
- setArrayToPreparedStatement(COLUMN.HEAP_ALLOCATION_BINARY_ID.ordinal(),
- DBConstants.DBTYPE_INT4, prep, rowData);
- setArrayToPreparedStatement(COLUMN.HEAP_ALLOCATION_BYTE.ordinal(),
- DBConstants.DBTYPE_LONG, prep, rowData);
- setArrayToPreparedStatement(COLUMN.TID.ordinal(), DBConstants.DBTYPE_INT4, prep,
- rowData);
- setArrayToPreparedStatement(COLUMN.THREAD_LOAD.ordinal(), DBConstants.DBTYPE_FLOAT, prep,
- rowData);
+ prep.setLong(1, (Long) (rowData.get(COLUMN.SAMPLING_TIME.index)));
+ prep.setInt(2, (Integer) (rowData.get(COLUMN.PID.index)));
+ prep.setFloat(3, (Float) (rowData.get(COLUMN.CPU_LOAD.index)));
+ prep.setLong(4, (Long) (rowData.get(COLUMN.MEMORY_VIRTUAL.index)));
+ prep.setLong(5, (Long) (rowData.get(COLUMN.MEMORY_RESIDENT.index)));
+ prep.setLong(6, (Long) (rowData.get(COLUMN.MEMORY_SHARED.index)));
+ prep.setLong(7, (Long) (rowData.get(COLUMN.MEMORY_PSS.index)));
+ prep.setLong(8, (Long) (rowData.get(COLUMN.MEMORY_THREED.index)));
+ prep.setLong(9, (Long) (rowData.get(COLUMN.MEMORY_GEM.index)));
+ prep.setInt(10, (Integer) (rowData.get(COLUMN.THREAD_COUNT.index)));
+ prep.setLong(11, (Long) (rowData.get(COLUMN.HEAP_ALLOCATION_TOTAL_BYTE.index)));
+ setArrayToPreparedStatement(COLUMN.HEAP_ALLOCATION_BINARY_ID.index, DBConstants.DBTYPE_INT4, prep, rowData);
+ setArrayToPreparedStatement(COLUMN.HEAP_ALLOCATION_BYTE.index, DBConstants.DBTYPE_LONG, prep, rowData);
+ setArrayToPreparedStatement(COLUMN.TID.index, DBConstants.DBTYPE_INT4, prep, rowData);
+ setArrayToPreparedStatement(COLUMN.THREAD_LOAD.index, DBConstants.DBTYPE_FLOAT, prep, rowData);
+
} catch (SQLException e) {
Logger.exception(e);
isPrepared = false;
public List<Object> extractDataFromResultSet(ResultSet rs) {
List<Object> row = new ArrayList<Object>();
try {
- row.add(Long.valueOf(rs.getLong(1)));
- row.add(Integer.valueOf(rs.getInt(2)));
- row.add(Float.valueOf(rs.getFloat(3)));
- row.add(Long.valueOf(rs.getLong(4)));
- row.add(Long.valueOf(rs.getLong(5)));
- row.add(Long.valueOf(rs.getLong(6)));
- row.add(Long.valueOf(rs.getLong(7)));
- row.add(Integer.valueOf(rs.getInt(8)));
- row.add(Long.valueOf(rs.getLong(9)));
- row.add(getArrayFromResultSet(rs, 10, Integer.valueOf(0)));
- row.add(getArrayFromResultSet(rs, 11, Long.valueOf(0)));
- row.add(getArrayFromResultSet(rs, 12, Integer.valueOf(0)));
- row.add(getArrayFromResultSet(rs, 13, Float.valueOf(0)));
+ int index = 1;
+
+ row.add(Long.valueOf(rs.getLong(index++)));
+ row.add(Integer.valueOf(rs.getInt(index++)));
+ row.add(Float.valueOf(rs.getFloat(index++)));
+ row.add(Long.valueOf(rs.getLong(index++)));
+ row.add(Long.valueOf(rs.getLong(index++)));
+ row.add(Long.valueOf(rs.getLong(index++)));
+ row.add(Long.valueOf(rs.getLong(index++)));
+ row.add(Long.valueOf(rs.getLong(index++)));
+ row.add(Long.valueOf(rs.getLong(index++)));
+ row.add(Integer.valueOf(rs.getInt(index++)));
+ row.add(Long.valueOf(rs.getLong(index++)));
+ row.add(getArrayFromResultSet(rs, index++, Integer.valueOf(0)));
+ row.add(getArrayFromResultSet(rs, index++, Long.valueOf(0)));
+ row.add(getArrayFromResultSet(rs, index++, Integer.valueOf(0)));
+ row.add(getArrayFromResultSet(rs, index++, Float.valueOf(0)));
+
} catch (SQLException e) {
Logger.exception(e);
return null;
\r
import java.util.ArrayList;\r
import java.util.HashMap;\r
-import java.util.HashSet;\r
import java.util.List;\r
import java.util.Map;\r
\r
}\r
\r
public List<List<Object>> remainedAllocatedListForRange(long startTime, long endTime, String targetPIDs) {\r
+ int current_alloc_count = 0;\r
+ int current_free_count = 0;\r
\r
- int current_alloc_count = HeapDataManager.getInstance().getColumnCount(MemAllocDBTable.TABLENAME,\r
+ if(startTime == 0 && endTime == 0) {\r
+ current_alloc_count = HeapDataManager.getInstance().getColumnCount(MemAllocDBTable.TABLENAME,\r
MemAllocDBTable.COLUMN.SEQUENCE_NUMBER.name, MemAllocDBTable.COLUMN.ALLOCATED_TIME.name,\r
startTime, endTime, targetPIDs);\r
- int current_free_count = HeapDataManager.getInstance().getColumnCount(MemFreeDBTable.TABLENAME,\r
+ current_free_count = HeapDataManager.getInstance().getColumnCount(MemFreeDBTable.TABLENAME,\r
MemFreeDBTable.COLUMN.SEQUENCE_NUMBER.name, MemFreeDBTable.COLUMN.FREE_TIME.name,\r
startTime, endTime, targetPIDs);\r
- \r
- if(startTime == 0 && endTime == 0) {\r
+\r
if(current_alloc_count == PREV_ALLOC_COUNT && current_free_count == PREV_FREE_COUNT) {\r
if(savedRemaindedList != null && savedRemaindedList.size() != 0){\r
//Logger.info("Used old data");\r
}\r
\r
private List<List<Object>> makeRemainedAllocatedList(List<List<Object>> allocData, List<List<Object>> freeData) {\r
+ Map<Long, List<Long>> addressMap = new HashMap<Long, List<Long>>();\r
+ List<List<Object>> output = new ArrayList<List<Object>>();\r
\r
- Map<String, List<List<Object>>> addresMap = new HashMap<String, List<List<Object>>>();\r
- HashSet<Integer> removeindex = new HashSet<Integer>();\r
+ for (int i = 0; i < freeData.size(); i++) {\r
+ List<Object> iFreeData = freeData.get(i);\r
+ \r
+ long freetime = (Long) iFreeData.get(MemFreeDBTable.COLUMN.FREE_TIME.index);\r
+ long address = (Long) iFreeData.get(MemFreeDBTable.COLUMN.ALLOCATED_ADDRESS.index);\r
+ \r
+ if(!addressMap.containsKey(address)) {\r
+ List<Long> newlist = new ArrayList<Long>();\r
+ addressMap.put(address, newlist);\r
+ }\r
+\r
+ addressMap.get(address).add(freetime);\r
+ }\r
\r
int allocDataSize = allocData.size(); \r
- for (int j = 0; j < allocDataSize; j++) {\r
- List<Object> iAllocData = allocData.get(j);\r
+ for (int i = 0; i < allocDataSize; i++) {\r
+ List<Object> iAllocData = allocData.get(i);\r
+ boolean live = true;\r
+ long alloctime = (Long) iAllocData.get(MemAllocDBTable.COLUMN.ALLOCATED_TIME.index);\r
long address = (Long) iAllocData.get(MemAllocDBTable.COLUMN.ALLOCATED_ADDRESS.index);\r
- long seqnum = (Long) iAllocData.get(MemAllocDBTable.COLUMN.SEQUENCE_NUMBER.index);\r
+ \r
+ if(addressMap.containsKey(address)) {\r
+ int size = addressMap.get(address).size();\r
+ for(int j = 0; j < size ; j++) {\r
+ Long freetime = addressMap.get(address).get(j);\r
+ \r
+ if(alloctime <= freetime) {\r
+ live = false;\r
+ addressMap.get(address).remove(j);\r
+ break;\r
+ }\r
+ }\r
+ }\r
+ \r
+ if(live == true) {\r
+ output.add(iAllocData);\r
+ }\r
+ }\r
+\r
+ return output;\r
+ }\r
+/*\r
+ private List<List<Object>> makeRemainedAllocatedList(List<List<Object>> allocData, List<List<Object>> freeData) {\r
+\r
+ Map<String, List<List<Object>>> addressMap = new HashMap<String, List<List<Object>>>();\r
+ HashSet<Integer> removeindexlist = new HashSet<Integer>();\r
+ \r
+ int allocDataSize = allocData.size(); \r
+ for (int removeindex = 0; removeindex < allocDataSize; removeindex++) {\r
+ List<Object> iAllocData = allocData.get(removeindex);\r
+ long alloctime = (Long) iAllocData.get(MemAllocDBTable.COLUMN.ALLOCATED_ADDRESS.index);\r
+ long address = (Long) iAllocData.get(MemAllocDBTable.COLUMN.ALLOCATED_ADDRESS.index); \r
int binaryId = (Integer) iAllocData.get(MemAllocDBTable.COLUMN.CALLER_LIBRARY_ID.index);\r
\r
String keystring = String.format("%d-%d", address, binaryId);\r
\r
- if(addresMap.containsKey(keystring)) {\r
- List<Object> onedata = new ArrayList<Object>();\r
- onedata.add(seqnum);\r
- onedata.add(j);\r
- \r
- addresMap.get(keystring).add(onedata);\r
- }\r
- else {\r
+ if(!addressMap.containsKey(keystring)) {\r
List<List<Object>> newlist = new ArrayList<List<Object>>();\r
- \r
- List<Object> onedata = new ArrayList<Object>();\r
- onedata.add(seqnum);\r
- onedata.add(j);\r
- \r
- newlist.add(onedata);\r
- addresMap.put(keystring, newlist);\r
+ addressMap.put(keystring, newlist);\r
}\r
+ \r
+ List<Object> onedata = new ArrayList<Object>();\r
+ onedata.add(alloctime);\r
+ onedata.add(removeindex);\r
+ \r
+ addressMap.get(keystring).add(onedata);\r
}\r
\r
for (int i = 0; i < freeData.size(); i++) {\r
List<Object> iFreeData = freeData.get(i);\r
\r
- long address = (Long) iFreeData.get(MemFreeDBTable.COLUMN.ALLOCATED_ADDRESS.index);\r
- long seqnum = (Long) iFreeData.get(MemFreeDBTable.COLUMN.SEQUENCE_NUMBER.index);\r
+ long freetime = (Long) iFreeData.get(MemFreeDBTable.COLUMN.FREE_TIME.index);\r
+ long address = (Long) iFreeData.get(MemFreeDBTable.COLUMN.ALLOCATED_ADDRESS.index); \r
int binaryId = (Integer) iFreeData.get(MemFreeDBTable.COLUMN.CALLER_LIBRARY_ID.index);\r
\r
String keystring = String.format("%d-%d", address, binaryId);\r
\r
- if(addresMap.containsKey(keystring)) {\r
- int size = addresMap.get(keystring).size();\r
+ if(addressMap.containsKey(keystring)) {\r
+ int size = addressMap.get(keystring).size();\r
for(int j = 0; j < size ; j++) {\r
- List<Object> onedata = addresMap.get(keystring).get(j);\r
+ List<Object> onedata = addressMap.get(keystring).get(j);\r
\r
- if((Long) onedata.get(0) <= seqnum) {\r
- removeindex.add((Integer) onedata.get(1));\r
- addresMap.get(keystring).remove(j);\r
+ if((Long) onedata.get(0) <= freetime) {\r
+ // 1 : removeindex\r
+ removeindexlist.add((Integer) onedata.get(1));\r
+ addressMap.get(keystring).remove(j);\r
break;\r
}\r
}\r
}\r
else {\r
- //Logger.info("Unknow : 0x%s", Long.toHexString(address));\r
+ //Logger.info("Unknown : 0x%s", Long.toHexString(address));\r
}\r
}\r
\r
List<List<Object>> output = new ArrayList<List<Object>>();\r
\r
for (int j = 0; j < allocDataSize; j++) {\r
- if(!removeindex.contains(j)) {\r
+ if(!removeindexlist.contains(j)) {\r
output.add(allocData.get(j));\r
}\r
}\r
\r
- return output; \r
+ return output;\r
}\r
- \r
+*/ \r
public void removeSelection() {\r
table.removeAll();\r
updateTable();\r
import org.tizen.dynamicanalyzer.ui.widgets.table.DefaultTableComparator;\r
import org.tizen.dynamicanalyzer.ui.widgets.table.TableColumnSizePackListener;\r
import org.tizen.dynamicanalyzer.util.Logger;\r
+import org.tizen.dynamicanalyzer.utils.Formatter;\r
\r
public class MemoryDetailsTable extends DATreeComposite {\r
\r
List<Object> data = new ArrayList<Object>();\r
\r
// add name\r
- text.add("System (Used KB)");\r
+ text.add("System (Used)");\r
data.add(parentString);\r
\r
// add current data\r
- text.add(String.format("%,d", currentmemory / 1024));\r
+ text.add(Formatter.toByteFormat(currentmemory));\r
data.add(currentmemory);\r
\r
for(int i = 1 ; i < sorteddata.size() ; i++) {\r
- text.add(String.format("%,d", sorteddata.get(i) / 1024));\r
+ text.add(Formatter.toByteFormat(sorteddata.get(i)));\r
data.add(sorteddata.get(i));\r
}\r
\r
}\r
\r
private TreeInput makeprocessMemory(int targetID) {\r
+ if(Global.MEMPSENABLE) {\r
+ return NewMemoryData(targetID);\r
+ }\r
+ else {\r
+ return OldMemoryData(targetID);\r
+ }\r
+ }\r
+ \r
+ private TreeInput NewMemoryData(int targetID) {\r
DATableDataFormat tableData = new DATableDataFormat(keyindex++);\r
- String parentString = String.format("Process #%s (Total KB)", targetID);\r
+ String parentString = String.format("Process #%s", targetID);\r
\r
tableData.setObject(parentString);\r
\r
List<Object> data = new ArrayList<Object>();\r
\r
String tablename = ProcessMemoryDBTable.getTablename(); \r
- String timeString = ProcessMemoryDBTable.SAMPLING_TIME;\r
+ String timeString = ProcessMemoryDBTable.COLUMN.SAMPLING_TIME.name;\r
+ \r
+ // These columns will be changed to 'memps' data.\r
+ String columnNamePSS = ProcessMemoryDBTable.COLUMN.MEMORY_PSS.name;\r
+ String columnNameTHREED = ProcessMemoryDBTable.COLUMN.MEMORY_THREED.name;\r
+ String columnNameGEM = ProcessMemoryDBTable.COLUMN.MEMORY_GEM.name;\r
+ \r
+ // This data will be changed to Total data.\r
+ List<Long> processPSS = \r
+ MemoryDataManager.getInstance().getColumnLongFromDB(tablename, columnNamePSS, timeString, targetID, StartTime, EndTime);\r
+ \r
+ if(processPSS.size() == 0) {\r
+ return null;\r
+ }\r
+\r
+ List<Long> processTHREED = \r
+ MemoryDataManager.getInstance().getColumnLongFromDB(tablename, columnNameTHREED, timeString, targetID, StartTime, EndTime);\r
+ List<Long> processGEM = \r
+ MemoryDataManager.getInstance().getColumnLongFromDB(tablename, columnNameGEM, timeString, targetID, StartTime, EndTime);\r
+ \r
+ List<Long> sorteddataPSS = SortMemoryData(processPSS);\r
+ List<Long> sorteddataThreeD = SortMemoryData(processTHREED);\r
+ List<Long> sorteddataGem = SortMemoryData(processGEM);\r
+ \r
+ long currentPSS = 0;\r
+ long currentThreed = 0;\r
+ long currentGem = 0;\r
+ \r
+ if(Current != -1) {\r
+ currentPSS = MemoryDataManager.getInstance().getCurrentColumnLongFromDB(tablename, columnNamePSS, timeString, targetID, Current);\r
+ currentThreed = MemoryDataManager.getInstance().getCurrentColumnLongFromDB(tablename, columnNameTHREED, timeString, targetID, Current);\r
+ currentGem = MemoryDataManager.getInstance().getCurrentColumnLongFromDB(tablename, columnNameGEM, timeString, targetID, Current);\r
+ sorteddataPSS.set(0, currentPSS);\r
+ sorteddataThreeD.set(0, currentThreed);\r
+ sorteddataGem.set(0, currentGem);\r
+ }\r
+ \r
+ // add title\r
+ text.add(parentString);\r
+ data.add(targetID);\r
+ \r
+ for(int i = 0 ; i < sorteddataPSS.size() ; i++) {\r
+ long total = sorteddataPSS.get(i) + sorteddataThreeD.get(i) + sorteddataGem.get(i);\r
+ text.add(Formatter.toByteFormat(total));\r
+ data.add(total);\r
+ }\r
+ \r
+ output.setText(text);\r
+ tableData.getData().addAll(data);\r
+ output.setData(tableData);\r
+ output.setParent(parentString);\r
+ \r
+ Map<String, List<Long>> childrenDataMap = new HashMap<String, List<Long>>();\r
+ \r
+ childrenDataMap.put("PSS", sorteddataPSS);\r
+ childrenDataMap.put("3D", sorteddataThreeD);\r
+ childrenDataMap.put("GEM(ALLOC)", sorteddataGem);\r
+ \r
+ for(Map.Entry<String, List<Long>> entry : childrenDataMap.entrySet()) {\r
+ makeChildTree(entry.getValue(), output, entry.getKey(), parentString);\r
+ }\r
+ \r
+ return output;\r
+ }\r
+ \r
+ private TreeInput OldMemoryData(int targetID) {\r
+ DATableDataFormat tableData = new DATableDataFormat(keyindex++);\r
+ String parentString = String.format("PSS (PID #%d)", targetID);\r
+\r
+ tableData.setObject(parentString);\r
+\r
+ TreeInput output = new TreeInput();\r
+ List<String> text = new ArrayList<String>();\r
+ List<Object> data = new ArrayList<Object>();\r
+\r
+ String tablename = ProcessMemoryDBTable.getTablename(); \r
+ String timeString = ProcessMemoryDBTable.COLUMN.SAMPLING_TIME.name;\r
\r
// These columns will be changed to 'memps' data.\r
- String columnNamePSS = ProcessMemoryDBTable.MEMORY_PSS;\r
- String columnNameRSS = ProcessMemoryDBTable.MEMORY_RESIDENT;\r
- String columnNameVSS = ProcessMemoryDBTable.MEMORY_VIRTUAL;\r
+ String columnNamePSS = ProcessMemoryDBTable.COLUMN.MEMORY_PSS.name;\r
+ String columnNameRSS = ProcessMemoryDBTable.COLUMN.MEMORY_RESIDENT.name;\r
+ String columnNameVSS = ProcessMemoryDBTable.COLUMN.MEMORY_VIRTUAL.name;\r
\r
// This data will be changed to Total data.\r
List<Long> processPSS = \r
data.add(targetID);\r
\r
for(int i = 0 ; i < sorteddataPSS.size() ; i++) {\r
- text.add(String.format("%,d", sorteddataPSS.get(i) / 1024));\r
+ text.add(Formatter.toByteFormat(sorteddataPSS.get(i)));\r
data.add(sorteddataPSS.get(i));\r
}\r
\r
}\r
\r
private TreeInput makeHeapData(int targetID) { \r
- String parentString = "Heap (Total KB)";\r
+ String parentString = "Heap (Total)";\r
\r
DATableDataFormat tableData = new DATableDataFormat(keyindex++);\r
tableData.setObject(parentString);\r
data.add(targetID);\r
\r
for(int i = 0 ; i < parentsdata.size() ; i++) {\r
- text.add(String.format("%,d", parentsdata.get(i) / 1024));\r
+ text.add(Formatter.toByteFormat(parentsdata.get(i)));\r
data.add(parentsdata.get(i));\r
}\r
\r
data.add(childName);\r
\r
for(int i = 0 ; i < childdata.size() ; i++) {\r
- text.add(String.format("%,d", childdata.get(i) / 1024));\r
+ text.add(Formatter.toByteFormat(childdata.get(i)));\r
data.add(childdata.get(i));\r
}\r
\r
for(int k = 0 ; k < processDataList.size() ; k++) {\r
List<Object> processData = processDataList.get(k);\r
// 9 : HEAP_ALLOCATION_BINARY_ID\r
- List<Object> binaryIDList = cast(processData.get(9));\r
+ List<Object> binaryIDList = cast(processData.get(ProcessMemoryDBTable.COLUMN.HEAP_ALLOCATION_BINARY_ID.index));\r
\r
// 10 : allocated size by libraries\r
- List<Object> allocByteList = cast(processData.get(10));\r
+ List<Object> allocByteList = cast(processData.get(ProcessMemoryDBTable.COLUMN.HEAP_ALLOCATION_BYTE.index));\r
\r
for(int i = 0; i < binaryIDList.size() ; i++) {\r
Integer binaryID = (Integer) binaryIDList.get(i);\r
import org.tizen.dynamicanalyzer.ui.widgets.table.DefaultTableComparator;\r
import org.tizen.dynamicanalyzer.ui.widgets.table.TableColumnSizePackListener;\r
import org.tizen.dynamicanalyzer.util.Logger;\r
+import org.tizen.dynamicanalyzer.utils.Formatter;\r
\r
public class MemoryStatisticsTable extends DATableComposite {\r
\r
\r
private int PREV_STATIC_ALLOC_COUNT;\r
private int PREV_STATIC_FREE_COUNT;\r
+\r
+ private final int PRESISTENT_SIZE_INDEX = 0; \r
+ private final int PRESISTENT_COUNT_INDEX = 1;\r
+ private final int FREE_COUNT_INDEX = 2;\r
+ private final int TOTAL_SIZE_INDEX = 3;\r
\r
private Map<Integer,List<Object>> savedRemaindedStatic = new HashMap<Integer,List<Object>> ();\r
\r
\r
int index = 0;\r
for(Map.Entry<Integer, List<Object>> elem : staticdatas.entrySet()) {\r
- if((Long) elem.getValue().get(1) == 0) {\r
- continue;\r
+ if((Long) elem.getValue().get(PRESISTENT_COUNT_INDEX) == 0) {\r
+ //continue;\r
}\r
\r
String apiName = Global.getLibraryName(elem.getKey());\r
}\r
\r
private Map<Integer, List<Object>> remainedAllocStaticData(long startTime, long endTime, String targetPIDs) {\r
+ int current_alloc_count = 0;\r
+ int current_free_count = 0;\r
\r
- int current_alloc_count = HeapDataManager.getInstance().getColumnCount(MemAllocDBTable.TABLENAME,\r
+ if(startTime == 0 && endTime == 0) {\r
+ current_alloc_count = HeapDataManager.getInstance().getColumnCount(MemAllocDBTable.TABLENAME,\r
MemAllocDBTable.COLUMN.SEQUENCE_NUMBER.name, MemAllocDBTable.COLUMN.ALLOCATED_TIME.name,\r
startTime, endTime, targetPIDs);\r
- int current_free_count = HeapDataManager.getInstance().getColumnCount(MemFreeDBTable.TABLENAME,\r
+ current_free_count = HeapDataManager.getInstance().getColumnCount(MemFreeDBTable.TABLENAME,\r
MemFreeDBTable.COLUMN.SEQUENCE_NUMBER.name, MemFreeDBTable.COLUMN.FREE_TIME.name,\r
startTime, endTime, targetPIDs);\r
- \r
- if(startTime == 0 && endTime == 0) {\r
+\r
if(current_alloc_count == PREV_STATIC_ALLOC_COUNT && current_free_count == PREV_STATIC_FREE_COUNT) {\r
if(savedRemaindedStatic != null && savedRemaindedStatic.size() != 0){\r
//Logger.info("Used old data");\r
}\r
\r
private Map<Integer, List<Object>> makeRemainedAllocatedStatic(List<List<Object>> allocData, List<List<Object>> freeData) {\r
- Map<String, List<List<Object>>> addresMap = new HashMap<String, List<List<Object>>>();\r
- Map<Integer, List<Object>> staticMap = new HashMap<Integer, List<Object>>();\r
+ Map<Long, List<List<Object>>> addressMap = new HashMap<Long, List<List<Object>>>();\r
+ Map<Integer, List<Object>> libStatisticMap = new HashMap<Integer, List<Object>>();\r
\r
int allocDataSize = allocData.size(); \r
for (int j = 0; j < allocDataSize; j++) {\r
List<Object> iAllocData = allocData.get(j);\r
\r
long address = (Long) iAllocData.get(MemAllocDBTable.COLUMN.ALLOCATED_ADDRESS.index);\r
- long seqnum = (Long) iAllocData.get(MemAllocDBTable.COLUMN.SEQUENCE_NUMBER.index);\r
+ long alloctime = (Long) iAllocData.get(MemAllocDBTable.COLUMN.ALLOCATED_TIME.index);\r
long allocSize = (Long) iAllocData.get(MemAllocDBTable.COLUMN.ALLOCATED_MEMORY_SIZE.index);\r
int binaryId = (Integer) iAllocData.get(MemAllocDBTable.COLUMN.CALLER_LIBRARY_ID.index);\r
- String keystring = String.format("%d-%d", address, binaryId);\r
\r
- if(addresMap.containsKey(keystring)) {\r
- List<Object> onedata = new ArrayList<Object>();\r
- onedata.add(seqnum);\r
- onedata.add(allocSize);\r
- \r
- addresMap.get(keystring).add(onedata);\r
- }\r
- else {\r
+ if(!addressMap.containsKey(address)) {\r
List<List<Object>> newlist = new ArrayList<List<Object>>();\r
- \r
- List<Object> onedata = new ArrayList<Object>();\r
- onedata.add(seqnum);\r
- onedata.add(allocSize);\r
- \r
- newlist.add(onedata);\r
- addresMap.put(keystring, newlist);\r
+ addressMap.put(address, newlist);\r
}\r
\r
- if(staticMap.containsKey(binaryId)) {\r
- List<Object> oldbinary = staticMap.get(binaryId);\r
+ List<Object> onedata = new ArrayList<Object>();\r
+ onedata.add(alloctime);\r
+ onedata.add(allocSize);\r
+ onedata.add(binaryId);\r
+ \r
+ addressMap.get(address).add(onedata);\r
+ \r
+ if(libStatisticMap.containsKey(binaryId)) {\r
+ List<Object> libstaticdata = libStatisticMap.get(binaryId);\r
\r
- oldbinary.set(0, (Long)oldbinary.get(0) + allocSize);\r
- oldbinary.set(1, (Long)oldbinary.get(1) + 1);\r
- oldbinary.set(3, (Long)oldbinary.get(3) + allocSize);\r
+ libstaticdata.set(PRESISTENT_SIZE_INDEX, (Long)libstaticdata.get(PRESISTENT_SIZE_INDEX) + allocSize);\r
+ libstaticdata.set(PRESISTENT_COUNT_INDEX, (Long)libstaticdata.get(PRESISTENT_COUNT_INDEX) + 1);\r
+ libstaticdata.set(TOTAL_SIZE_INDEX, (Long)libstaticdata.get(TOTAL_SIZE_INDEX) + allocSize);\r
\r
- staticMap.put(binaryId, oldbinary);\r
+ libStatisticMap.put(binaryId, libstaticdata);\r
}\r
else {\r
List<Object> newbinary = new ArrayList<Object>();\r
\r
+ /*\r
+ * 0: allocated size\r
+ * 1: allocated count\r
+ * 2: free count\r
+ * 3 : total size\r
+ */\r
+ \r
newbinary.add(allocSize);\r
newbinary.add((long) 1); \r
newbinary.add((long) 0);\r
newbinary.add(allocSize);\r
\r
- staticMap.put(binaryId, newbinary);\r
+ libStatisticMap.put(binaryId, newbinary);\r
}\r
}\r
\r
for (int i = 0; i < freeData.size(); i++) {\r
List<Object> iFreeData = freeData.get(i);\r
long address = (Long) iFreeData.get(MemFreeDBTable.COLUMN.ALLOCATED_ADDRESS.index);\r
- long seqnum = (Long) iFreeData.get(MemFreeDBTable.COLUMN.SEQUENCE_NUMBER.index);\r
- int binaryId = (Integer) iFreeData.get(MemFreeDBTable.COLUMN.CALLER_LIBRARY_ID.index);\r
- \r
- String keystring = String.format("%d-%d", address, binaryId);\r
+ long freetime = (Long) iFreeData.get(MemFreeDBTable.COLUMN.FREE_TIME.index);\r
\r
- if(addresMap.containsKey(keystring)) {\r
- int size = addresMap.get(keystring).size();\r
- for(int j = 0; j < size ; j++) {\r
- List<Object> onedata = addresMap.get(keystring).get(j);\r
+ if(addressMap.containsKey(address)) {\r
+ int size = addressMap.get(address).size();\r
+ \r
+ for(int removeindex = 0; removeindex < size ; removeindex++) {\r
+ List<Object> onedata = addressMap.get(address).get(removeindex);\r
\r
- if((Long) onedata.get(0) <= seqnum) {\r
- long allocSize = (Long) onedata.get(1);\r
+ if((Long) onedata.get(0) <= freetime) {\r
+ long freeSize = (Long) onedata.get(1);\r
+ int binaryId = (Integer) onedata.get(2);\r
\r
- if(staticMap.containsKey(binaryId)) {\r
- List<Object> oldbinary = staticMap.get(binaryId);\r
- \r
- oldbinary.set(0, (Long)oldbinary.get(0) - allocSize);\r
- oldbinary.set(1, (Long)oldbinary.get(1) - 1);\r
- oldbinary.set(2, (Long)oldbinary.get(2) + 1);\r
+ if(libStatisticMap.containsKey(binaryId)) {\r
+ List<Object> libstaticdata = libStatisticMap.get(binaryId);\r
\r
- staticMap.put(binaryId, oldbinary);\r
- }\r
- else {\r
- List<Object> newbinary = new ArrayList<Object>();\r
- \r
- newbinary.add((long) (0 - allocSize));\r
- newbinary.add((long) 0);\r
- newbinary.add((long) 1);\r
- newbinary.add((long) 0);\r
+ libstaticdata.set(PRESISTENT_SIZE_INDEX, (Long)libstaticdata.get(PRESISTENT_SIZE_INDEX) - freeSize);\r
+ libstaticdata.set(PRESISTENT_COUNT_INDEX, (Long)libstaticdata.get(PRESISTENT_COUNT_INDEX) - 1);\r
+ libstaticdata.set(FREE_COUNT_INDEX, (Long)libstaticdata.get(FREE_COUNT_INDEX) + 1);\r
\r
- staticMap.put(binaryId, newbinary);\r
+ libStatisticMap.put(binaryId, libstaticdata); \r
}\r
\r
- addresMap.get(keystring).remove(j);\r
+ addressMap.get(address).remove(removeindex);\r
break;\r
}\r
}\r
//Logger.info("Unknow : 0x%s", Long.toHexString(address));\r
}\r
}\r
- return staticMap;\r
+ return libStatisticMap;\r
}\r
\r
private TableInput makeTreeInputForDatas(String path, List<Object> staticdata, int index) {\r
\r
text.add(libname);\r
data.add(libname);\r
- // Persistent byte\r
+ // Persistent byte \r
Long PByte = (Long) staticdata.get(0);\r
+ text.add(Formatter.toByteFormat(PByte));\r
data.add(PByte);\r
-\r
- String byteunit = "B"; \r
- if (PByte > 1024) {\r
- PByte /= 1024;\r
- byteunit = "KB";\r
- } \r
- text.add(String.format("%,d %s", PByte, byteunit));\r
\r
// Persistent count\r
//Integer PCount = (Integer) staticdata.get(1);\r
data.add(FCount);\r
\r
// Total Byte\r
- Long TotalByte = (Long) staticdata.get(3); \r
+ Long TotalByte = (Long) staticdata.get(3);\r
+ text.add(Formatter.toByteFormat(TotalByte));\r
data.add(TotalByte);\r
\r
- byteunit = "B"; \r
- if (TotalByte > 1024) {\r
- TotalByte /= 1024; \r
- byteunit = "KB";\r
- }\r
- text.add(String.format("%,d %s", TotalByte, byteunit));\r
-\r
// Total count\r
//Integer TotalCount = PCount + FCount;\r
Long TotalCount = PCount + FCount;\r
import org.tizen.dynamicanalyzer.resources.ImageResources;
import org.tizen.dynamicanalyzer.ui.common.TimelineChartMouseEventListener;
import org.tizen.dynamicanalyzer.ui.common.TimelineChartMouseTrackAdapter;
+import org.tizen.dynamicanalyzer.ui.memory.data.ProcessMemoryDBTable;
import org.tizen.dynamicanalyzer.ui.timeline.TargetProcessDBTable;
import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants;
import org.tizen.dynamicanalyzer.ui.toolbar.Toolbar;
private final int VSS = 0;
private final int RSS = 1;
private final int PSS = 2;
-
+ private final int NEW_PSS = 0;
+ private final int NEW_THREED = 1;
+ private final int NEW_GEM = 2;
+
private Map<Integer, DAChartBoardItem> processChartboardMap = new HashMap<Integer, DAChartBoardItem>();
private Map<Integer, String> processNameMap = new HashMap<Integer, String>();
private DAChartBoardItem parentBoardItem;
private List<DAChartSeries> createChartSeries() {
List<DAChartSeries> chartSeriesList = new ArrayList<DAChartSeries>();
- DAChartSeries vssMemorySeries = new DAChartSeries(
- TimelineChartLabels.PROCESS_MEMORY_CHART_VSS,
- DAChartSeries.SERIES_STYLE_AREA, ColorResources.SERIES_COLOR_PROCESS_VSS);
- DAChartSeries rssMemorySeries = new DAChartSeries(
- TimelineChartLabels.PROCESS_MEMORY_CHART_RSS,
- DAChartSeries.SERIES_STYLE_AREA, ColorResources.SERIES_COLOR_PROCESS_RSS);
- DAChartSeries pssMemorySeries = new DAChartSeries(
+ DAChartSeries pssSeries = new DAChartSeries(
TimelineChartLabels.PROCESS_MEMORY_CHART_PSS,
DAChartSeries.SERIES_STYLE_AREA, ColorResources.SERIES_COLOR_PROCESS_PSS);
- /*
- * Insert order is important.
- */
- chartSeriesList.add(vssMemorySeries);
- chartSeriesList.add(rssMemorySeries);
- chartSeriesList.add(pssMemorySeries);
+
+ if(Global.MEMPSENABLE) {
+ DAChartSeries threeDSeries = new DAChartSeries(
+ TimelineChartLabels.PROCESS_MEMORY_CHART_THREED,
+ DAChartSeries.SERIES_STYLE_AREA, ColorResources.SERIES_COLOR_PROCESS_VSS);
+ DAChartSeries gemSeries = new DAChartSeries(
+ TimelineChartLabels.PROCESS_MEMORY_CHART_GEM,
+ DAChartSeries.SERIES_STYLE_AREA, ColorResources.SERIES_COLOR_PROCESS_RSS);
+
+ chartSeriesList.add(pssSeries);
+ chartSeriesList.add(threeDSeries);
+ chartSeriesList.add(gemSeries);
+ }
+ else {
+ DAChartSeries vssSeries = new DAChartSeries(
+ TimelineChartLabels.PROCESS_MEMORY_CHART_VSS,
+ DAChartSeries.SERIES_STYLE_AREA, ColorResources.SERIES_COLOR_PROCESS_VSS);
+ DAChartSeries rssSeries = new DAChartSeries(
+ TimelineChartLabels.PROCESS_MEMORY_CHART_RSS,
+ DAChartSeries.SERIES_STYLE_AREA, ColorResources.SERIES_COLOR_PROCESS_RSS);
+
+
+ chartSeriesList.add(vssSeries);
+ chartSeriesList.add(rssSeries);
+ chartSeriesList.add(pssSeries);
+ }
return chartSeriesList;
}
List<List<Object>> data = processDataMap.get(pid);
for (int i = 0; i < data.size(); i++) {
List<Object> row = data.get(i);
- double time = (Long) row.get(TargetProcessDBTable.COLUMN.SAMPLING_TIME.ordinal())
- / TimelineConstants.MEGA_DOUBLE;
- long vssMemory = (Long) row
- .get(TargetProcessDBTable.COLUMN.MEMORY_VIRTUAL.ordinal());
- long rssMemory = (Long) row
- .get(TargetProcessDBTable.COLUMN.MEMORY_RESIDENT.ordinal());
- long pssMemory = (Long) row.get(TargetProcessDBTable.COLUMN.MEMORY_PSS
- .ordinal());
- seriesList.get(VSS).addSeriesItem(
- new DAChartSeriesItem(time, vssMemory, Formatter
- .toByteFormat(vssMemory)));
- seriesList.get(RSS).addSeriesItem(
- new DAChartSeriesItem(time, rssMemory, Formatter
- .toByteFormat(rssMemory)));
- seriesList.get(PSS).addSeriesItem(
- new DAChartSeriesItem(time, pssMemory, Formatter
- .toByteFormat(pssMemory)));
+ double time = (Long) row.get(ProcessMemoryDBTable.COLUMN.SAMPLING_TIME.index) / TimelineConstants.MEGA_DOUBLE;
+ long vssMemory = (Long) row.get(ProcessMemoryDBTable.COLUMN.MEMORY_VIRTUAL.index);
+ long rssMemory = (Long) row.get(ProcessMemoryDBTable.COLUMN.MEMORY_RESIDENT.index);
+ long pssMemory = (Long) row.get(ProcessMemoryDBTable.COLUMN.MEMORY_PSS.index);
+
+ if(Global.MEMPSENABLE) {
+ long threeDMemory = (Long) row.get(ProcessMemoryDBTable.COLUMN.MEMORY_THREED.index);
+ long gemMemory = (Long) row.get(ProcessMemoryDBTable.COLUMN.MEMORY_GEM.index);
+
+ seriesList.get(NEW_PSS).addSeriesItem(
+ new DAChartSeriesItem(time, pssMemory, Formatter
+ .toByteFormat(pssMemory)));
+ seriesList.get(NEW_THREED).addSeriesItem(
+ new DAChartSeriesItem(time, threeDMemory, Formatter
+ .toByteFormat(threeDMemory)));
+ seriesList.get(NEW_GEM).addSeriesItem(
+ new DAChartSeriesItem(time, gemMemory, Formatter
+ .toByteFormat(gemMemory)));
+
+ }
+ else {
+ seriesList.get(VSS).addSeriesItem(
+ new DAChartSeriesItem(time, vssMemory, Formatter
+ .toByteFormat(vssMemory)));
+ seriesList.get(RSS).addSeriesItem(
+ new DAChartSeriesItem(time, rssMemory, Formatter
+ .toByteFormat(rssMemory)));
+ seriesList.get(PSS).addSeriesItem(
+ new DAChartSeriesItem(time, pssMemory, Formatter
+ .toByteFormat(pssMemory)));
+ }
}
}
}
import org.tizen.dynamicanalyzer.ui.common.TimelineChartMouseEventListener;
import org.tizen.dynamicanalyzer.ui.common.TimelineChartMouseTrackAdapter;
import org.tizen.dynamicanalyzer.ui.info.screenshot.ScreenshotDataManager;
+import org.tizen.dynamicanalyzer.ui.memory.data.MemoryDataManager;
import org.tizen.dynamicanalyzer.ui.timeline.CustomDataDBTable;
import org.tizen.dynamicanalyzer.ui.timeline.LifeCycleDBTable;
import org.tizen.dynamicanalyzer.ui.timeline.SystemDataDBTable;
import org.tizen.dynamicanalyzer.ui.timeline.chart.DeviceChart;
import org.tizen.dynamicanalyzer.ui.timeline.chart.DiskIOChart;
import org.tizen.dynamicanalyzer.ui.timeline.chart.EnergyChart;
-import org.tizen.dynamicanalyzer.ui.timeline.chart.HeapChart;
import org.tizen.dynamicanalyzer.ui.timeline.chart.NetworkIOChart;
import org.tizen.dynamicanalyzer.ui.timeline.chart.ProcessMemoryChart;
import org.tizen.dynamicanalyzer.ui.timeline.chart.ScreenshotChart;
initChartMap(new CPUChart(TimelinePage.pageID));
initChartMap(new CPUCoreChart(TimelinePage.pageID));
initChartMap(new CPUFrequencyChart(TimelinePage.pageID));
- initChartMap(new HeapChart(TimelinePage.pageID));
- initChartMap(new ProcessMemoryChart(TimelinePage.pageID));
+ //initChartMap(new HeapChart(TimelinePage.pageID));
initChartMap(new SystemMemoryChart(TimelinePage.pageID));
+ initChartMap(new ProcessMemoryChart(TimelinePage.pageID));
initChartMap(new ScreenshotChart(TimelinePage.pageID));
initChartMap(new UIEventChart(TimelinePage.pageID));
initChartMap(new DiskIOChart(TimelinePage.pageID));
if (Toolbar.INSTANCE != null) {
selectedPID = Toolbar.INSTANCE.getSelectedPid();
}
- Map<Integer, List<List<Object>>> targetProcessDBData = getTargetProcessDataFromDB(
- startTime, endTime, selectedPID);
+ Map<Integer, List<List<Object>>> targetProcessDBData =
+ MemoryDataManager.getInstance().getTargetProcessDataMapFromDB(startTime, endTime, selectedPID);
/*
* 2. Make series of chart
projects / sdk / tools / dynamic-analyzer.git / commitdiff