apply new Database schema : callstack unit, callstack data, function entry, function exit, function sample, profiling data, profiling child data
use new database handling APIs
calltrace table no longer has LogData
function entry, function exit, function sample are saved into separate DB table
Change-Id: I84380e174901252f99753df27fa3e54d317568b7
Signed-off-by: woojin <woojin2.jung@samsung.com>
StopProcessManager.clear();
// UserFunctionManager.getInstance().clear();
LogDataFactory.clean();
- FunctionUsageProfiler.clear();
+ FunctionUsageProfiler.getInstance().clear();
FunctionUsageProfiler.getInstance().stopThread();
RangeDataManager.getInstance().initRange();
startBinaryAddr = -1;
public static final String UNLIMITTED_ARRAY = "ARRAY[]";//$NON-NLS-1$
// types constant
- public static final String DBTYPE_INT1 = "TYNYINT";//$NON-NLS-1$
+ public static final String DBTYPE_INT1 = "TINYINT";//$NON-NLS-1$
public static final String DBTYPE_INT2 = "SMALLINT";//$NON-NLS-1$
public static final String DBTYPE_INT4 = "INTEGER";//$NON-NLS-1$
public static final String DBTYPE_INT8 = "BIGINT";//$NON-NLS-1$
} else if (rsMetaData.getColumnTypeName(i)
.contains(DBConstants.BOOLEAN)) {
rowData.add(Boolean.valueOf(rs.getBoolean(i)));
+ } else if (rsMetaData.getColumnTypeName(i)
+ .contains(DBConstants.DBTYPE_INT1)) {
+ rowData.add(Byte.valueOf(rs.getByte(i)));
} else {
DA_LOG.error("undefined type : "
+ rsMetaData.getColumnTypeName(i));
import org.tizen.dynamicanalyzer.swap.channel.data.ProcessInfo;
import org.tizen.dynamicanalyzer.swap.channel.data.ProcessInfoPackage;
import org.tizen.dynamicanalyzer.swap.logparser.DataManagerRegistry;
-import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackData;
+import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackInserter;
import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackUnit;
+import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackUnitDBTable;
import org.tizen.dynamicanalyzer.ui.network.data.NetworkDataManager;
import org.tizen.dynamicanalyzer.ui.opengl.data.GLDataManager;
import org.tizen.dynamicanalyzer.ui.range.RangeDataManager;
import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler;
import org.tizen.dynamicanalyzer.ui.summary.profiling.ProfileDataMaker;
import org.tizen.dynamicanalyzer.ui.summary.profiling.ProfilingChildData;
+import org.tizen.dynamicanalyzer.ui.summary.profiling.ProfilingChildDataDBTable;
import org.tizen.dynamicanalyzer.ui.summary.profiling.ProfilingData;
+import org.tizen.dynamicanalyzer.ui.summary.profiling.ProfilingDataDBTable;
import org.tizen.dynamicanalyzer.ui.timeline.TimelinePage;
import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
import org.tizen.dynamicanalyzer.ui.toolbar.opentrace.OpenTraceProgressManager;
AnalyzerUtil.executeCommand(ClearHandler.ID);
}
- private boolean loadCallStackData() {
- boolean isSuccess = true;
- List<List<String>> dbInfo = SqlManager.getInstance()
- .getCallStackDataFromTable();
- if (null == dbInfo) {
- DA_LOG.debug("failed - loadCallStackData");
- isSuccess = false;
- } else {
- for (int i = 0; i < dbInfo.size(); i++) {
- List<String> pInfo = dbInfo.get(i);
- int seq = Integer.parseInt(pInfo.get(0));
- String addrs = pInfo.get(1);
- if (null == addrs) {
- continue;
- }
- String[] splitAddrs = addrs.split(CommonConstants.SLASH);
- CallStackData csd = new CallStackData(seq);
- List<Long> addrList = csd.getAddrs();
- int size = splitAddrs.length;
- for (int j = 0; j < size; j++) {
- long addr = Long.parseLong(splitAddrs[j]);
- addrList.add(addr);
- }
- AnalyzerManager.getCallstackManager()
- .getCallStackDataBySeqMap().put(seq, csd);
- }
- }
- return isSuccess;
- }
-
private boolean loadCallStackApis() {
boolean isSuccess = true;
- List<List<String>> dbInfo = SqlManager.getInstance()
- .setloadCallStackApis();
- if (null == dbInfo) {
+ List<List<Object>> callStackUnits =
+ CallStackInserter.getInstance().getCallStackUnitTable()
+ .getCallStackUnitsFromDB();
+ if (null == callStackUnits) {
DA_LOG.debug("failed - loadCallStackApis");
isSuccess = false;
} else {
BaseCallstackManager callstackManager = AnalyzerManager
.getCallstackManager();
- for (int i = 0; i < dbInfo.size(); i++) {
- List<String> pInfo = dbInfo.get(i);
- long addr = Long.parseLong(pInfo.get(0));
- String api = pInfo.get(1);
- int pid = Integer.parseInt(pInfo.get(2));
- long time = Long.parseLong(pInfo.get(3));
- CallStackUnit csa = new CallStackUnit(addr, api, pid, time);
+ for (int i = 0; i < callStackUnits.size(); i++) {
+ List<Object> callStackUnit = callStackUnits.get(i);
+ int pid = (Integer) callStackUnit.get(CallStackUnitDBTable.COLUMN.PID.index);
+ String functionName = (String) callStackUnit
+ .get(CallStackUnitDBTable.COLUMN.FUNCTIONNAME.index);
+ String path = (String) callStackUnit
+ .get(CallStackUnitDBTable.COLUMN.BINARYPATH.index);
+ long addr = (Long) callStackUnit.get(CallStackUnitDBTable.COLUMN.PCADDR.index);
+ CallStackUnit csa = new CallStackUnit(addr, pid, functionName, path);
callstackManager.getCallStackApiAddrByPidMap(pid)
.put(addr, csa);
}
private boolean loadProfilingData() {
boolean isSuccess = true;
- List<List<String>> dbInfo = SqlManager.getInstance()
- .setloadProfilingData();
- if (null == dbInfo) {
+ List<List<Object>> profilingDatas = FunctionUsageProfiler.getInstance()
+ .getProfilingDataTable().getProfilingDataFromDB();
+ if (null == profilingDatas) {
DA_LOG.debug("failed - loadProfilingData");
isSuccess = false;
} else {
- for (int i = 0; i < dbInfo.size(); i++) {
- List<String> pInfo = dbInfo.get(i);
- int pid = Integer.parseInt(pInfo.get(ProfilingData.PID_INDEX));
+ for (int i = 0; i < profilingDatas.size(); i++) {
+ List<Object> profilingData = profilingDatas.get(i);
+ int pid = (Integer) profilingData.get(ProfilingDataDBTable.COLUMN.PID.index);
// possibility of extensions - network, efl, db, etc...
ProfileDataMaker profiler = FunctionUsageProfiler.getInstance()
.getProfileDataMakerByPid(pid);
- ProfilingData fupData = new ProfilingData(pInfo, profiler);
- String seq = pInfo.get(ProfilingData.SEQUENCE_INDEX);
- profiler.getProfilingDataMap().put(Integer.parseInt(seq),
- fupData);
- String symbol = pInfo.get(ProfilingData.KEY_INDEX);
- profiler.getSymbolSeqHash().put(symbol, seq);
+ int seq = (Integer) profilingData.get(ProfilingDataDBTable.COLUMN.SEQ.index);
+ byte type = (Byte) profilingData.get(ProfilingDataDBTable.COLUMN.TYPE.index);
+ int exCount = (Integer) profilingData
+ .get(ProfilingDataDBTable.COLUMN.EXCOUNT.index);
+ int inCount = (Integer) profilingData
+ .get(ProfilingDataDBTable.COLUMN.INCOUNT.index);
+ int callCount = (Integer) profilingData
+ .get(ProfilingDataDBTable.COLUMN.CALLCOUNT.index);
+ long inElapsedTime = (Long) profilingData
+ .get(ProfilingDataDBTable.COLUMN.INCLEXETIME.index);
+ long exElapsedTime = (Long) profilingData
+ .get(ProfilingDataDBTable.COLUMN.EXCLEXETIME.index);
+ String name;
+ ProfilingData fupData = null;
+ switch (type) {
+ case ProfilingData.TYPE_APPLICATION:
+ name = (String) profilingData
+ .get(ProfilingDataDBTable.COLUMN.BINARYPATH.index);
+ fupData = new ProfilingData(seq, name, exCount, inCount, callCount,
+ inElapsedTime, exElapsedTime, profiler);
+ profiler.setAppBin(fupData);
+ break;
+ case ProfilingData.TYPE_DEPENDENTLIBRARY:
+ name = (String) profilingData
+ .get(ProfilingDataDBTable.COLUMN.BINARYPATH.index);
+ fupData = new ProfilingData(seq, name, exCount, inCount, callCount,
+ inElapsedTime, exElapsedTime, profiler);
+ profiler.setDependentLib(fupData);
+ break;
+ case ProfilingData.TYPE_LIBRARY:
+ name = (String) profilingData
+ .get(ProfilingDataDBTable.COLUMN.BINARYPATH.index);
+ fupData = new ProfilingData(seq, name, exCount, inCount, callCount,
+ inElapsedTime, exElapsedTime, profiler);
+ break;
+ case ProfilingData.TYPE_FUNCTION:
+ name = (String) profilingData
+ .get(ProfilingDataDBTable.COLUMN.FUNCTIONNAME.index);
+ fupData = new ProfilingData(seq, name, exCount, inCount, callCount,
+ inElapsedTime, exElapsedTime, profiler);
+ break;
+ default: // never goes here
+ System.out.println("invalid profiling data type");
+ break;
+ }
+
+ profiler.getProfilingDataMap().put(seq, fupData);
UIDataManager.getInstance().getfunctionProfilingDataChecker()
.addProfilingData(fupData);
// restore total sample count
profiler.setTotalSampleCount(profiler.getTotalSampleCount()
+ fupData.getExCount());
}
-
- List<Integer> pids = FunctionUsageProfiler.getInstance()
- .getPidsOfProfileDataMakerMap();
- for (int i = 0; i < pids.size(); i++) {
- ProfileDataMaker profiler = FunctionUsageProfiler.getInstance()
- .getProfileDataMakerByPid(pids.get(i));
- ProfilingData ab = profiler
- .getProfilingDataByKey(FunctionUsageProfiler.APPLICATION_KEY);
- profiler.setAppBin(ab);
- ProfilingData dl = profiler
- .getProfilingDataByKey(FunctionUsageProfiler.DEPENDENT_LIB_KEY);
- profiler.setDependentLib(dl);
- }
}
return isSuccess;
}
private boolean loadProfilingChildData() {
boolean isSuccess = true;
- List<List<String>> dbInfo = SqlManager.getInstance()
- .setloadProfilingChildData();
- if (null == dbInfo) {
+ List<List<Object>> profilingChilds = FunctionUsageProfiler.getInstance()
+ .getProfilingChildDataTable().getProfilingChildDataFromDB();
+ if (null == profilingChilds) {
DA_LOG.debug("failed - loadProfilingChildData");
isSuccess = false;
} else {
- for (int i = 0; i < dbInfo.size(); i++) {
- List<String> data = dbInfo.get(i);
- if (data.size() < 2) { // why?
- continue;
- }
- int pid = Integer.parseInt(data.get(1)); // 1 == PID_INDEX
- String seqs = data.get(2); // 2 == CHILDLIST_INDEX
- String[] splitSeqs = seqs.split(CommonConstants.SLASH);
- List<Integer> childData = new ArrayList<Integer>();
- for (int ii = 0; ii < splitSeqs.length; ii++) {
- childData.add(Integer.parseInt(splitSeqs[ii]));
- }
- int key = Integer.parseInt(data.get(0));
+ for (int i = 0; i < profilingChilds.size(); i++) {
+ List<Object> data = profilingChilds.get(i);
+ int parentSeq = (Integer) data.get(ProfilingChildDataDBTable.COLUMN.SEQ.index);
+ int pid = (Integer) data.get(ProfilingChildDataDBTable.COLUMN.PID.index);
+ int childSeq = (Integer) data
+ .get(ProfilingChildDataDBTable.COLUMN.CHILDSEQ.index);
+
ProfileDataMaker profiler = FunctionUsageProfiler.getInstance()
.getProfileDataMakerByPid(pid);
- ProfilingData parent = profiler.getProfilingDataMap().get(key);
+ ProfilingData parent = profiler.getProfilingDataMap().get(parentSeq);
ProfilingChildData child = parent.getChildData();
- child.getChildren().addAll(childData);
- profiler.getChildListMap().put(data.get(0), child);
+ child.getChildren().add(childSeq);
}
}
return isSuccess;
import org.tizen.dynamicanalyzer.swap.channel.data.ProcessInfoPackage;
import org.tizen.dynamicanalyzer.swap.model.data.LogData;
import org.tizen.dynamicanalyzer.swap.model.data.ProbeCommonData;
-import org.tizen.dynamicanalyzer.swap.model.data.ProfileData;
-import org.tizen.dynamicanalyzer.swap.model.data.UserFunctionData;
import org.tizen.dynamicanalyzer.swap.platform.BinarySettingData;
import org.tizen.dynamicanalyzer.swap.platform.BinarySettingManager;
+import org.tizen.dynamicanalyzer.ui.timeline.calltrace.FunctionEntryDBTable;
import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableDataFormat;
import org.tizen.dynamicanalyzer.util.CommonUtil;
libName = pData.getLibName();
break;
case AnalyzerConstants.TYPE_TABLE_CALLTRACE:
- data = tableData.getLogData();
- if (data instanceof UserFunctionData) {
- addr = ((UserFunctionData) data).getCallerPcAddr();
- libName = ((UserFunctionData) data).getLibName();
- } else if (data instanceof ProfileData) {
- addr = ((ProfileData) data).getCallerPcAddr();
- libName = ((ProfileData) data).getLibName();
- }
- pid = data.getPid();
- time = data.getTime();
+ List<Object> calltraceData = tableData.getData();
+ addr = (Long) calltraceData.get(FunctionEntryDBTable.COLUMN.CALLERPCADDR.index);
+ libName = (String) calltraceData.get(FunctionEntryDBTable.COLUMN.BINARYPATH.index);
+ pid = (Integer) calltraceData.get(FunctionEntryDBTable.COLUMN.PID.index);
+ time = (Long) calltraceData.get(FunctionEntryDBTable.COLUMN.STARTTIME.index);
break;
- default: // normal
+ default: // normal (in case table has LogData)
data = tableData.getLogData();
ProbeCommonData wData = (ProbeCommonData) data;
addr = wData.getCallerPcAddr();
switch (tableData.getType()) {
case AnalyzerConstants.TYPE_TABLE_CALLTRACE:
- LogData data = tableData.getLogData();
- if (data instanceof UserFunctionData) {
- addr = ((UserFunctionData) data).getPcAddr();
- libName = ((UserFunctionData) data).getLibName();
- } else if (data instanceof ProfileData) {
- addr = ((ProfileData) data).getPcAddr();
- libName = ((ProfileData) data).getLibName();
- }
- pid = data.getPid();
- time = data.getTime();
+ List<Object> calltraceData = tableData.getData();
+ addr = (Long) calltraceData.get(FunctionEntryDBTable.COLUMN.PCADDR.index);
+ libName = (String) calltraceData.get(FunctionEntryDBTable.COLUMN.BINARYPATH.index);
+ pid = (Integer) calltraceData.get(FunctionEntryDBTable.COLUMN.PID.index);
+ time = (Long) calltraceData.get(FunctionEntryDBTable.COLUMN.STARTTIME.index);
break;
default:
/*
libName = pData.getLibName();
break;
case AnalyzerConstants.TYPE_TABLE_CALLTRACE:
- LogData data = tableData.getLogData();
- if (data instanceof UserFunctionData) {
- libName = ((UserFunctionData) data).getLibName();
- } else if (data instanceof ProfileData) {
- libName = ((ProfileData) data).getLibName();
- }
+ List<Object> calltraceData = tableData.getData();
+ libName = (String) calltraceData.get(FunctionEntryDBTable.COLUMN.BINARYPATH.index);
break;
default: // normal
ProbeCommonData wData = (ProbeCommonData) tableData.getLogData();
import org.tizen.dynamicanalyzer.swap.channel.data.ProcessInfoPackage;
import org.tizen.dynamicanalyzer.swap.logparser.DataManagerRegistry;
import org.tizen.dynamicanalyzer.swap.model.DATime;
+import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackInserter;
import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
import org.tizen.dynamicanalyzer.util.CommonUtil;
import org.tizen.dynamicanalyzer.util.DALogger;
// create table
DataManagerRegistry.createDBTables();
+ CallStackInserter.getInstance().createTables();
SqlManager.getInstance().createTables();
SqlManager.getInstance().createProbeTable();
}
public static DBTableManager instance = null;
private static final String TABLE_NAME_PROJECT = "project";//$NON-NLS-1$
- private static final String TABLE_NAME_CALLSTACK_UNITS = "CallstackUnits";//$NON-NLS-1$
- private static final String TABLE_NAME_CALLSTACK_DATA = "CallstackData";//$NON-NLS-1$
private static final String TABLE_NAME_FAILED_DATA = "FailedData";//$NON-NLS-1$
private static final String TABLE_NAME_LEAK_DATA = "LeakData";//$NON-NLS-1$
- private static final String TABLE_NAME_PROFILING_DATA = "ProfilingData";//$NON-NLS-1$
- private static final String TABLE_NAME_PROFILING_CHILD_DATA = "ProfilingChildData";//$NON-NLS-1$
private static final String TABLE_NAME_TARGET_INFO = "TargetInfo";//$NON-NLS-1$
private static final String TABLE_NAME_PROCESS_INFO = "ProcessInfo";//$NON-NLS-1$
private static final String TABLE_NAME_LIB_OBJ = "LibraryObject";//$NON-NLS-1$
private static List<DBTableInfo> tableInfos;
public static final int TABLE_INDEX_PROJECT = 0;
- public static final int TABLE_INDEX_CALLSTACK_UNITS = 1;
- public static final int TABLE_INDEX_CALLSTACK_DATA = 2;
- public static final int TABLE_INDEX_FAILED_DATA = 3;
- public static final int TABLE_INDEX_LEAK_DATA = 4;
- public static final int TABLE_INDEX_PROFILING_DATA = 5;
- public static final int TABLE_INDEX_PROFILING_CHILD_DATA = 6;
- public static final int TABLE_INDEX_TARGET_INFO = 7;
- public static final int TABLE_INDEX_PROCESS_INFO = 8;
- public static final int TABLE_INDEX_LIB_OBJ = 9;
- public static final int TABLE_INDEX_APINAME = 10;
+ public static final int TABLE_INDEX_FAILED_DATA = 1;
+ public static final int TABLE_INDEX_LEAK_DATA = 2;
+ public static final int TABLE_INDEX_TARGET_INFO = 3;
+ public static final int TABLE_INDEX_PROCESS_INFO = 4;
+ public static final int TABLE_INDEX_LIB_OBJ = 5;
+ public static final int TABLE_INDEX_APINAME = 6;
// public static final int TABLE_INDEX_CONTEXT_SWITCH_DATA = 12;
// public static final int TABLE_INDEX_FUNCTION_CALL_DATA = 13;
tableInfos.add(projectInfo);
}
- // "callstack units" table info block
- {
- String[] names = { CUSTOM_COLUMN_ADDR, CUSTOM_COLUMN_API,
- COMMON_COLUMN_PID, COMMON_COLUMN_TIME };
- String[] options = { "not null", EMPTY, EMPTY, EMPTY };
- String[] types = { TEXT, "VARCHAR(256)", TEXT, TEXT };
- DBTableInfo callstackUnitsTableInfo = new DBTableInfo(
- TABLE_NAME_CALLSTACK_UNITS, names, options, types);
- tableInfos.add(callstackUnitsTableInfo);
- }
-
- // "callstack data" table info block
- {
- String[] names = { CUSTOM_COLUMN_SEQ, CUSTOM_COLUMN_CALLSTACK };
- String[] options = { NOT_NULL, EMPTY };
- String[] types = { INTEGER, "VARCHAR(1024)" };
- DBTableInfo callstackDataTableInfo = new DBTableInfo(
- TABLE_NAME_CALLSTACK_DATA, names, options, types);
- tableInfos.add(callstackDataTableInfo);
- }
-
// "failed data" table info block
{
String[] names = { "Rid", "MsgId", "SeqNumber", "Time", "ApiName",
tableInfos.add(leakDataTableInfo);
}
- // "profiling data" table info block
- {
- String[] names = { CUSTOM_COLUMN_SEQ, CUSTOM_COLUMN_PID,
- CUSTOM_COLUMN_NAME, CUSTOM_COLUMN_EXCOUNT,
- CUSTOM_COLUMN_INCOUNT, CUSTOM_COLUMN_CALL_COUNT,
- CUSTOM_COLUMN_PARENT, CUSTOM_COLUMN_KEY,
- CUSTOM_COLUMN_INCL_EXETIME, CUSTOM_COLUMN_EXCL_EXETIME };
- String[] options = { NOT_NULL, NOT_NULL, EMPTY, EMPTY, EMPTY,
- EMPTY, EMPTY, EMPTY, EMPTY, EMPTY };
- String[] types = { TEXT, TEXT, "VARCHAR(512)", TEXT, TEXT, TEXT,
- "VARCHAR(512)", "VARCHAR(512)", TEXT, TEXT };
- DBTableInfo profilingDataTableInfo = new DBTableInfo(
- TABLE_NAME_PROFILING_DATA, names, options, types);
- tableInfos.add(profilingDataTableInfo);
- }
-
- // "profiling child data" table info block
- {
- String[] names = { CUSTOM_COLUMN_SEQ, CUSTOM_COLUMN_PID,
- CUSTOM_COLUMN_CHILD_LIST };
- String[] options = { NOT_NULL, NOT_NULL, EMPTY };
- String[] types = { TEXT, TEXT, "VARCHAR(1024)" };
- DBTableInfo profilingChildTableInfo = new DBTableInfo(
- TABLE_NAME_PROFILING_CHILD_DATA, names, options, types);
- tableInfos.add(profilingChildTableInfo);
- }
-
// target info
{
String[] names = { TARGET_INFO_SYS_MEM_SIZE,
import java.sql.SQLWarning;
import java.sql.Statement;
import java.util.ArrayList;
-import java.util.Collection;
import java.util.List;
-import java.util.Map;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
-import org.tizen.dynamicanalyzer.common.GlobalInformation;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
import org.tizen.dynamicanalyzer.project.Project;
-import org.tizen.dynamicanalyzer.swap.callstack.BaseCallstackManager;
import org.tizen.dynamicanalyzer.swap.channel.control.DeviceStatusInfo;
import org.tizen.dynamicanalyzer.swap.channel.data.ApiNameManager;
import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants;
import org.tizen.dynamicanalyzer.swap.model.data.LogData;
import org.tizen.dynamicanalyzer.swap.model.data.LogDataFactory;
import org.tizen.dynamicanalyzer.swap.model.format.LogFormat;
-import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackData;
-import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackUnit;
import org.tizen.dynamicanalyzer.ui.summary.failed.FailedChecker;
import org.tizen.dynamicanalyzer.ui.summary.failed.FailedData;
import org.tizen.dynamicanalyzer.ui.summary.leaks.LeakData;
import org.tizen.dynamicanalyzer.ui.summary.leaks.LeakDetector;
-import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler;
-import org.tizen.dynamicanalyzer.ui.summary.profiling.ProfileDataMaker;
-import org.tizen.dynamicanalyzer.ui.summary.profiling.ProfilingChildData;
-import org.tizen.dynamicanalyzer.ui.summary.profiling.ProfilingData;
import org.tizen.dynamicanalyzer.util.CommonUtil;
import org.tizen.dynamicanalyzer.util.DALogger;
return true;
}
- public void saveCallStackUnits() {
- BaseCallstackManager callstackManager = AnalyzerManager
- .getCallstackManager();
- DBTableInfo unitTableInfo = DBTableManager.getInstance().getTableInfo(
- DBTableManager.TABLE_INDEX_CALLSTACK_UNITS);
- List<List<String>> insetData = new ArrayList<List<String>>();
- String insertQuery = unitTableInfo.insertQuery();
- List<CallStackUnit> callstackUnits = new ArrayList<CallStackUnit>();
- List<Integer> pids = callstackManager.getPidsOfCallstackApiAddrMap();
- int size = pids.size();
- for (int i = 0; i < size; i++) {
- callstackUnits.addAll(callstackManager.getCallStackApiAddrByPidMap(
- pids.get(i)).values());
- }
-
- size = callstackUnits.size();
- for (int i = 0; i < size; i++) {
- List<String> insertRowData = new ArrayList<String>();
- try {
- CallStackUnit saveData = callstackUnits.get(i);
- insertRowData.add(Long.toString(saveData.getAddr()));
- insertRowData.add(saveData.getSymbol());
- insertRowData.add(Integer.toString(saveData.getPid()));
- insertRowData.add(Long.toString(saveData.getTime()));
- } catch (ArrayIndexOutOfBoundsException e) {
- e.printStackTrace();
- }
- insetData.add(insertRowData);
- }
- insertQuery(insertQuery, insetData);
- }
-
- public void saveCallStackData() {
- DBTableInfo callstackData = DBTableManager.getInstance().getTableInfo(
- DBTableManager.TABLE_INDEX_CALLSTACK_DATA);
- List<List<String>> insetData = new ArrayList<List<String>>();
- String insertQuery = callstackData.insertQuery();
- Collection<CallStackData> col = AnalyzerManager.getCallstackManager()
- .getCallStackDataBySeqMap().values();
- List<CallStackData> callstackDataList = new ArrayList<CallStackData>();
- callstackDataList.addAll(col);
- int size = callstackDataList.size();
- for (int i = 0; i < size; i++) {
- List<String> insetRowData = new ArrayList<String>();
- int seq = callstackDataList.get(i).getSeq();
- String addrs = makeSaveFormat(callstackDataList.get(i).getAddrs());
- try {
- insetRowData.add(Integer.toString(seq));
- insetRowData.add(addrs);
- } catch (ArrayIndexOutOfBoundsException e) {
- e.printStackTrace();
- }
- insetData.add(insetRowData);
- }
- insertQuery(insertQuery, insetData);
- }
-
- public void saveProfilingData() {
- List<Integer> pids = FunctionUsageProfiler.getInstance()
- .getPidsOfProfileDataMakerMap();
- for (int i = 0; i < pids.size(); i++) {
- ProfileDataMaker profiler = FunctionUsageProfiler.getInstance()
- .getProfileDataMakerByPid(pids.get(i));
- Map<Integer, ProfilingData> profilingDataMap = profiler
- .getProfilingDataMap();
- List<ProfilingData> pDataList = new ArrayList<ProfilingData>();
- pDataList.addAll(profilingDataMap.values());
-
- DBTableInfo profilingData = DBTableManager.getInstance()
- .getTableInfo(DBTableManager.TABLE_INDEX_PROFILING_DATA);
- String insertQuery = profilingData.insertQuery();
-
- List<List<String>> insetData = new ArrayList<List<String>>();
- int size = profilingData.getColumnNames().length;
- int count = pDataList.size();
- for (int j = 0; j < count; j++) {
- List<String> input = pDataList.get(j).getSaveData();
- List<String> insetRowData = new ArrayList<String>();
- int dataSize = input.size();
- for (int ii = 0; ii < size; ii++) {
- if (ii >= dataSize) {
- insetRowData.add(CommonConstants.EMPTY);
- } else {
- insetRowData.add(input.get(ii));
- }
- }
- insetData.add(insetRowData);
- }
- insertQuery(insertQuery, insetData);
- }
- }
-
- public void saveProfilingChildData() {
- List<Integer> pids = FunctionUsageProfiler.getInstance()
- .getPidsOfProfileDataMakerMap();
- for (int i = 0; i < pids.size(); i++) {
- ProfileDataMaker profiler = FunctionUsageProfiler.getInstance()
- .getProfileDataMakerByPid(pids.get(i));
- Map<String, ProfilingChildData> profilingDataMap = profiler
- .getChildListMap();
- List<ProfilingChildData> pDataList = new ArrayList<ProfilingChildData>();
- pDataList.addAll(profilingDataMap.values());
-
- DBTableInfo profilingChildData = DBTableManager.getInstance()
- .getTableInfo(
- DBTableManager.TABLE_INDEX_PROFILING_CHILD_DATA);
-
- List<List<String>> insetData = new ArrayList<List<String>>();
- int count = pDataList.size();
- for (int j = 0; j < count; j++) {
- ProfilingChildData data = pDataList.get(j);
- String seqStr = makeLoadFormat(data.getChildren());
- List<String> insetRowData = new ArrayList<String>();
- if (null == seqStr || seqStr.isEmpty()) {
- continue;
- }
- insetRowData.add(data.getSeq());
- insetRowData.add(Integer.toString(data.getPid()));
- insetRowData.add(seqStr);
- insetData.add(insetRowData);
- }
- insertQuery(profilingChildData.insertQuery(), insetData);
- }
- }
-
/**
* select query function
*
}
// openTraceHandler
- public List<List<String>> getCallStackDataFromTable() {
- return selectQuery(
- null,
- DBTableManager
- .getInstance()
- .getTableInfo(DBTableManager.TABLE_INDEX_CALLSTACK_DATA)
- .getColumnNames(),
- DBTableManager
- .getInstance()
- .getTableInfo(DBTableManager.TABLE_INDEX_CALLSTACK_DATA)
- .getTableName(), null);
- }
-
- public List<List<String>> setloadCallStackApis() {
- return selectQuery(
- null,
- DBTableManager
- .getInstance()
- .getTableInfo(
- DBTableManager.TABLE_INDEX_CALLSTACK_UNITS)
- .getColumnNames(),
- DBTableManager
- .getInstance()
- .getTableInfo(
- DBTableManager.TABLE_INDEX_CALLSTACK_UNITS)
- .getTableName(), null);
- }
-
public List<List<String>> loadTargetInfo() {
return selectQuery(
null,
.getTableName(), null);
}
- public List<List<String>> setloadProfilingData() {
- return selectQuery(
- null,
- DBTableManager
- .getInstance()
- .getTableInfo(DBTableManager.TABLE_INDEX_PROFILING_DATA)
- .getColumnNames(),
- DBTableManager
- .getInstance()
- .getTableInfo(DBTableManager.TABLE_INDEX_PROFILING_DATA)
- .getTableName(), null);
- }
-
- public List<List<String>> setloadProfilingChildData() {
- return selectQuery(
- null,
- DBTableManager
- .getInstance()
- .getTableInfo(
- DBTableManager.TABLE_INDEX_PROFILING_CHILD_DATA)
- .getColumnNames(),
- DBTableManager
- .getInstance()
- .getTableInfo(
- DBTableManager.TABLE_INDEX_PROFILING_CHILD_DATA)
- .getTableName(), null);
- }
-
public List<String> getPids() {
List<List<String>> dbInfo = selectQuery(null,
new String[] { "distinct pid" }, "ProcessInfo", null);
}
return 0;
}
-
- private String makeSaveFormat(List<Long> input) {
- if (null == input || input.isEmpty()) {
- return null;
- }
-
- int size = input.size();
- StringBuffer str = new StringBuffer();
- for (int i = 0; i < size; i++) {
- try {
- str.append(input.get(i));
- } catch (OutOfMemoryError e) {
- e.printStackTrace();
- }
- if (i + 1 == size) {
- break;
- } else {
- str.append(CommonConstants.SLASH);
- }
- }
- return str.toString();
- }
-
- private String makeLoadFormat(List<Integer> input) {
- if (null == input || input.isEmpty()) {
- return null;
- }
-
- int size = input.size();
- StringBuffer str = new StringBuffer();
- for (int i = 0; i < size; i++) {
- str.append(input.get(i));
- if (i + 1 == size) {
- break;
- } else {
- str.append(CommonConstants.SLASH);
- }
- }
- return str.toString();
- }
}
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.logparser.LogInserter;
import org.tizen.dynamicanalyzer.model.ImageInfo;
-import org.tizen.dynamicanalyzer.nl.InformationViewLabels;
-import org.tizen.dynamicanalyzer.swap.channel.control.BinaryInfo;
-import org.tizen.dynamicanalyzer.swap.channel.data.ApiNameManager;
import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants;
-import org.tizen.dynamicanalyzer.swap.channel.data.LibraryObject;
-import org.tizen.dynamicanalyzer.swap.channel.data.ProcessInfo;
import org.tizen.dynamicanalyzer.swap.channel.data.ProcessInfoPackage;
import org.tizen.dynamicanalyzer.swap.model.data.ContextSwitchData;
import org.tizen.dynamicanalyzer.swap.model.data.LogData;
import org.tizen.dynamicanalyzer.swap.model.data.ReplayData;
import org.tizen.dynamicanalyzer.swap.model.data.ScreenShotData;
import org.tizen.dynamicanalyzer.swap.model.data.SystemData;
-import org.tizen.dynamicanalyzer.swap.platform.BinarySettingManager;
import org.tizen.dynamicanalyzer.ui.info.screenshot.SocketClient;
import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler;
import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
// private static boolean dropCallTraceLog = true;
// private static boolean dropCallTraceLog = false;
private static LogQueue logQueue = null;
+
+ // map for matching exit log with entry log
+ private static HashMap<Integer, List<Integer>> functionEntryStackByTidMap = new HashMap<Integer, List<Integer>>();
private int SMALL_IMG_WIDTH = 40;
private int SMALL_IMG_HEIGHT = 66;
return logQueue;
}
+ public List<Integer> getFunctionEntryStack(int tid) {
+ if (null == functionEntryStackByTidMap) {
+ functionEntryStackByTidMap = new HashMap<Integer, List<Integer>>();
+ }
+ List<Integer> functionEntryStack = functionEntryStackByTidMap.get(tid);
+ if (null == functionEntryStack) {
+ functionEntryStack = new ArrayList<Integer>();
+ functionEntryStackByTidMap.put(tid, functionEntryStack);
+ }
+ return functionEntryStack;
+ }
+
public static synchronized void startLogParser() {
getLogQueue().clear();
// why here?
e.printStackTrace();
}
}
-
+ functionEntryStackByTidMap.clear();
DataManagerRegistry.stopThreads();
}
}
LogData log = logLumb.get(i);
int id = log.getId();
+ int seqNum = log.getSeq();
if (log instanceof SystemData) {
// System.out
// .println("=========systemData is slicing===========\n");
// + AnalyzerUtil.toHexdecimal(processInfo
// .getLowestAddress()));
+ List<Integer> functionStack = getFunctionEntryStack(pData.getTid());
+ // entry / exit pair matching
+ if (id == DataChannelConstants.MSG_FUNCTION_ENTRY) {
+ functionStack.add(seqNum);
+ } else { // msg_function_exit
+ int stackSize = functionStack.size();
+ if (size > 0) {
+ pData.setEntrySeq(functionStack.get(stackSize - 1));
+ functionStack.remove(stackSize - 1);
+ } else { // size <= 0 : bug (exit without entry)
+ DA_LOG.error("function exit log without entry log");
+ }
+ }
+
pushLog(log, logPack);
AnalyzerManager.getCallstackManager()
.makeUserCallstack(
* Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved.
*
* Contact:
+ * WooJin Jung <woojin2.jung@samsung.com>
* Jooyoul Lee <jy.exe.lee@samsung.com>
* Juyoung Kim <j0.kim@samsung.com>
*
String args = null; // function entry specific
String ret = null;
String apiName = null;
-
+ int entrySeq = -1; // for entry/exit log matching
+
int buildType = -1;
String binaryPath = null;
this.apiName = apiName;
}
+ public int getEntrySeq() {
+ return entrySeq;
+ }
+
+ public void setEntrySeq(int seq) {
+ this.entrySeq = seq;
+ }
+
@Override
public void makePreparedStatement(PreparedStatement prep)
throws SQLException {
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+
+package org.tizen.dynamicanalyzer.ui.info.callstack;
+
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.tizen.dynamicanalyzer.database.DBColumn;
+import org.tizen.dynamicanalyzer.database.DBConstants;
+import org.tizen.dynamicanalyzer.database.DBTable;
+
+public class CallStackDataDBTable extends DBTable {
+ private static final String TABLENAME="CallStackData";
+ private static final String queryto_withSeq = "where %s = %s";
+ //TODO: use Array type of DB
+ public enum COLUMN {
+ SEQ(0, "SEQNUMBER"),
+ ORDER(1, "CallStackOrder"),
+ PCADDR(2, "PcAddr");
+
+ 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 CallStackDataDBTable() {
+ addColumn(new DBColumn(COLUMN.SEQ.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.ORDER.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.PCADDR.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ }
+
+ public List<List<Object>> getCallStackAddrsFromDB(int seq) {
+ String where = String.format(queryto_withSeq,
+ COLUMN.SEQ.name, seq);
+
+ List<String> selectColumn = new ArrayList<String>();
+ selectColumn.add(COLUMN.PCADDR.name);
+
+ return selectData(selectColumn, where);
+ }
+
+ @Override
+ public boolean prepare(PreparedStatement prep, List<Object> rowData) {
+ boolean isPrepared = true;
+
+ int columnsize = getColumnSize();
+ if (columnsize != rowData.size()) {
+ isPrepared = false;
+ } else {
+ try {
+ prep.setLong(COLUMN.SEQ.index + 1, (Long) (rowData.get(COLUMN.SEQ.index)));
+ prep.setInt(COLUMN.ORDER.index + 1, (Integer) (rowData.get(COLUMN.ORDER.index)));
+ prep.setLong(COLUMN.PCADDR.index + 1, (Long) (rowData.get(COLUMN.PCADDR.index)));
+ } catch (SQLException e) {
+ e.printStackTrace();
+ isPrepared = false;
+ }
+ }
+
+ return isPrepared;
+ }
+}
import java.util.concurrent.ConcurrentLinkedQueue;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
-import org.tizen.dynamicanalyzer.constant.CommonConstants;
-import org.tizen.dynamicanalyzer.sql.DBTableInfo;
-import org.tizen.dynamicanalyzer.sql.DBTableManager;
-import org.tizen.dynamicanalyzer.sql.SqlManager;
-// TODO: apply new DB schema, class, API
// inserter thread for callstackdata, callstackunit
public class CallStackInserter implements Runnable {
private static CallStackInserter instance = null;
private static volatile Thread inserterThread = null;
private static final int FULL_COUNT = 100;
private static boolean stopTrace = false;
+
+ private CallStackDataDBTable callStackDataTable = null;
+ private CallStackUnitDBTable callStackUnitTable = null;
+ public CallStackInserter() {
+ callStackDataTable = new CallStackDataDBTable();
+ callStackUnitTable = new CallStackUnitDBTable();
+ }
+
public synchronized static CallStackInserter getInstance() {
if (null == instance) {
instance = new CallStackInserter();
}
return instance;
}
+
+ public CallStackDataDBTable getCallStackDataTable() {
+ return callStackDataTable;
+ }
+
+ public CallStackUnitDBTable getCallStackUnitTable() {
+ return callStackUnitTable;
+ }
+ public void createTables() {
+ callStackDataTable.createTable();
+ callStackUnitTable.createTable();
+ }
+
public synchronized void startInserterThread() {
if (inserterThread == null) {
stopTrace = false;
inserterThread = new Thread(null, getInstance());
inserterThread.start();
}
-
}
public void stopInserterThread() {
}
private void saveCallStackUnits() {
- DBTableInfo unitTableInfo = DBTableManager.getInstance().getTableInfo(
- DBTableManager.TABLE_INDEX_CALLSTACK_UNITS);
- List<List<String>> insetData = new ArrayList<List<String>>();
- String insertQuery = unitTableInfo.insertQuery();
+ ArrayList<List<Object>> insertData = new ArrayList<List<Object>>();
+
CallStackUnit csu = null;
int insertCount = FULL_COUNT;
while ((csu = callstackUnitQueue.poll()) != null) {
- List<String> insetRowData = new ArrayList<String>();
+ List<Object> insertRowData = new ArrayList<Object>();
try {
- insetRowData.add(Long.toString(csu.getAddr()));
- insetRowData.add(csu.getSymbol());
- insetRowData.add(Integer.toString(csu.getPid()));
- insetRowData.add(Long.toString(csu.getTime()));
+ insertRowData.add(new Integer(csu.getPid()));
+ insertRowData.add(csu.getFunctionName());
+ insertRowData.add(csu.getPath());
+ insertRowData.add(new Long(csu.getAddr()));
} catch (ArrayIndexOutOfBoundsException e) {
e.printStackTrace();
}
- insetData.add(insetRowData);
+ insertData.add(insertRowData);
if ((insertCount-- <= 0) && (stopTrace == false)) {
break;
}
}
- if (insetData.size() > 0) {
- SqlManager.getInstance().insertQuery(insertQuery, insetData);
+ if (insertData.size() > 0) {
+ callStackUnitTable.insertData(insertData);
}
}
private void saveCallStackData() {
- DBTableInfo callstackData = DBTableManager.getInstance().getTableInfo(
- DBTableManager.TABLE_INDEX_CALLSTACK_DATA);
- List<List<String>> insetData = new ArrayList<List<String>>();
- String insertQuery = callstackData.insertQuery();
+ ArrayList<List<Object>> insertData = new ArrayList<List<Object>>();
+
CallStackData csd = null;
int insertCount = FULL_COUNT;
while ((csd = callstackDataQueue.poll()) != null) {
- List<String> insetRowData = new ArrayList<String>();
- String addrs = makeLongList2String(csd.getAddrs());
- try {
- insetRowData.add(Integer.toString(csd.getSeq()));
- insetRowData.add(addrs);
- } catch (ArrayIndexOutOfBoundsException e) {
- e.printStackTrace();
+ List<Long> addrs = csd.getAddrs();
+ int size = addrs.size();
+
+ for(int i = 0; i < size; i++) {
+ List<Object> insertRowData = new ArrayList<Object>();
+ try {
+ insertRowData.add(new Long(csd.getSeq()));
+ insertRowData.add(new Integer(i));
+ insertRowData.add(new Long(addrs.get(i)));
+ } catch (ArrayIndexOutOfBoundsException e) {
+ e.printStackTrace();
+ }
+ insertData.add(insertRowData);
}
- insetData.add(insetRowData);
if ((insertCount-- <= 0) && (stopTrace == false)) {
break;
}
}
- if (insetData.size() > 0) {
- SqlManager.getInstance().insertQuery(insertQuery, insetData);
+ if (insertData.size() > 0) {
+ callStackDataTable.insertData(insertData);
}
}
saveCallStackUnits();
saveCallStackData();
}
-
- public static String makeLongList2String(List<Long> input) {
- if (null == input || input.isEmpty()) {
- return null;
- }
-
- int size = input.size();
- StringBuffer str = new StringBuffer();
- for (int i = 0; i < size; i++) {
- try {
- str.append(input.get(i));
- } catch (OutOfMemoryError e) {
- e.printStackTrace();
- }
- if (i + 1 == size) {
- break;
- } else {
- str.append(CommonConstants.SLASH);
- }
- }
- return str.toString();
- }
-
}
\ No newline at end of file
makeCallstackData();
}
+ /** using open trace **/
+ public CallStackUnit(long addr, int pid, String functionName, String path) {
+ address = addr;
+ functionStartAddress = addr;
+ originSymbol = CommonConstants.EMPTY;
+ this.time = -1;
+
+ this.functionName = functionName;
+ this.path = path;
+ offset = CommonConstants.EMPTY;
+ etc = CommonConstants.EMPTY;
+ this.pid = pid;
+ }
+
private void makeCallstackData() {
String[] splitPath = originSymbol.split("\\(", 2); //$NON-NLS-1$
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+
+package org.tizen.dynamicanalyzer.ui.info.callstack;
+
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.util.List;
+
+import org.tizen.dynamicanalyzer.common.DALimit;
+import org.tizen.dynamicanalyzer.constant.CommonConstants;
+import org.tizen.dynamicanalyzer.database.DBColumn;
+import org.tizen.dynamicanalyzer.database.DBConstants;
+import org.tizen.dynamicanalyzer.database.DBTable;
+
+public class CallStackUnitDBTable extends DBTable {
+ private static final String TABLENAME="CallStackUnits";
+
+ public enum COLUMN {
+ PID(0, "PID"),
+ FUNCTIONNAME(1, "FunctionName"),
+ BINARYPATH(2, "BinaryPath"),
+ PCADDR(3, "PcAddr");
+
+ 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 CallStackUnitDBTable() {
+ addColumn(new DBColumn(COLUMN.PID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.FUNCTIONNAME.name, DBConstants.NOT_NULL,
+ DBConstants.VARCHAR, DALimit.FUNCTION_NAME_LENGTH));
+ addColumn(new DBColumn(COLUMN.BINARYPATH.name, DBConstants.NOT_NULL,
+ DBConstants.VARCHAR, DALimit.FILEPATH_LENGTH));
+ addColumn(new DBColumn(COLUMN.PCADDR.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ }
+
+ public List<List<Object>> getCallStackUnitsFromDB() {
+ return selectData(null, CommonConstants.EMPTY);
+ }
+
+ @Override
+ public boolean prepare(PreparedStatement prep, List<Object> rowData) {
+ boolean isPrepared = true;
+
+ int columnsize = getColumnSize();
+ if (columnsize != rowData.size()) {
+ isPrepared = false;
+ } else {
+ try {
+ prep.setInt(COLUMN.PID.index + 1, (Integer) (rowData.get(COLUMN.PID.index)));
+
+ String functionStr = clipString((String) (rowData.get(COLUMN.FUNCTIONNAME.index)),
+ DALimit.FUNCTION_NAME_LENGTH, rowData.get(COLUMN.PCADDR.index).toString());
+ prep.setString(COLUMN.FUNCTIONNAME.index + 1, functionStr);
+
+ String pathStr = clipString((String) (rowData.get(COLUMN.BINARYPATH.index)),
+ DALimit.FILEPATH_LENGTH, rowData.get(COLUMN.PCADDR.index).toString());
+ prep.setString(COLUMN.BINARYPATH.index + 1, pathStr);
+
+ prep.setLong(COLUMN.PCADDR.index + 1, (Long) (rowData.get(COLUMN.PCADDR.index)));
+ } catch (SQLException e) {
+ e.printStackTrace();
+ isPrepared = false;
+ }
+ }
+
+ return isPrepared;
+ }
+}
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.DASelectionData;
-import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.model.TableInput;
-import org.tizen.dynamicanalyzer.sql.SqlManager;
import org.tizen.dynamicanalyzer.swap.model.data.LogData;
import org.tizen.dynamicanalyzer.ui.file.FilePage;
import org.tizen.dynamicanalyzer.ui.opengl.GLPage;
import org.tizen.dynamicanalyzer.ui.page.ScreenshotTabComposite;
import org.tizen.dynamicanalyzer.ui.range.RangePage;
import org.tizen.dynamicanalyzer.ui.summary.SummaryPage;
+import org.tizen.dynamicanalyzer.ui.timeline.calltrace.FunctionEntryDBTable;
import org.tizen.dynamicanalyzer.ui.userinterface.UIPage;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableComposite;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableDataFormat;
pid = (Integer) leakData.get(1);
time = (Long) leakData.get(4);
libName = (String) leakData.get(7);
- } else {
+ } else if (tableData.getType() == AnalyzerConstants.TYPE_TABLE_CALLTRACE) {
+ List<Object> calltraceData = tableData.getData();
+ seqNum = ((Long) calltraceData.get(FunctionEntryDBTable.COLUMN.SEQ.index)).intValue();
+ pid = (Integer) calltraceData.get(FunctionEntryDBTable.COLUMN.PID.index);
+ time = (Long) calltraceData.get(FunctionEntryDBTable.COLUMN.STARTTIME.index);
+ libName = (String) calltraceData.get(FunctionEntryDBTable.COLUMN.BINARYPATH.index);
+ } else { // in case table has LogData
LogData logData = tableData.getLogData();
seqNum = logData.getSeq();
pid = logData.getPid();
CallStackData csd = cdMap.get(seqNum);
List<Long> addrs = null;
if (null == csd) { // callstackdata is not in memory, find from DB
- // TODO: apply new DB schema
- String callstackQuery = "where seqnumber = " + seqNum;
- List<List<String>> dbInfo = SqlManager.getInstance()
- .selectQuery(null, new String[] { "callstack" },
- "CallstackData", callstackQuery);
- if (null == dbInfo || 0 == dbInfo.size()
- || null == dbInfo.get(0)) { // not found
- return;
- }
- String strAddrs = dbInfo.get(0).get(0);
- if (null == strAddrs) {
+ List<List<Object>> callStackAddrs =
+ CallStackInserter.getInstance().getCallStackDataTable()
+ .getCallStackAddrsFromDB(seqNum);
+
+ if (null == callStackAddrs || 0 == callStackAddrs.size()
+ || null == callStackAddrs.get(0)) { // not found
return;
}
- String[] splitAddrs = strAddrs.split(CommonConstants.SLASH);
- int size = splitAddrs.length;
+
+ int size = callStackAddrs.size();
addrs = new ArrayList<Long>();
- for (int j = 0; j < size; j++) {
- long addr = Long.parseLong(splitAddrs[j]);
- addrs.add(addr);
+ for (int i = 0; i < size; i++) {
+ addrs.add((Long) callStackAddrs.get(i).get(0));
}
} else { // callstackdata is in memory
addrs = csd.getAddrs();
int size = addrs.size();
for (int i = 0; i < size; i++) {
+ String hexAddr = Formatter.toHexString(addrs.get(i).toString());
CallStackUnit api = addrMap.get(addrs.get(i));
- String hexAddr = Formatter.toHexString(addrs.get(i).toString());
+ if (null == api) {
+ DA_LOG.debug("callstackunit for addr : " + hexAddr + " not found");
+ return;
+ }
+
String path = api.getPath();
if (null == path) {
DA_LOG.debug("callstackunit for addr : " + hexAddr + " not found");
* Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
*
* Contact:
+ * WooJin Jung <woojin2.jung@samsung.com>
* Jooyoul Lee <jy.exe.lee@samsung.com>
* Juyoung Kim <j0.kim@samsung.com>
*
import org.tizen.dynamicanalyzer.nl.InformationViewLabels;
import org.tizen.dynamicanalyzer.resources.ColorResources;
import org.tizen.dynamicanalyzer.swap.model.data.LogData;
+import org.tizen.dynamicanalyzer.ui.timeline.calltrace.FunctionEntryDBTable;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableComposite;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableDataFormat;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATreeComposite;
} else if (tableData.getType() == AnalyzerConstants.TYPE_TABLE_LEAK) {
List<Object> leakData = tableData.getData();
startTime = (Long) leakData.get(4);
- } else {
+ } else if (tableData.getType() == AnalyzerConstants.TYPE_TABLE_CALLTRACE) {
+ List<Object> calltraceData = tableData.getData();
+ startTime = (Long) calltraceData.get(FunctionEntryDBTable.COLUMN.STARTTIME.index);
+ } else { // in case table has LogData
LogData startData = ((DATableDataFormat) selection[0]
.getData()).getLogData();
startTime = startData.getTime();
}
long endTime = startTime;
+ // TODO: need to review what below code does
if (null != selection[selection.length - 1].getData()) {
- DATableDataFormat lastTableData = (DATableDataFormat) selection[0]
+ DATableDataFormat lastTableData = (DATableDataFormat) selection[selection.length - 1]
.getData();
if (lastTableData.getType() == AnalyzerConstants.TYPE_TABLE_FAILED) {
- List<Object> failedData = tableData.getData();
+ List<Object> failedData = lastTableData.getData();
endTime = (Long) failedData.get(1);
} else if (lastTableData.getType() == AnalyzerConstants.TYPE_TABLE_LEAK) {
- List<Object> leakData = tableData.getData();
+ List<Object> leakData = lastTableData.getData();
endTime = (Long) leakData.get(4);
+ } else if (lastTableData.getType() == AnalyzerConstants.TYPE_TABLE_CALLTRACE) {
+ List<Object> calltraceData = lastTableData.getData();
+ endTime = (Long) calltraceData.get(FunctionEntryDBTable.COLUMN.STARTTIME.index);
} else {
- LogData endData = ((DATableDataFormat) selection[selection.length - 1]
- .getData()).getLogData();
+ LogData endData = lastTableData.getLogData();
endTime = endData.getTime();
}
}
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+
+package org.tizen.dynamicanalyzer.ui.summary.profiling;
+
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.util.List;
+
+import org.tizen.dynamicanalyzer.constant.CommonConstants;
+import org.tizen.dynamicanalyzer.database.DBColumn;
+import org.tizen.dynamicanalyzer.database.DBConstants;
+import org.tizen.dynamicanalyzer.database.DBTable;
+
+public class FunctionSampleDBTable extends DBTable {
+ private static final String TABLENAME="FunctionSample";
+
+ public enum COLUMN {
+ SEQ(0, "SEQNUMBER"),
+ SAMPLETIME(1, "SampleTime"),
+ PID(2, "PID"),
+ TID(3, "TID"),
+ PCADDR(4, "PcAddr"),
+ CPUNUM(5, "CpuNum");
+
+ 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 FunctionSampleDBTable() {
+ addColumn(new DBColumn(COLUMN.SEQ.name, DBConstants.PRIMARY_KEY, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.SAMPLETIME.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.PID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.TID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.PCADDR.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.CPUNUM.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT1));
+ }
+
+ public List<List<Object>> getFunctionSampleFromDB() {
+ return selectData(null, CommonConstants.EMPTY);
+ }
+
+ @Override
+ public boolean prepare(PreparedStatement prep, List<Object> rowData) {
+ boolean isPrepared = true;
+
+ int columnsize = getColumnSize();
+ if (columnsize != rowData.size()) {
+ isPrepared = false;
+ } else {
+ try {
+ prep.setLong(COLUMN.SEQ.index + 1, (Long) (rowData.get(COLUMN.SEQ.index)));
+ prep.setLong(COLUMN.SAMPLETIME.index + 1, (Long) (rowData.get(COLUMN.SAMPLETIME.index)));
+ prep.setInt(COLUMN.PID.index + 1, (Integer) (rowData.get(COLUMN.PID.index)));
+ prep.setInt(COLUMN.TID.index + 1, (Integer) (rowData.get(COLUMN.TID.index)));
+ prep.setLong(COLUMN.PCADDR.index + 1, (Long) (rowData.get(COLUMN.PCADDR.index)));
+ prep.setByte(COLUMN.CPUNUM.index + 1, (Byte) (rowData.get(COLUMN.CPUNUM.index)));
+ } catch (SQLException e) {
+ e.printStackTrace();
+ isPrepared = false;
+ }
+ }
+
+ return isPrepared;
+ }
+}
public class FunctionUsageProfiler extends PageDataManager {
// default sampling rate = 10 ms
- public static long SAMPLE_TIME = -1;
+ public static long SAMPLE_TIME = 10;
public static final String APPLICATION = SummaryLabels.FUNCTION_USAGE_PROFILER_APPLICATION;
public static final String DEPENDENT_LIB = SummaryLabels.FUNCTION_USAGE_PROFILER_DEPENDENT_LIB;
public static final String APPLICATION_KEY = "profiling_app_bin_key";//$NON-NLS-1$
public static final String UNKNOWN = CommonConstants.EMPTY;
private static FunctionUsageProfiler instance = null;
-
+ private boolean isSetSamplePeriod = false;
+
+ private ProfilingDataDBTable profilingDataTable = null;
+ private ProfilingChildDataDBTable profilingChildDataTable = null;
+ private FunctionSampleDBTable functionSampleTable = null;
+
private HashMap<Integer, ProfileDataMaker> profileDataMakerMap = null;
+ private FunctionUsageProfiler() {
+ profilingDataTable = new ProfilingDataDBTable();
+ addDBTable(profilingDataTable);
+ profilingChildDataTable = new ProfilingChildDataDBTable();
+ addDBTable(profilingChildDataTable);
+ functionSampleTable = new FunctionSampleDBTable();
+ addDBTable(functionSampleTable);
+ }
+
+ public ProfilingDataDBTable getProfilingDataTable() {
+ return profilingDataTable;
+ }
+
+ public ProfilingChildDataDBTable getProfilingChildDataTable() {
+ return profilingChildDataTable;
+ }
+
+ public FunctionSampleDBTable getFunctionSampleTable() {
+ return functionSampleTable;
+ }
+
/**
* key: symbol(child) or file path (parent) - value : sequence num of
* profiling data. all parent and child data is in
return instance;
}
- public static void clear() {
- instance = null;
+ public void clear() {
+ isSetSamplePeriod = false;
+ if (profileDataMakerMap != null) {
+ profileDataMakerMap.clear();
+ }
+ }
+
+ public void saveProfilingData() {
+ List<Integer> pids = getPidsOfProfileDataMakerMap();
+ for (int i = 0; i < pids.size(); i++) {
+ ProfileDataMaker profiler = getProfileDataMakerByPid(pids.get(i));
+ Map<Integer, ProfilingData> profilingDataMap = profiler
+ .getProfilingDataMap();
+ List<ProfilingData> pDataList = new ArrayList<ProfilingData>();
+ pDataList.addAll(profilingDataMap.values());
+
+ List<List<Object>> insertData = new ArrayList<List<Object>>();
+
+ int count = pDataList.size();
+ for (int j = 0; j < count; j++) {
+ List<Object> insertRowData = new ArrayList<Object>();
+ ProfilingData pData = pDataList.get(j);
+
+ try {
+ insertRowData.add(new Integer(pData.getSequence()));
+ String key = pData.getKey();
+ byte type;
+ if (key.equals(APPLICATION_KEY)) {
+ type = ProfilingData.TYPE_APPLICATION;
+ } else if (key.equals(DEPENDENT_LIB_KEY)) {
+ type = ProfilingData.TYPE_DEPENDENTLIBRARY;
+ } else {
+ if (pData.isParent()) { // library
+ type = ProfilingData.TYPE_LIBRARY;
+ } else { // function
+ type = ProfilingData.TYPE_FUNCTION;
+ }
+ }
+ insertRowData.add(new Byte(type));
+ if (pData.isParent()) {
+ insertRowData.add(""); // function name is null for library type
+ insertRowData.add(pData.getName());
+ } else {
+ insertRowData.add(pData.getName());
+ insertRowData.add(""); // library path is null for function type
+ }
+ insertRowData.add(new Integer(pids.get(i)));
+ insertRowData.add(new Integer(pData.getSelfExCount()));
+ insertRowData.add(new Integer(pData.getInCount()));
+ insertRowData.add(new Integer(pData.getCallCount()));
+ insertRowData.add(new Long(pData.getElapsedTime()));
+ insertRowData.add(new Long(pData.getExclusiveElapsedTime()));
+ } catch (ArrayIndexOutOfBoundsException e) {
+ e.printStackTrace();
+ }
+ insertData.add(insertRowData);
+ }
+ if (insertData.size() > 0) {
+ profilingDataTable.insertData(insertData);
+ }
+ }
+ }
+
+ public void saveProfilingChildData() {
+ List<Integer> pids = getPidsOfProfileDataMakerMap();
+ for (int i = 0; i < pids.size(); i++) {
+ ProfileDataMaker profiler = getProfileDataMakerByPid(pids.get(i));
+ Map<String, ProfilingChildData> profilingDataMap = profiler
+ .getChildListMap();
+ List<ProfilingChildData> pDataList = new ArrayList<ProfilingChildData>();
+ pDataList.addAll(profilingDataMap.values());
+
+ List<List<Object>> insertData = new ArrayList<List<Object>>();
+ int count = pDataList.size();
+ for (int j = 0; j < count; j++) {
+ ProfilingChildData data = pDataList.get(j);
+ List<Integer> childList = data.getChildren();
+ int childCount = childList.size();
+ try {
+ for (int k = 0; k < childCount; k++)
+ {
+ List<Object> insertRowData = new ArrayList<Object>();
+ insertRowData.add(Integer.valueOf(data.getSeq()));
+ insertRowData.add(new Integer(data.getPid()));
+ insertRowData.add(new Integer(childList.get(k)));
+ insertData.add(insertRowData);
+ }
+ } catch (ArrayIndexOutOfBoundsException e) {
+ e.printStackTrace();
+ }
+ }
+ if (insertData.size() > 0) {
+ profilingChildDataTable.insertData(insertData);
+ }
+ }
}
@Override
protected void makeData(LogPackage pack) {
- if (SAMPLE_TIME < 0) {
+ // TODO: will get sample_time from Project.java
+ if (!isSetSamplePeriod) {
SAMPLE_TIME = ConfigurationDialogDataManager
.getInstance()
.getfeatureValue(
ConfigureLabels.FUNCTION_PROFILING_SAMPLING_PERIODIC);
+ isSetSamplePeriod = true;
}
if (ConfigurationDialogDataManager.getInstance() // sampling is on
ConfigureLabels.FEATURE_FUNCTION_PROFILING) != 0) {
Logs logs = pack.getLogs(DataChannelConstants.MSG_DATA_SAMPLE);
if (null != logs && logs.getRawLogs().size() != 0) {
+ List<List<Object>> insertData = new ArrayList<List<Object>>();
List<LogData> sample = logs.getLogs();
int size = sample.size();
for (int i = 0; i < size; i++) {
+ List<Object> insertRowData = new ArrayList<Object>();
ProfileData sampleLog = (ProfileData) sample.get(i);
getInstance().getProfileDataMakerByPid(
sample.get(i).getPid())
itr.remove();
}
}
+ // save to DB
+ try {
+ insertRowData.add(new Long(sampleLog.getSeq()));
+ insertRowData.add(new Long(sampleLog.getTime()));
+ insertRowData.add(new Integer(sampleLog.getPid()));
+ insertRowData.add(new Integer(sampleLog.getTid()));
+ insertRowData.add(new Long(sampleLog.getPcAddr()));
+ Integer cpuNum = new Integer(sampleLog.getCpuNum());
+ insertRowData.add(new Byte(cpuNum.byteValue()));
+ } catch (ArrayIndexOutOfBoundsException e) {
+ e.printStackTrace();
+ }
+ insertData.add(insertRowData);
+ }
+ if (insertData.size() > 0) {
+ functionSampleTable.insertData(insertData);
}
}
} else { // sampling is off, callstackdata is not needed in memory
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+
+package org.tizen.dynamicanalyzer.ui.summary.profiling;
+
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.util.List;
+
+import org.tizen.dynamicanalyzer.constant.CommonConstants;
+import org.tizen.dynamicanalyzer.database.DBColumn;
+import org.tizen.dynamicanalyzer.database.DBConstants;
+import org.tizen.dynamicanalyzer.database.DBTable;
+
+public class ProfilingChildDataDBTable extends DBTable {
+ private static final String TABLENAME="ProfilingChildData";
+ // TODO: use Array type of DB
+ public enum COLUMN {
+ SEQ(0, "SEQNUMBER"),
+ PID(1, "PID"),
+ CHILDSEQ(2, "CHILD_SEQNUMBER");
+
+ 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 ProfilingChildDataDBTable() {
+ addColumn(new DBColumn(COLUMN.SEQ.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.PID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.CHILDSEQ.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ }
+
+ public List<List<Object>> getProfilingChildDataFromDB() {
+ return selectData(null, CommonConstants.EMPTY);
+ }
+
+ @Override
+ public boolean prepare(PreparedStatement prep, List<Object> rowData) {
+ boolean isPrepared = true;
+
+ int columnsize = getColumnSize();
+ if (columnsize != rowData.size()) {
+ isPrepared = false;
+ } else {
+ try {
+ prep.setInt(COLUMN.SEQ.index + 1, (Integer) (rowData.get(COLUMN.SEQ.index)));
+ prep.setInt(COLUMN.PID.index + 1, (Integer) (rowData.get(COLUMN.PID.index)));
+ prep.setInt(COLUMN.CHILDSEQ.index + 1, (Integer) (rowData.get(COLUMN.CHILDSEQ.index)));
+ } catch (SQLException e) {
+ e.printStackTrace();
+ isPrepared = false;
+ }
+ }
+
+ return isPrepared;
+ }
+}
*
* Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
*
- * Contact:
+ * Contact:
+ * WooJin Jung <woojin2.jung@samsung.com>
* Jooyoul Lee <jy.exe.lee@samsung.com>
- * WooJin Jung <woojin2.jung@samsung.com>
* Juyoung Kim <j0.kim@samsung.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
import java.util.ArrayList;
import java.util.List;
-import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackUnit;
public class ProfilingData {
public static final int INCL_ELAPSED_TIME_INDEX = 8;
public static final int EXCL_ELAPSED_TIME_INDEX = 9;
+ public static final byte TYPE_APPLICATION = 0;
+ public static final byte TYPE_DEPENDENTLIBRARY = 1;
+ public static final byte TYPE_FUNCTION = 2;
+ public static final byte TYPE_LIBRARY = 3;
+
private static int internalSeq = 0;
private int seq = -1;
private String name = null;
}
/** using open trace **/
- public ProfilingData(List<String> input, ProfileDataMaker profiler) {
- if (input.size() < DATA_FIELD_SIZE) {
- return;
- }
- seq = Integer.parseInt(input.get(SEQUENCE_INDEX));
- name = input.get(NAME_INDEX);
- exCount = Integer.parseInt(input.get(EXCOUNT_INDEX));
- inCount = Integer.parseInt(input.get(INCOUNT_INDEX));
- callCount = Integer.parseInt(input.get(CALLCOUNT_INDEX));
- parent = input.get(PARENT_INDEX);
- key = input.get(KEY_INDEX);
- if (!input.get(INCL_ELAPSED_TIME_INDEX).isEmpty()) {
- inElapsedTime = Integer
- .parseInt(input.get(INCL_ELAPSED_TIME_INDEX));
- }
- if (!input.get(EXCL_ELAPSED_TIME_INDEX).isEmpty()) {
- exElapsedTime = Integer
- .parseInt(input.get(EXCL_ELAPSED_TIME_INDEX));
- }
-
+ public ProfilingData(int seq, String name, int exCount, int inCount, int callCount,
+ long inElapsedTime, long exElapsedTime, ProfileDataMaker profiler) {
+ this.seq = seq;
+ this.name = name;
+ this.exCount = exCount;
+ this.inCount = inCount;
+ this.callCount = callCount;
+ this.inElapsedTime = inElapsedTime;
+ this.exElapsedTime = exElapsedTime;
this.profiler = profiler;
}
- /** using save trace **/
- public List<String> getSaveData() {
- List<String> output = new ArrayList<String>();
- for (int i = 0; i < DATA_FIELD_SIZE; i++) {
- output.add(CommonConstants.EMPTY);
- }
- output.set(SEQUENCE_INDEX, Integer.toString(seq));
- output.set(PID_INDEX, Integer.toString(profiler.getPid()));
- output.set(NAME_INDEX, name);
- output.set(EXCOUNT_INDEX, Integer.toString(exCount));
- output.set(INCOUNT_INDEX, Integer.toString(inCount));
- output.set(CALLCOUNT_INDEX, Integer.toString(callCount));
- output.set(PARENT_INDEX, parent);
- output.set(KEY_INDEX, key);
- output.set(INCL_ELAPSED_TIME_INDEX, Long.toString(inElapsedTime));
- output.set(EXCL_ELAPSED_TIME_INDEX, Long.toString(exElapsedTime));
- return output;
- }
-
public void addChild(ProfilingData child) {
int seq = child.getSequence();
getChildData().getChildren().add(seq);
}
return exCount + count;
}
-
+ // self ex count should be saved to DB
+ public int getSelfExCount() {
+ return exCount;
+ }
+
public void addExCount() {
exCount++;
}
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+
+package org.tizen.dynamicanalyzer.ui.summary.profiling;
+
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.util.List;
+
+import org.tizen.dynamicanalyzer.common.DALimit;
+import org.tizen.dynamicanalyzer.constant.CommonConstants;
+import org.tizen.dynamicanalyzer.database.DBColumn;
+import org.tizen.dynamicanalyzer.database.DBConstants;
+import org.tizen.dynamicanalyzer.database.DBTable;
+
+public class ProfilingDataDBTable extends DBTable {
+ private static final String TABLENAME="ProfilingData";
+
+ public enum COLUMN {
+ SEQ(0, "SEQNUMBER"),
+ TYPE(1, "Type"),
+ FUNCTIONNAME(2, "FunctionName"),
+ BINARYPATH(3, "BinaryPath"),
+ PID(4, "PID"),
+ EXCOUNT(5, "ExCount"),
+ INCOUNT(6, "InCount"),
+ CALLCOUNT(7, "CallCount"),
+ INCLEXETIME(8, "InclExeTime"),
+ EXCLEXETIME(9, "ExclExeTime");
+
+ 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 ProfilingDataDBTable() {
+ addColumn(new DBColumn(COLUMN.SEQ.name, DBConstants.PRIMARY_KEY, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.TYPE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT1));
+ addColumn(new DBColumn(COLUMN.FUNCTIONNAME.name, DBConstants.NOT_NULL,
+ DBConstants.VARCHAR, DALimit.FUNCTION_NAME_LENGTH));
+ addColumn(new DBColumn(COLUMN.BINARYPATH.name, DBConstants.NOT_NULL,
+ DBConstants.VARCHAR, DALimit.FILEPATH_LENGTH));
+ addColumn(new DBColumn(COLUMN.PID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.EXCOUNT.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.INCOUNT.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.CALLCOUNT.name, DBConstants.EMPTY, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.INCLEXETIME.name, DBConstants.EMPTY, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.EXCLEXETIME.name, DBConstants.EMPTY, DBConstants.DBTYPE_LONG));
+ }
+
+ public List<List<Object>> getProfilingDataFromDB() {
+ return selectData(null, CommonConstants.EMPTY);
+ }
+
+ @Override
+ public boolean prepare(PreparedStatement prep, List<Object> rowData) {
+ boolean isPrepared = true;
+
+ int columnsize = getColumnSize();
+ if (columnsize != rowData.size()) {
+ isPrepared = false;
+ } else {
+ try {
+ prep.setInt(COLUMN.SEQ.index + 1, (Integer) (rowData.get(COLUMN.SEQ.index)));
+ prep.setByte(COLUMN.TYPE.index + 1, (Byte) (rowData.get(COLUMN.TYPE.index)));
+
+ String functionStr = clipString((String) (rowData.get(COLUMN.FUNCTIONNAME.index)),
+ DALimit.FUNCTION_NAME_LENGTH, rowData.get(COLUMN.SEQ.index).toString());
+ prep.setString(COLUMN.FUNCTIONNAME.index + 1, functionStr);
+
+ String pathStr = clipString((String) (rowData.get(COLUMN.BINARYPATH.index)),
+ DALimit.FILEPATH_LENGTH, rowData.get(COLUMN.SEQ.index).toString());
+ prep.setString(COLUMN.BINARYPATH.index + 1, pathStr);
+
+ prep.setInt(COLUMN.PID.index + 1, (Integer) (rowData.get(COLUMN.PID.index)));
+ prep.setInt(COLUMN.EXCOUNT.index + 1, (Integer) (rowData.get(COLUMN.EXCOUNT.index)));
+ prep.setInt(COLUMN.INCOUNT.index + 1, (Integer) (rowData.get(COLUMN.INCOUNT.index)));
+ prep.setInt(COLUMN.CALLCOUNT.index + 1, (Integer) (rowData.get(COLUMN.CALLCOUNT.index)));
+ prep.setLong(COLUMN.INCLEXETIME.index + 1, (Long) (rowData.get(COLUMN.INCLEXETIME.index)));
+ prep.setLong(COLUMN.EXCLEXETIME.index + 1, (Long) (rowData.get(COLUMN.EXCLEXETIME.index)));
+ } catch (SQLException e) {
+ e.printStackTrace();
+ isPrepared = false;
+ }
+ }
+
+ return isPrepared;
+ }
+}
import org.tizen.dynamicanalyzer.shortcut.ShortCutManager;
import org.tizen.dynamicanalyzer.swap.logparser.DataManagerRegistry;
import org.tizen.dynamicanalyzer.ui.page.ScreenshotTabComposite;
+import org.tizen.dynamicanalyzer.ui.timeline.calltrace.CallTraceDataManager;
import org.tizen.dynamicanalyzer.ui.timeline.calltrace.CallTraceView;
import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineChartManager;
import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineView;
DataManagerRegistry.registerPageDataManager(TimelineChartManager.getInstance());
DataManagerRegistry.registerPageDataManager(ReplayDataManager.getInstance());
-
+ DataManagerRegistry.registerPageDataManager(CallTraceDataManager.getInstance());
}
@Override
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+
+package org.tizen.dynamicanalyzer.ui.timeline.calltrace;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants;
+import org.tizen.dynamicanalyzer.swap.channel.data.ProcessInfoPackage;
+import org.tizen.dynamicanalyzer.swap.logparser.LogPackage;
+import org.tizen.dynamicanalyzer.swap.logparser.Logs;
+import org.tizen.dynamicanalyzer.swap.logparser.PageDataManager;
+import org.tizen.dynamicanalyzer.swap.model.data.LogData;
+import org.tizen.dynamicanalyzer.swap.model.data.ProfileData;
+
+public class CallTraceDataManager extends PageDataManager {
+
+ private static CallTraceDataManager instance = null;
+
+ private FunctionEntryDBTable functionEntryTable = null;
+ private FunctionExitDBTable functionExitTable = null;
+
+ private CallTraceDataManager() {
+ functionEntryTable = new FunctionEntryDBTable();
+ addDBTable(functionEntryTable);
+ functionExitTable = new FunctionExitDBTable();
+ addDBTable(functionExitTable);
+ }
+
+ public FunctionEntryDBTable getFunctionEntryTable() {
+ return functionEntryTable;
+ }
+
+ public FunctionExitDBTable getFunctionExitTable() {
+ return functionExitTable;
+ }
+
+ public synchronized static CallTraceDataManager getInstance() {
+ if (null == instance) {
+ instance = new CallTraceDataManager();
+ }
+ return instance;
+ }
+
+ public void clear() {
+ // nothing to do
+ }
+
+ @Override
+ protected void makeData(LogPackage pack) {
+ Logs entryLogs = pack.getLogs(DataChannelConstants.MSG_FUNCTION_ENTRY);
+ if (null != entryLogs && entryLogs.getRawLogs().size() != 0) {
+ List<LogData> inputs = entryLogs.getLogs();
+ List<List<Object>> insertData = new ArrayList<List<Object>>();
+ int size = inputs.size();
+ for (int i = 0; i < size; i++) {
+ List<Object> insertRowData = new ArrayList<Object>();
+ ProfileData pData = (ProfileData) inputs.get(i);
+
+ try {
+ insertRowData.add(new Long(pData.getSeq()));
+ insertRowData.add(new Integer(pData.getPid()));
+ insertRowData.add(new Integer(pData.getTid()));
+ Integer type = new Integer(pData.getProbeType());
+ insertRowData.add(new Byte(type.byteValue()));
+ insertRowData.add(new String(pData.getApiName()));
+ insertRowData.add(new String(pData.getLibName()));
+ insertRowData.add(new Long(pData.getTime()));
+ insertRowData.add(new Long(pData.getCallerPcAddr()));
+ insertRowData.add(new Long(pData.getPcAddr()));
+ insertRowData.add(new String(pData.getArgs()));
+ } catch (ArrayIndexOutOfBoundsException e) {
+ e.printStackTrace();
+ }
+ insertData.add(insertRowData);
+ // for calltrace table windowing
+ ProcessInfoPackage processInfoPkg = AnalyzerManager.getProject()
+ .getProcessInfoPackage(pData.getPid());
+ processInfoPkg.addFunctionEntryInsertLogCount();
+ }
+ if (insertData.size() > 0) {
+ functionEntryTable.insertData(insertData);
+ }
+ }
+
+ Logs exitLogs = pack.getLogs(DataChannelConstants.MSG_FUNCTION_EXIT);
+ if (null != exitLogs && exitLogs.getRawLogs().size() != 0) {
+ List<LogData> inputs = exitLogs.getLogs();
+ List<List<Object>> insertData = new ArrayList<List<Object>>();
+ int size = inputs.size();
+ for (int i = 0; i < size; i++) {
+ List<Object> insertRowData = new ArrayList<Object>();
+ ProfileData pData = (ProfileData) inputs.get(i);
+
+ try {
+ insertRowData.add(new Long(pData.getEntrySeq()));
+ insertRowData.add(new Long(pData.getSeq()));
+ insertRowData.add(new Long(pData.getTime()));
+ insertRowData.add(new String(pData.getReturn()));
+ } catch (ArrayIndexOutOfBoundsException e) {
+ e.printStackTrace();
+ }
+ insertData.add(insertRowData);
+ }
+ if (insertData.size() > 0) {
+ functionExitTable.insertData(insertData);
+ }
+ }
+ }
+}
* Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
*
* Contact:
+ * WooJin Jung <woojin2.jung@samsung.com>
* Jooyoul Lee <jy.exe.lee@samsung.com>
* Juyoung Kim <j0.kim@samsung.com>
*
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.DASelectionData;
import org.tizen.dynamicanalyzer.model.TableInput;
-import org.tizen.dynamicanalyzer.sql.DBTableManager;
-import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants;
import org.tizen.dynamicanalyzer.swap.channel.data.ProcessInfoPackage;
-import org.tizen.dynamicanalyzer.swap.model.data.LogData;
-import org.tizen.dynamicanalyzer.swap.model.data.LogDataFactory;
-import org.tizen.dynamicanalyzer.swap.model.data.ProfileData;
-import org.tizen.dynamicanalyzer.swap.model.data.UserFunctionData;
import org.tizen.dynamicanalyzer.ui.range.RangeDataManager;
import org.tizen.dynamicanalyzer.ui.timeline.TimelinePage;
import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
public CallTraceTable(Composite parent, int compStyle, int tableStyle) {
super(parent, compStyle, tableStyle);
+ setDataType(false, 0); // use new DB
setContextMenu(AnalyzerConstants.CONTEXT_TABLE_SOURCE | AnalyzerConstants.CONTEXT_TABLE_RANGE);
table.addSelectionListener(new SelectionListener() {
return;
}
int size = ti.length;
- LogData startData = ((DATableDataFormat) ti[0].getData())
- .getLogData();
- LogData endData = ((DATableDataFormat) ti[size - 1].getData())
- .getLogData();
- long startTime = startData.getTime();
- long endTime = endData.getTime();
+ List<Object> startData = ((DATableDataFormat) ti[0].getData()).getData();
+ List<Object> endData = ((DATableDataFormat) ti[size - 1].getData()).getData();
+ long startTime = (Long) startData.get(FunctionEntryDBTable.COLUMN.STARTTIME.index);
+ long endTime = (Long) endData.get(FunctionEntryDBTable.COLUMN.STARTTIME.index);
DASelectionData data = new DASelectionData(
TimelinePage.calltraceViewID, startTime, endTime, ti,
@Override
protected List<TableInput> makeTableInput() {
- List<LogData> userLog = getQueriedLogData();
+ List<List<Object>> queriedData = getQueriedObjectData();
List<TableInput> input = new ArrayList<TableInput>();
- int size = userLog.size();
+ int size = queriedData.size();
for (int i = 0; i < size; i++) {
- LogData logData = userLog.get(i);
+ List<Object> rowData = queriedData.get(i);
List<String> text = new ArrayList<String>();
- if (logData instanceof UserFunctionData) {
- // create text
- UserFunctionData data = (UserFunctionData) logData;
- String time = Formatter.toTimeFormat(data.getTime());
- text.add(time);
- text.add(Integer.toString(data.getTid()));
- text.add(Integer.toString(data.getPid()));
- text.add(data.getApiName());
- text.add(data.getArgs());
- text.add(data.getReturn());
- text.add(data.getLibName());
- } else if (logData instanceof ProfileData) {
- ProfileData data = (ProfileData) logData;
- String time = Formatter.toTimeFormat(data.getTime());
- text.add(time);
- text.add(Integer.toString(data.getTid()));
- text.add(Integer.toString(data.getPid()));
- text.add(data.getApiName());
- text.add(data.getArgs());
- text.add(data.getReturn());
- text.add(data.getLibName());
- } else {
- DA_LOG.debug("wrong log data in calltrace view");
- continue;
- }
+
+ long time = (Long) rowData.get(FunctionEntryDBTable.COLUMN.STARTTIME.index);
+ String strTime = Formatter.toTimeFormat(time);
+ text.add(strTime);
+ text.add(rowData.get(FunctionEntryDBTable.COLUMN.TID.index).toString());
+ text.add(rowData.get(FunctionEntryDBTable.COLUMN.PID.index).toString());
+ text.add(rowData.get(FunctionEntryDBTable.COLUMN.FUNCTIONNAME.index).toString());
+ text.add(rowData.get(FunctionEntryDBTable.COLUMN.ARGUMENT.index).toString());
+ // TODO: ret value
+ text.add("");
+ text.add(rowData.get(FunctionEntryDBTable.COLUMN.BINARYPATH.index).toString());
+
// create DATableDataFormat
DATableDataFormat tableData = new DATableDataFormat(
- logData.getSeq());
- tableData.setLogData(logData);
+ (Long) rowData.get(FunctionEntryDBTable.COLUMN.SEQ.index));
+// tableData.setLogData(logData);
+ tableData.getData().addAll(rowData);
tableData.setType(AnalyzerConstants.TYPE_TABLE_CALLTRACE);
TableInput tableInput = new TableInput();
input.add(tableInput);
if (RangeDataManager.getInstance().isBeingAnalyzed()) {
- long logTime = logData.getTime();
long analysisStartTime = RangeDataManager.getInstance()
.getAnalysisStartTime();
long analysisEndTime = RangeDataManager.getInstance()
.getAnalysisEndTime();
- if (logTime >= analysisStartTime && logTime <= analysisEndTime) {
+ if (time >= analysisStartTime && time <= analysisEndTime) {
tableInput.setInRange(true);
}
}
-
}
return input;
}
protected String getDBTableName() {
- return LogDataFactory.getLogFormatById(
- DataChannelConstants.MSG_FUNCTION_ENTRY).getName();
+ return CallTraceDataManager.getInstance().getFunctionEntryTable().getTableName();
}
protected List<String> getDBTableColumnNames() {
- return LogDataFactory.getLogFormatById(
- DataChannelConstants.MSG_FUNCTION_ENTRY).getDBColumnNames();
+ List<String> columnName = new ArrayList<String>();
+ columnName.add("*");
+ return columnName;
}
public int getItemCountByPid() {
}
protected String getSelectQueryOption() {
- StringBuffer query = new StringBuffer(
- " messageid = " + DataChannelConstants.MSG_FUNCTION_ENTRY);//$NON-NLS-1$
+ StringBuffer query = new StringBuffer(" type = "
+ + AnalyzerConstants.FUNCTION_TYPE_APPINST);
int selectedPid = ToolbarArea.getInstance().getSelectedPid();
if (selectedPid != 0) {
query.append(" and pid =" + selectedPid);//$NON-NLS-1$
}
- query.append(" order by time");//$NON-NLS-1$
+ query.append(" order by " + FunctionEntryDBTable.COLUMN.STARTTIME.name);
return query.toString();
}
protected String getSelectQueryCountOption() {
- StringBuffer query = new StringBuffer(
- " messageid = " + DataChannelConstants.MSG_FUNCTION_ENTRY);//$NON-NLS-1$
+ StringBuffer query = new StringBuffer(" type = "
+ + AnalyzerConstants.FUNCTION_TYPE_APPINST);
int selectedPid = ToolbarArea.getInstance().getSelectedPid();
if (selectedPid != 0) {
query.append(" and pid =" + selectedPid);//$NON-NLS-1$
@Override
protected String getTimeColumnName() {
- String timestr = DBTableManager.COMMON_COLUMN_TIME;
- return timestr;
+ return FunctionEntryDBTable.COLUMN.STARTTIME.name;
}
-
}
\ No newline at end of file
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+
+package org.tizen.dynamicanalyzer.ui.timeline.calltrace;
+
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.util.List;
+
+import org.tizen.dynamicanalyzer.common.DALimit;
+import org.tizen.dynamicanalyzer.constant.CommonConstants;
+import org.tizen.dynamicanalyzer.database.DBColumn;
+import org.tizen.dynamicanalyzer.database.DBConstants;
+import org.tizen.dynamicanalyzer.database.DBTable;
+
+public class FunctionEntryDBTable extends DBTable {
+ private static final String TABLENAME="FunctionEntry";
+
+ public enum COLUMN {
+ SEQ(0, "SEQNUMBER"),
+ PID(1, "PID"),
+ TID(2, "TID"),
+ TYPE(3, "Type"),
+ FUNCTIONNAME(4, "FunctionName"),
+ BINARYPATH(5, "BinaryPath"),
+ STARTTIME(6, "StartTime"),
+ CALLERPCADDR(7, DBConstants.DBCOLUMN_CALLER_PC_ADDRESS),
+ PCADDR(8, "PcAddr"),
+ ARGUMENT(9, DBConstants.DBCOLUMN_ARGUMENT);
+
+ 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 FunctionEntryDBTable() {
+ addColumn(new DBColumn(COLUMN.SEQ.name, DBConstants.PRIMARY_KEY, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.PID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.TID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.TYPE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT1));
+ addColumn(new DBColumn(COLUMN.FUNCTIONNAME.name, DBConstants.NOT_NULL,
+ DBConstants.VARCHAR, DALimit.FUNCTION_NAME_LENGTH));
+ addColumn(new DBColumn(COLUMN.BINARYPATH.name, DBConstants.NOT_NULL,
+ DBConstants.VARCHAR, DALimit.FILEPATH_LENGTH));
+ addColumn(new DBColumn(COLUMN.STARTTIME.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.CALLERPCADDR.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.PCADDR.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.ARGUMENT.name, DBConstants.EMPTY,
+ DBConstants.VARCHAR, DALimit.FUNCTION_ARGUMENTS_VALUE_LENGTH));
+ }
+
+ public List<List<Object>> getFunctionEntryFromDB() {
+ return selectData(null, CommonConstants.EMPTY);
+ }
+
+ @Override
+ public boolean prepare(PreparedStatement prep, List<Object> rowData) {
+ boolean isPrepared = true;
+
+ int columnsize = getColumnSize();
+ if (columnsize != rowData.size()) {
+ isPrepared = false;
+ } else {
+ try {
+ prep.setLong(COLUMN.SEQ.index + 1, (Long) (rowData.get(COLUMN.SEQ.index)));
+ prep.setInt(COLUMN.PID.index + 1, (Integer) (rowData.get(COLUMN.PID.index)));
+ prep.setInt(COLUMN.TID.index + 1, (Integer) (rowData.get(COLUMN.TID.index)));
+ prep.setByte(COLUMN.TYPE.index + 1, (Byte) (rowData.get(COLUMN.TYPE.index)));
+
+ String functionStr = clipString((String) (rowData.get(COLUMN.FUNCTIONNAME.index)),
+ DALimit.FUNCTION_NAME_LENGTH, rowData.get(COLUMN.SEQ.index).toString());
+ prep.setString(COLUMN.FUNCTIONNAME.index + 1, functionStr);
+
+ String pathStr = clipString((String) (rowData.get(COLUMN.BINARYPATH.index)),
+ DALimit.FILEPATH_LENGTH, rowData.get(COLUMN.SEQ.index).toString());
+ prep.setString(COLUMN.BINARYPATH.index + 1, pathStr);
+
+ prep.setLong(COLUMN.STARTTIME.index + 1, (Long) (rowData.get(COLUMN.STARTTIME.index)));
+ prep.setLong(COLUMN.CALLERPCADDR.index + 1, (Long) (rowData.get(COLUMN.CALLERPCADDR.index)));
+ prep.setLong(COLUMN.PCADDR.index + 1, (Long) (rowData.get(COLUMN.PCADDR.index)));
+
+ String argumentStr = clipString((String) (rowData.get(COLUMN.ARGUMENT.index)),
+ DALimit.FUNCTION_ARGUMENTS_VALUE_LENGTH, rowData.get(COLUMN.SEQ.index).toString());
+ prep.setString(COLUMN.ARGUMENT.index + 1, argumentStr);
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ isPrepared = false;
+ }
+ }
+
+ return isPrepared;
+ }
+}
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+
+package org.tizen.dynamicanalyzer.ui.timeline.calltrace;
+
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.util.List;
+
+import org.tizen.dynamicanalyzer.constant.CommonConstants;
+import org.tizen.dynamicanalyzer.database.DBColumn;
+import org.tizen.dynamicanalyzer.database.DBConstants;
+import org.tizen.dynamicanalyzer.database.DBTable;
+
+public class FunctionExitDBTable extends DBTable {
+ private static final String TABLENAME="FunctionExit";
+ public static final int FUNCTION_RETURN_VALUE_LENGTH = 1024;
+
+ public enum COLUMN {
+ ENTRYSEQ(0, "EntrySEQNUMBER"),
+ EXITSEQ(1, "ExitSEQNUMBER"),
+ ENDTIME(2, "EndTime"),
+ RETURN(3, DBConstants.DBCOLUMN_RETURN_VALUE);
+
+ 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 FunctionExitDBTable() {
+ addColumn(new DBColumn(COLUMN.ENTRYSEQ.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.EXITSEQ.name, DBConstants.PRIMARY_KEY, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.ENDTIME.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.RETURN.name, DBConstants.EMPTY,
+ DBConstants.DBTYPE_VARCHAR, FUNCTION_RETURN_VALUE_LENGTH));
+ }
+
+ public List<List<Object>> getFunctionExitFromDB() {
+ return selectData(null, CommonConstants.EMPTY);
+ }
+
+ @Override
+ public boolean prepare(PreparedStatement prep, List<Object> rowData) {
+ boolean isPrepared = true;
+
+ int columnsize = getColumnSize();
+ if (columnsize != rowData.size()) {
+ isPrepared = false;
+ } else {
+ try {
+ prep.setLong(COLUMN.ENTRYSEQ.index + 1, (Long) (rowData.get(COLUMN.ENTRYSEQ.index)));
+ prep.setLong(COLUMN.EXITSEQ.index + 1, (Long) (rowData.get(COLUMN.EXITSEQ.index)));
+ prep.setLong(COLUMN.ENDTIME.index + 1, (Long) (rowData.get(COLUMN.ENDTIME.index)));
+
+ String retStr = clipString((String) (rowData.get(COLUMN.RETURN.index)),
+ FUNCTION_RETURN_VALUE_LENGTH, rowData.get(COLUMN.RETURN.index).toString());
+ prep.setString(COLUMN.RETURN.index + 1, retStr);
+ } catch (SQLException e) {
+ e.printStackTrace();
+ isPrepared = false;
+ }
+ }
+
+ return isPrepared;
+ }
+}
import org.tizen.dynamicanalyzer.swap.logparser.SWAPLogParser;
import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackInserter;
import org.tizen.dynamicanalyzer.ui.page.UpdateViewTimer;
+import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler;
import org.tizen.dynamicanalyzer.util.DALogger;
public class StopLogProcessor implements Runnable {
SqlManager.getInstance().insertProcessInfo();
SqlManager.getInstance().saveLeakData();
SqlManager.getInstance().saveFailedData();
-// SqlManager.getInstance().saveCallStackData();
-// SqlManager.getInstance().saveCallStackUnits();
CallStackInserter.getInstance().stopInserterThread();
- SqlManager.getInstance().saveProfilingData();
- SqlManager.getInstance().saveProfilingChildData();
+ FunctionUsageProfiler.getInstance().saveProfilingData();
+ FunctionUsageProfiler.getInstance().saveProfilingChildData();
SqlManager.getInstance().saveApiNames();
SqlManager.getInstance().closeConnection();
DA_LOG.debug("insert to db complete..."); //$NON-NLS-1$
pd.setInclEsapsedAvgTime(exeAvgTime);
pd.setExclEsapsedAvgTime(inExeAvgTime);
pd.setParent(input.getParent());
- pd.setCalssKeyName(getClassName(input.getSaveData())); // index 10;
+ //TODO: ProfilingData.getSaveData is deprecated, below code must be fixed.
+// pd.setCalssKeyName(getClassName(input.getSaveData())); // index 10;
if (bUpdateData == true) {
getDataList().add(nChangedIndex, pd);
projects / sdk / tools / dynamic-analyzer.git / commitdiff