public static final int SHADER_VARIABLE_LENGTH = 1024;
// Network Analysis
public static final int HTML_SCRIPT_LENGTH = 4096;
+ // Thread Analysis
+ public static final int CLASS_NAME_LENGTH = 1024;
+ public static final int TOOLTIP_LENGTH = 256;
/*
public ProbeCommonData() {
}
+ /* load from Database */
+ public ProbeCommonData(int seq, long time, int apiId, int pid, int tid, String args,
+ String ret, int errno) {
+ this.seq = seq;
+ this.time = time;
+ this.apiId = apiId;
+ this.pid = pid;
+ this.tid = tid;
+ this.args = args;
+ this.ret = ret;
+ this.errno = errno;
+ }
+
public ProbeCommonData clone() throws CloneNotSupportedException {
ProbeCommonData log = (ProbeCommonData) super.clone();
log.apiId = this.apiId;
return pThreadId;
}
- public void setpThreadId(long pThreadId) {
+ public void setPThreadId(long pThreadId) {
this.pThreadId = pThreadId;
}
|| data.getErrNo() != 0) {
continue;
}
- double time = Formatter.toLongTimeForDoubleTime(data.getEventTime());
+ double time = Formatter.longTimeToDoubleTime(data.getEventTime());
switch(data.getApiType()){
case LogCenterConstants.FD_API_TYPE_OPEN:
if(openNum > 0){ // duplicated open
List<FileAccess> accessList = dataMaker.getFileAccessList();
for (int i = 0; i < accessList.size(); i++) {
FileAccess access = accessList.get(i);
- double startTime = Formatter.toLongTimeForDoubleTime(access
+ double startTime = Formatter.longTimeToDoubleTime(access
.getStartTime());
- double endTime = Formatter.toLongTimeForDoubleTime(access
+ double endTime = Formatter.longTimeToDoubleTime(access
.getEndTime());
double visibleStartTime = getVisibleStartTime();
double visibleEndTime = getVisibleEndTime();
@Override
public void run() {
isBeingAnalyzed = false;
- DAPageComposite page = AnalyzerManager.getCurrentPage();
- if (page instanceof RangePage) {
- AnalyzerUtil.changePage(TimelinePage.pageID);
- } else {
- page.updateView();
- }
+ AnalyzerUtil.changePage(TimelinePage.pageID);
DATabComposite mainTab = AnalyzerUtil.getMainTab();
if (null != mainTab.getView(RangePage.pageID)) {
*/
package org.tizen.dynamicanalyzer.ui.thread;
+import java.sql.ResultSet;
+import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.swt.widgets.Composite;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.DASelectionData;
+import org.tizen.dynamicanalyzer.database.SqlConnectionManager;
import org.tizen.dynamicanalyzer.error.ErrorCodeManager;
import org.tizen.dynamicanalyzer.model.TableInput;
import org.tizen.dynamicanalyzer.swap.model.data.LogData;
import org.tizen.dynamicanalyzer.swap.model.data.ProbeCommonData;
+import org.tizen.dynamicanalyzer.ui.thread.data.SyncAPIDBTable;
+import org.tizen.dynamicanalyzer.ui.thread.data.ThreadAPIDBTable;
+import org.tizen.dynamicanalyzer.ui.thread.sync.ThreadPageSyncData;
+import org.tizen.dynamicanalyzer.ui.thread.thread.ThreadPageThreadData;
import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants;
import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
import org.tizen.dynamicanalyzer.ui.widgets.table.DAApiListTableComposite;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableDataFormat;
+import org.tizen.dynamicanalyzer.util.Logger;
import org.tizen.dynamicanalyzer.utils.Formatter;
public class ThreadAPIListTable extends DAApiListTableComposite {
+ private enum API {
+ SEQ(1),
+ APICALLTIME(2),
+ APIID(3),
+ PID(4),
+ TID(5),
+ ARGUMENT(6),
+ RETURN(7),
+ ERRORNO(8);
+
+ public final int index;
+
+ API(int index) {
+ this.index = index;
+ }
+ }
+
public ThreadAPIListTable(Composite parent, int compStyle, int tableStyle) {
super(parent, compStyle, tableStyle);
table.addSelectionListener(new SelectionListener() {
}
List<TableInput> input = new ArrayList<TableInput>();
+ ResultSet rs = null;
- List<ThreadPageDataEvent> contents = data.getContents();
-
- ThreadPageDataEvent content;
- for (int i = 0; i < contents.size(); i++) {
- content = contents.get(i);
- ProbeCommonData contentTemp = (ProbeCommonData) content
- .getContents();
- int selectedPid = ToolbarArea.getInstance().getSelectedPid();
- if (selectedPid != 0) {
- if (selectedPid != contentTemp.getPid()) {
- continue;
- }
+ if (data instanceof ThreadPageThreadData) {
+ ThreadPageThreadData tData = (ThreadPageThreadData) data;
+ String query = String.format(ThreadAPIDBTable.SELECT_QUERY, tData.getThreadDataID());
+ rs = SqlConnectionManager.executeQueryRS(query);
+ if (null == rs) {
+ Logger.debug("failed to query api data in thread API table");
+ return null;
}
- List<String> contentText = new ArrayList<String>();
- List<String> contentData = new ArrayList<String>();
-
- String seq = Integer.toString(contentTemp.getSeq());
- contentText.add(0, seq);
- contentData.add(seq);
-
- contentText.add(Formatter.toTimeFormat(contentTemp.getTime()));
- contentData.add(Long.toString(contentTemp.getTime()));
-
- contentText.add(Integer.toString(contentTemp.getPid()));
- contentData.add(Integer.toString(contentTemp.getPid()));
-
- contentText.add(Long.toString(contentTemp.getTid()));
- contentData.add(Long.toString(contentTemp.getTid()));
-
- contentText.add(contentTemp.getApiName());
- contentData.add(contentTemp.getApiName());
-
- contentText.add(contentTemp.getArgs());
- contentData.add(contentTemp.getArgs());
-
- contentText.add(contentTemp.getReturn());
- contentData.add(contentTemp.getReturn());
+ } else if (data instanceof ThreadPageSyncData) {
+ ThreadPageSyncData sData = (ThreadPageSyncData) data;
+ String query = String.format(SyncAPIDBTable.SELECT_QUERY, sData.getSyncDataID());
+ rs = SqlConnectionManager.executeQueryRS(query);
+ if (null == rs) {
+ Logger.debug("failed to query api data in sync API table");
+ return null;
+ }
+ } else {
+ Logger.error("unknown thread page data type!!");
+ return null;
+ }
- String errMsg = ErrorCodeManager.getInatance()
- .getErrorCode(contentTemp.getErrno()).name();
- if (null == errMsg) {
- errMsg = "undefined error code";
- }
- contentText.add(errMsg);
- contentData.add(errMsg);
-
- DATableDataFormat tableData = new DATableDataFormat(
- contentTemp.getSeq());
- tableData.setLogData(contentTemp);
- tableData.getData().addAll(contentData);
- TableInput tableInput = new TableInput();
- tableInput.setText(contentText);
- tableInput.setData(tableData);
- if (!errMsg.contains("SUCCESS")) {//$NON-NLS-1$
- tableInput.setFailed(true);
+ try {
+ while(rs.next()) {
+ ProbeCommonData apiData = makeProbeCommonData(rs);
+
+ int selectedPid = ToolbarArea.getInstance().getSelectedPid();
+ if (selectedPid != 0) {
+ if (selectedPid != apiData.getPid()) {
+ continue;
+ }
+ }
+ List<String> contentText = new ArrayList<String>();
+ List<String> contentData = new ArrayList<String>();
+
+ contentText.add(0, String.valueOf(apiData.getSeq()));
+ contentData.add(String.valueOf(apiData.getSeq()));
+
+ contentText.add(Formatter.toTimeFormat(apiData.getTime()));
+ contentData.add(Long.toString(apiData.getTime()));
+
+ contentText.add(Integer.toString(apiData.getPid()));
+ contentData.add(Integer.toString(apiData.getPid()));
+
+ contentText.add(Long.toString(apiData.getTid()));
+ contentData.add(Long.toString(apiData.getTid()));
+
+ contentText.add(apiData.getApiName());
+ contentData.add(apiData.getApiName());
+
+ contentText.add(apiData.getArgs());
+ contentData.add(apiData.getArgs());
+
+ contentText.add(apiData.getReturn());
+ contentData.add(apiData.getReturn());
+
+ String errMsg = ErrorCodeManager.getInatance()
+ .getErrorCode(apiData.getErrno()).name();
+ if (null == errMsg) {
+ errMsg = "undefined error code";
+ }
+ contentText.add(errMsg);
+ contentData.add(errMsg);
+
+ DATableDataFormat tableData = new DATableDataFormat(apiData.getSeq());
+ tableData.setLogData(apiData);
+ tableData.getData().addAll(contentData);
+ TableInput tableInput = new TableInput();
+ tableInput.setText(contentText);
+ tableInput.setData(tableData);
+ if (!errMsg.contains("SUCCESS")) {//$NON-NLS-1$
+ tableInput.setFailed(true);
+ }
+ input.add(tableInput);
+
+ if (apiData.getTime() >= rangeStartTime && apiData.getTime() <= rangeEndTime) {
+ tableInput.setInRange(true);
+ }
}
- input.add(tableInput);
-
- long time = contentTemp.getTime();
- if (time >= rangeStartTime && time <= rangeEndTime) {
- tableInput.setInRange(true);
+ } catch (SQLException e) {
+ e.printStackTrace();
+ } finally {
+ if (rs != null) {
+ SqlConnectionManager.releaseResultSet(rs);
}
}
chartview.setRangeMarker(startTime, endTime);
}
}
-}
+
+ private ProbeCommonData makeProbeCommonData(ResultSet rs) {
+ ProbeCommonData pData = null;
+ try {
+ int seq = rs.getInt(API.SEQ.index);
+ long time = rs.getLong(API.APICALLTIME.index);
+ int apiID = rs.getInt(API.APIID.index);
+ int pid = rs.getInt(API.PID.index);
+ int tid = rs.getInt(API.TID.index);
+ String args = rs.getString(API.ARGUMENT.index);
+ String returnValue = rs.getString(API.RETURN.index);
+ int errorno = rs.getInt(API.ERRORNO.index);
+
+ pData = new ProbeCommonData(seq, time, apiID, pid, tid, args, returnValue, errorno);
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+ return pData;
+ }
+}
\ No newline at end of file
* Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved.
*
* Contact:
+ * WooJin Jung <woojin2.jung@samsung.com>
* yeongtaik byeon <yeongtaik.byeon@samsung.com>
* Juyoung Kim <j0.kim@samsung.com>
*
package org.tizen.dynamicanalyzer.ui.thread;
+import java.util.ArrayList;
import java.util.List;
+import java.util.Map;
+import org.tizen.dynamicanalyzer.database.SqlConnectionManager;
+import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;
import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants;
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.ui.thread.data.SyncAPIDBTable;
+import org.tizen.dynamicanalyzer.ui.thread.data.SyncDataDBTable;
+import org.tizen.dynamicanalyzer.ui.thread.data.SyncEventDBTable;
+import org.tizen.dynamicanalyzer.ui.thread.data.ThreadAPIDBTable;
+import org.tizen.dynamicanalyzer.ui.thread.data.ThreadDataDBTable;
+import org.tizen.dynamicanalyzer.ui.thread.data.ThreadEventDBTable;
+import org.tizen.dynamicanalyzer.ui.thread.sync.ThreadPageSyncData;
+import org.tizen.dynamicanalyzer.ui.thread.sync.ThreadPageSyncDataEvent;
import org.tizen.dynamicanalyzer.ui.thread.sync.ThreadPageSyncDataManager;
+import org.tizen.dynamicanalyzer.ui.thread.thread.ThreadPageThreadData;
+import org.tizen.dynamicanalyzer.ui.thread.thread.ThreadPageThreadDataEvent;
import org.tizen.dynamicanalyzer.ui.thread.thread.ThreadPageThreadDataManager;
+import org.tizen.dynamicanalyzer.util.Logger;
import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoard;
public class ThreadChartManager extends PageDataManager {
private static ThreadChartManager instance = null;
+
+ private ThreadDataDBTable threadDataTable = null;
+ private ThreadEventDBTable threadEventTable = null;
+ private ThreadAPIDBTable threadAPITable = null;
+
+ private SyncDataDBTable syncDataTable = null;
+ private SyncEventDBTable syncEventTable = null;
+ private SyncAPIDBTable syncAPITable = null;
private ThreadPageThreadDataManager tManager;
private ThreadPageSyncDataManager sManager;
+ private enum THREADEVENT {
+ EVENTTIME(0),
+ TID(1),
+ APITYPE(2),
+ TOOLTIP(3),
+ ERRORNO(4),
+ EVENTTYPE(5),
+ THREADTYPE(6),
+ CALLERID(7);
+
+ public final int index;
+
+ THREADEVENT(int index) {
+ this.index = index;
+ }
+ }
+
+ private enum SYNCEVENT {
+ EVENTTIME(0),
+ APITYPE(1),
+ TOOLTIP(2),
+ ERRORNO(3),
+ SYNCVALUE(4);
+
+ public final int index;
+
+ SYNCEVENT(int index) {
+ this.index = index;
+ }
+ }
+
private ThreadChartManager() {
+ threadDataTable = new ThreadDataDBTable();
+ threadEventTable = new ThreadEventDBTable();
+ threadAPITable = new ThreadAPIDBTable();
+
+ syncDataTable = new SyncDataDBTable();
+ syncEventTable = new SyncEventDBTable();
+ syncAPITable = new SyncAPIDBTable();
+
tManager = new ThreadPageThreadDataManager(null);
sManager = new ThreadPageSyncDataManager(null);
}
public ThreadPageThreadDataManager getThreadDataManager() {
return tManager;
}
+
+ public ThreadEventDBTable getThreadEventDBTable() {
+ return threadEventTable;
+ }
+
+ public ThreadAPIDBTable getThreadAPIDBTable() {
+ return threadAPITable;
+ }
+
+ public SyncDataDBTable getSyncDataDBTable() {
+ return syncDataTable;
+ }
+
+ public SyncEventDBTable getSyncEventDBTable() {
+ return syncEventTable;
+ }
+
+ public SyncAPIDBTable getSyncAPIDBTable() {
+ return syncAPITable;
+ }
private List<LogData> getLogsFromLogPackage(LogPackage logPack,
int logCenterConstants) {
tManager.clear();
sManager.clear();
}
+
+ @Override
+ protected void onThreadStop() {
+ saveRemainingThreadData();
+ }
+
+ private void saveRemainingThreadData() {
+ // ThreadPageThreadData
+ List<ThreadPageThreadData> remainedThreadData = tManager.getRows();
+ int size = remainedThreadData.size();
+ for (int i = 0; i < size; i++) {
+ ThreadPageThreadData threadData = remainedThreadData.get(i);
+ if (threadData.getEndTime() < 0) {
+ saveThreadPageThreadData(threadData);
+ }
+ }
+ }
+ public void openData(Map<String, String> dataMap) {
+ openThreadData();
+ }
+
+ private void openThreadData() {
+ //TODO: use ResultSet
+ // load ThreadPageThreadData
+ List<List<Object>> threadDatas = threadDataTable.getThreadDataFromDB();
+ int size = threadDatas.size();
+ for (int i = 0; i < size; i++) {
+ List<Object>rowData = threadDatas.get(i);
+ int id = (Integer) rowData.get(ThreadDataDBTable.COLUMN.THREADDATAID.index);
+ int pid = (Integer) rowData.get(ThreadDataDBTable.COLUMN.PID.index);
+ int tid = (Integer) rowData.get(ThreadDataDBTable.COLUMN.TID.index);
+ byte threadType = (Byte) rowData.get(ThreadDataDBTable.COLUMN.THREADTYPE.index);
+ byte attrType = (Byte) rowData.get(ThreadDataDBTable.COLUMN.ATTRIBUTETYPE.index);
+ String attributeType = ThreadPageThreadDataManager.getAttrTypeByTypeInt(attrType);
+ long startTime = (Long) rowData.get(ThreadDataDBTable.COLUMN.STARTTIME.index);
+ long endTime = (Long) rowData.get(ThreadDataDBTable.COLUMN.ENDTIME.index);
+ int functionID = (Integer) rowData.get(ThreadDataDBTable.COLUMN.FUNCTIONID.index);
+ String className = (String) rowData.get(ThreadDataDBTable.COLUMN.CLASSNAME.index);
+
+ ThreadPageThreadData threadData = new ThreadPageThreadData(id, pid, tid, threadType,
+ attributeType, startTime, endTime, functionID, className);
+ tManager.pushRow(threadData);
+
+ // load ThreadPageThreadDataEvent for the ThreadPageThreadData
+ String query = String.format(ThreadEventDBTable.SELECT_QUERY, id);
+ List<List<Object>> threadEvents = SqlConnectionManager.executeQuery(query);
+ int eventSize = threadEvents.size();
+ for (int j = 0; j < eventSize; j++) {
+ ThreadPageThreadDataEvent threadEvent = makeThreadEvent(threadEvents.get(j));
+ threadData.pushEvent(threadEvent);
+ }
+ }
+
+ // load ThreadPageSyncData
+// List<List<Object>> syncDatas = SqlConnectionManager.executeQuery(SyncDataDBTable.SELECT_QUERY);
+ List<List<Object>> syncDatas = syncDataTable.getSyncDataFromDB();
+ int syncSize = syncDatas.size();
+ for (int i = 0; i < syncSize; i++) {
+ ThreadPageSyncData syncData = makeSyncData(syncDatas.get(i));
+ // load ThreadPageSyncDataEvent for the ThreadPageSyncData
+ String query = String.format(SyncEventDBTable.SELECT_QUERY, syncData.getSyncDataID());
+ List<List<Object>> syncEvents = SqlConnectionManager.executeQuery(query);
+ int eventSize = syncEvents.size();
+ for (int j = 0; j < eventSize; j++) {
+ ThreadPageSyncDataEvent syncEvent = makeSyncEvent(syncEvents.get(j));
+ syncData.pushEvent(syncEvent);
+ }
+
+ switch (syncData.getSyncDataType()) {
+ case ThreadPageSyncData.SYNC_PARENT:
+ case ThreadPageSyncData.SYNC_CHILD:
+ sManager.pushRow(syncData);
+ break;
+ case ThreadPageSyncData.THREAD_CHILD:
+ tManager.pushSyncData(syncData);
+ break;
+ default:
+ Logger.error("unknown sync data type");
+ }
+ }
+ }
+
+ private ThreadPageThreadDataEvent makeThreadEvent(List<Object> rowData) {
+ ThreadPageThreadDataEvent threadEvent = null;
+ long time = (Long) rowData.get(THREADEVENT.EVENTTIME.index);
+ int tid = (Integer) rowData.get(THREADEVENT.TID.index);
+ String tidStr = String.valueOf(tid);
+ byte apiType = (Byte) rowData.get(THREADEVENT.APITYPE.index);
+ String tooltip = (String) rowData.get(THREADEVENT.TOOLTIP.index);
+ long errorNum = (Long) rowData.get(THREADEVENT.ERRORNO.index);
+ byte eventType = (Byte) rowData.get(THREADEVENT.EVENTTYPE.index);
+ int threadType = (Integer) rowData.get(THREADEVENT.THREADTYPE.index);
+ int callerId = (Integer) rowData.get(THREADEVENT.CALLERID.index);
+ String callerIdStr = null;
+ if (callerId != -1) {
+ callerIdStr = String.valueOf(callerId);
+ }
+
+ threadEvent = new ThreadPageThreadDataEvent(eventType, threadType, apiType, time,
+ tidStr, tooltip, errorNum, null);
+ threadEvent.setCallerTid(callerIdStr);
+
+ return threadEvent;
+ }
+
+ private ThreadPageSyncData makeSyncData(List<Object> rowData) {
+ ThreadPageSyncData syncData = null;
+ int id = (Integer) rowData.get(SyncDataDBTable.COLUMN.SYNCDATAID.index);
+ int pid = (Integer) rowData.get(SyncDataDBTable.COLUMN.PID.index);
+ int tid = (Integer) rowData.get(SyncDataDBTable.COLUMN.TID.index);
+ byte syncType = (Byte) rowData.get(SyncDataDBTable.COLUMN.SYNCTYPE.index);
+ long syncValue = (Long) rowData.get(SyncDataDBTable.COLUMN.SYNCVALUE.index);
+ byte attrType = (Byte) rowData.get(SyncDataDBTable.COLUMN.ATTRIBUTETYPE.index);
+ String attributeType = ThreadPageSyncDataManager.getAttrTypeByTypeInt(attrType);
+ byte syncDataType = (Byte) rowData.get(SyncDataDBTable.COLUMN.SYNCDATATYPE.index);
+ int parentID = (Integer) rowData.get(SyncDataDBTable.COLUMN.PARENTID.index);
+
+ syncData = new ThreadPageSyncData(id, pid, tid, syncType, syncValue, attributeType,
+ syncDataType, parentID);
+
+ return syncData;
+ }
+
+ private ThreadPageSyncDataEvent makeSyncEvent(List<Object> rowData) {
+ ThreadPageSyncDataEvent syncEvent = null;
+ long time = (Long) rowData.get(SYNCEVENT.EVENTTIME.index);
+ byte apiType = (Byte) rowData.get(SYNCEVENT.APITYPE.index);
+ String tooltip = (String) rowData.get(SYNCEVENT.TOOLTIP.index);
+ long errorNum = (Long) rowData.get(SYNCEVENT.ERRORNO.index);
+ long syncValue = (Long) rowData.get(SYNCEVENT.SYNCVALUE.index);
+ String syncValueStr = String.valueOf(syncValue);
+
+ syncEvent = new ThreadPageSyncDataEvent(time, apiType, tooltip, errorNum, syncValueStr);
+
+ return syncEvent;
+ }
+
public int getItemIndexByTid(String tid) {
return tManager.getItemIndexByTid(tid);
}
}
}
}
-}
+
+ public void saveThreadPageThreadData(ThreadPageData threadPageData) {
+ List<List<Object>> insertData = new ArrayList<List<Object>>();
+ List<Object> insertRowData = new ArrayList<Object>();
+
+ if (threadPageData instanceof ThreadPageThreadData) {
+ ThreadPageThreadData threadData = (ThreadPageThreadData) threadPageData;
+ try {
+ insertRowData.add(new Integer(threadData.getThreadDataID()));
+ insertRowData.add(new Integer(threadData.getPid()));
+ insertRowData.add(new Integer(threadData.getTid()));
+ Integer type = new Integer(threadData.getType());
+ byte threadType = type.byteValue();
+ insertRowData.add(new Byte(threadType));
+ String attrTypeStr = threadData.getAttrType();
+ byte attrType = -1;
+ if (attrTypeStr.equals(ThreadPageLabels.THREAD_ATTR_TYPE_JOINABLE)) {
+ attrType = ThreadPageThreadDataManager.PTHREAD_CREATE_JOINABLE;
+ } else if (attrTypeStr.equals(ThreadPageLabels.THREAD_ATTR_TYPE_DETACHED)) {
+ attrType = ThreadPageThreadDataManager.PTHREAD_CREATE_DETACHED;
+ } else { // main thread has no attribute
+ attrType = -1;
+ }
+ insertRowData.add(new Byte(attrType));
+ insertRowData.add(new Long(threadData.getStartTime()));
+ insertRowData.add(new Long(threadData.getEndTime()));
+ insertRowData.add(new Integer(threadData.getThreadFuncID()));
+ insertRowData.add(new String(threadData.getThreadClassName()));
+ } catch (ArrayIndexOutOfBoundsException e) {
+ e.printStackTrace();
+ }
+ insertData.add(insertRowData);
+ } else if (threadPageData instanceof ThreadPageSyncData) {
+
+ } else {
+ Logger.error("Unknown ThreadPageData type!");
+ }
+
+ if (insertData.size() > 0) {
+ threadDataTable.insertData(insertData);
+ }
+ }
+}
\ No newline at end of file
String str;
if (item instanceof ThreadPageThreadData) {
tid = item.getTid();
- type = item.getType();
+ type = ((ThreadPageThreadData) item).getTypeString();
str = ((ThreadPageThreadData) item).getThreadFuncName();
if (null != str && !(str.equals(CommonConstants.EMPTY))) {
funcName = str;
if (null != str && !(str.equals(CommonConstants.EMPTY))) {
className = str;
}
- str = ((ThreadPageThreadData) item).getStartTime();
+ str = ((ThreadPageThreadData) item).getStartTimeString();
if (null != str && !(str.equals(CommonConstants.EMPTY))) {
startTime = str;
}
- str = ((ThreadPageThreadData) item).getEndTime();
+ str = ((ThreadPageThreadData) item).getEndTimeString();
if (null != str && !(str.equals(CommonConstants.EMPTY))) {
endTime = str;
}
attrType = str;
}
} else if (item instanceof ThreadPageSyncData) {
- type = item.getType();
+ type = ((ThreadPageSyncData) item).getTypeString();
ThreadPageSyncData syncItem = (ThreadPageSyncData) item;
List<ThreadPageSyncData> children = syncItem.getChildren();
int childrenSize = children.size();
if (!tid.equals(item.getTid())) {
return true;
}
- if (!type.equals(item.getType())) {
+ if (!type.equals(((ThreadPageThreadData) item).getTypeString())) {
return true;
}
if (!funcName.equals(((ThreadPageThreadData) item).getThreadFuncName())) {
if (!className.equals(((ThreadPageThreadData) item).getThreadClassName())) {
return true;
}
- if (!startTime.equals(((ThreadPageThreadData) item).getStartTime())) {
+ if (!startTime.equals(((ThreadPageThreadData) item).getStartTimeString())) {
return true;
}
- if (!endTime.equals(((ThreadPageThreadData) item).getEndTime())) {
+ if (!endTime.equals(((ThreadPageThreadData) item).getEndTimeString())) {
return true;
}
if (!attrType.equals(item.getAttrType())) {
canvas.redraw();
}
-}
+}
\ No newline at end of file
import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;
import org.tizen.dynamicanalyzer.resources.ColorResources;
-import org.tizen.dynamicanalyzer.ui.summary.SummaryDataManager;
import org.tizen.dynamicanalyzer.widgets.chart.DAChart;
import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeriesItem;
import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoardItem;
public abstract class ThreadPageData {
private String pid;
private String tid;
- private String type;
+ private int type;
private String key;
private String attrType;
protected DAChartBoardItem item;
protected DAChart chart;
protected boolean hasUpdate = false;
- public ThreadPageData(String type, String name, String pid, String tid, String attrType) {
+ public ThreadPageData(int type, String name, String pid, String tid, String attrType) {
setType(type);
setKey(name);
setPid(pid);
this.pid = pid;
}
- public String getType() {
+ public int getType() {
return type;
}
- public void setType(String type) {
+ public void setType(int type) {
this.type = type;
}
ThreadPageDataEvent event, long errno) {
DAChartSeriesItem apiItem = null;
if (0 != errno) {
-// FailedData ffd = new FailedData(event.getContents());
-// AnalyzerManager.getFailedChecker().getFailedList().add(ffd);
- SummaryDataManager.getInstance().getFailedApiDataMaker().
- makeData(event.getContents());
- apiItem = new DAChartSeriesItem(event.getTime(),
+ apiItem = new DAChartSeriesItem(event.getDoubleTime(),
DAChartSeriesItem.SERIES_STATE_BAR,
ColorResources.RED, event.getTooltipContent()
+ ThreadPageLabels.SYNC_CHART_ITEM_FAILED);
} else {
- apiItem = new DAChartSeriesItem(event.getTime(),
+ apiItem = new DAChartSeriesItem(event.getDoubleTime(),
DAChartSeriesItem.SERIES_STATE_BAR,
ColorResources.YELLOW, event.getTooltipContent());
}
return apiItem;
}
-}
+}
\ No newline at end of file
package org.tizen.dynamicanalyzer.ui.thread;
import org.tizen.dynamicanalyzer.swap.model.data.LogData;
+import org.tizen.dynamicanalyzer.utils.Formatter;
-public abstract class ThreadPageDataEvent {
+public abstract class ThreadPageDataEvent implements Cloneable {
private LogData contents;
- private double time = -1;
+ private long time = -1;
private String tid = null;
private int apiType = -1;
private String tooltip = null;
private long errorNum = -1;
- public ThreadPageDataEvent(double time, String tid, int apiType,
+ public ThreadPageDataEvent(long time, String tid, int apiType,
String tooltip, long errorNum, LogData contents) {
setTime(time);
setTid(tid);
setErrorNum(errorNum);
setContents(contents);
}
+
+ public ThreadPageDataEvent clone() throws CloneNotSupportedException {
+ ThreadPageDataEvent dataEvent = (ThreadPageDataEvent) super.clone();
+ dataEvent.setContents(contents);
+ dataEvent.setTime(time);
+ dataEvent.setTid(tid);
+ dataEvent.setApiType(apiType);
+ dataEvent.setTooltipContent(tooltip);
+ dataEvent.setErrorNum(errorNum);
+
+ return dataEvent;
+ }
public LogData getContents() {
return contents;
this.contents = contents;
}
- public double getTime() {
+ public long getTime() {
return time;
- }
+ }
- public void setTime(double time) {
+ public void setTime(long time) {
this.time = time;
}
+
+ public double getDoubleTime() {
+ double dTime = Formatter.longTimeToDoubleTime(time);
+ return dTime;
+ }
public String getTid() {
return tid;
public void setErrorNum(long errorNum) {
this.errorNum = errorNum;
}
-}
+}
\ 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.thread.data;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+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;
+import org.tizen.dynamicanalyzer.database.IResultSet;
+
+public class SyncAPIDBTable extends DBTable implements IResultSet {
+ public static final String TABLENAME="SyncAPI";
+
+ private static final String SELECT_COLUMN =
+ COLUMN.SEQ.name + CommonConstants.COMMA +
+ COLUMN.APICALLTIME.name + CommonConstants.COMMA +
+ COLUMN.APIID.name + CommonConstants.COMMA +
+ COLUMN.PID.name + CommonConstants.COMMA +
+ COLUMN.TID.name + CommonConstants.COMMA +
+ COLUMN.ARGUMENT.name + CommonConstants.COMMA +
+ COLUMN.RETURN.name + CommonConstants.COMMA +
+ COLUMN.ERRORNO.name;
+ public static final String SELECT_QUERY =
+ "select " + SELECT_COLUMN + " from " + SyncEventDBTable.TABLENAME +
+ CommonConstants.COMMA + TABLENAME +
+ " where " + SyncEventDBTable.COLUMN.SYNCDATAID.name + " = %s and " +
+ SyncEventDBTable.COLUMN.API_SEQNUMBER.name + " = " + COLUMN.SEQ.name;
+
+ public enum COLUMN {
+ SEQ(0, "SEQNUMBER"),
+ APICALLTIME(1, "APICallTime"),
+ APIID(2, "APIID"),
+ PID(3, "PID"),
+ TID(4, "TID"),
+ ARGUMENT(5, DBConstants.DBCOLUMN_ARGUMENT),
+ RETURN(6, DBConstants.DBCOLUMN_RETURN_VALUE),
+ ERRORNO(7, DBConstants.DBCOLUMN_ERROR_NUMBER),
+ SYNCVALUE(8, "SyncValue");
+
+ 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 SyncAPIDBTable() {
+ addColumn(new DBColumn(COLUMN.SEQ.name, DBConstants.PRIMARY_KEY, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.APICALLTIME.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.APIID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ 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.ARGUMENT.name, DBConstants.EMPTY,
+ DBConstants.DBTYPE_VARCHAR, DALimit.FUNCTION_ARGUMENTS_VALUE_LENGTH));
+ addColumn(new DBColumn(COLUMN.RETURN.name, DBConstants.EMPTY,
+ DBConstants.DBTYPE_VARCHAR, DALimit.FUNCTION_RETURN_VALUE_LENGTH));
+ addColumn(new DBColumn(COLUMN.ERRORNO.name, DBConstants.EMPTY, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.SYNCVALUE.name, DBConstants.EMPTY, DBConstants.DBTYPE_LONG));
+ }
+
+ public List<List<Object>> getSyncAPIFromDB() {
+ return selectAllColumnData(null);
+ }
+
+ @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.APICALLTIME.index + 1, (Long) (rowData.get(COLUMN.APICALLTIME.index)));
+ prep.setInt(COLUMN.APIID.index + 1, (Integer) (rowData.get(COLUMN.APIID.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)));
+ 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);
+ String retStr = clipString((String) (rowData.get(COLUMN.RETURN.index)),
+ DALimit.FUNCTION_RETURN_VALUE_LENGTH, rowData.get(COLUMN.SEQ.index).toString());
+ prep.setString(COLUMN.RETURN.index + 1, retStr);
+ prep.setLong(COLUMN.ERRORNO.index + 1, (Long) (rowData.get(COLUMN.ERRORNO.index)));
+ prep.setLong(COLUMN.SYNCVALUE.index + 1, (Long) (rowData.get(COLUMN.SYNCVALUE.index)));
+ } catch (SQLException e) {
+ e.printStackTrace();
+ isPrepared = false;
+ }
+ }
+
+ return isPrepared;
+ }
+
+ @Override
+ public List<Object> extractDataFromResultSet(ResultSet rs) {
+ List<Object> row = new ArrayList<Object>();
+ try {
+ row.add(Long.valueOf(rs.getLong(COLUMN.SEQ.index + 1)));
+ row.add(Long.valueOf(rs.getLong(COLUMN.APICALLTIME.index + 1)));
+ row.add(Integer.valueOf(rs.getInt(COLUMN.APIID.index + 1)));
+ row.add(Integer.valueOf(rs.getInt(COLUMN.PID.index + 1)));
+ row.add(Integer.valueOf(rs.getInt(COLUMN.TID.index + 1)));
+ row.add(rs.getString(COLUMN.ARGUMENT.index + 1));
+ row.add(rs.getString(COLUMN.RETURN.index + 1));
+ row.add(Long.valueOf(rs.getLong(COLUMN.ERRORNO.index + 1)));
+ row.add(Long.valueOf(rs.getLong(COLUMN.SYNCVALUE.index + 1)));
+ } catch (SQLException e) {
+ e.printStackTrace();
+ return null;
+ }
+
+ return row;
+ }
+}
--- /dev/null
+/*\r
+ * Dynamic Analyzer\r
+ *\r
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.\r
+ *\r
+ * Contact: \r
+ * WooJin Jung <woojin2.jung@samsung.com>\r
+ * Juyoung Kim <j0.kim@samsung.com>\r
+ *\r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ * \r
+ * Contributors:\r
+ * - S-Core Co., Ltd\r
+ * \r
+ */\r
+\r
+package org.tizen.dynamicanalyzer.ui.thread.data;\r
+\r
+import java.util.ArrayList;\r
+import java.util.List;\r
+import java.util.concurrent.LinkedBlockingQueue;\r
+\r
+import org.tizen.dynamicanalyzer.common.AnalyzerConstants;\r
+import org.tizen.dynamicanalyzer.common.AnalyzerManager;\r
+import org.tizen.dynamicanalyzer.swap.model.data.SyncData;\r
+import org.tizen.dynamicanalyzer.ui.thread.ThreadChartManager;\r
+//TODO: use DBInserter\r
+public class SyncAPIInserter implements Runnable {\r
+ private static LinkedBlockingQueue<SyncData> syncAPIQueue = new LinkedBlockingQueue<SyncData>();\r
+\r
+ private static volatile Thread inserterThread = null;\r
+\r
+ public static void startThread() {\r
+ if (inserterThread == null || !inserterThread.isAlive()) {\r
+ synchronized (SyncAPIInserter.class) {\r
+ if (inserterThread == null || !inserterThread.isAlive()) {\r
+ inserterThread = new Thread(null,\r
+ new SyncAPIInserter());\r
+ inserterThread.start();\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ public static void stopThread() {\r
+ if (inserterThread != null && inserterThread.isAlive()) {\r
+ try {\r
+ sendNotify();\r
+ inserterThread.join(AnalyzerConstants.THREAD_JOIN_WAIT_TIME);\r
+ } catch (InterruptedException e) {\r
+ e.printStackTrace();\r
+ }\r
+ }\r
+ }\r
+\r
+ public static void pushSyncEvent(SyncData syncAPI) {\r
+ syncAPIQueue.offer(syncAPI);\r
+ }\r
+\r
+ public static void clear() {\r
+ stopThread();\r
+ }\r
+\r
+ @Override\r
+ public void run() {\r
+ while (!AnalyzerManager.isExit()) {\r
+ SyncData syncAPI = syncAPIQueue.poll();\r
+\r
+ if (syncAPI != null) {\r
+ ArrayList<List<Object>> insertData = new ArrayList<List<Object>>(); \r
+ List<Object> insertRowData = new ArrayList<Object>();\r
+ try {\r
+ insertRowData.add(new Long(syncAPI.getSeq()));\r
+ insertRowData.add(new Long(syncAPI.getTime()));\r
+ insertRowData.add(new Integer(syncAPI.getApiId()));\r
+ insertRowData.add(new Integer(syncAPI.getPid()));\r
+ insertRowData.add(new Integer(syncAPI.getTid()));\r
+ insertRowData.add(new String(syncAPI.getArgs()));\r
+ insertRowData.add(new String(syncAPI.getReturn()));\r
+ insertRowData.add(new Long(syncAPI.getErrno()));\r
+ insertRowData.add(new Long(syncAPI.getSyncValue()));\r
+ } catch (ArrayIndexOutOfBoundsException e) {\r
+ e.printStackTrace();\r
+ }\r
+ insertData.add(insertRowData);\r
+ if (insertData.size() > 0) {\r
+ ThreadChartManager.getInstance().getSyncAPIDBTable().insertData(insertData);\r
+ } \r
+ }\r
+ } \r
+ }\r
+\r
+ public static void sendNotify() {\r
+// syncAPIQueue.wake();\r
+ }\r
+}\r
--- /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.thread.data;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+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;
+import org.tizen.dynamicanalyzer.database.IResultSet;
+
+public class SyncDataDBTable extends DBTable implements IResultSet {
+ public static final String TABLENAME="SyncData";
+
+ public static final String QUERY_OPTION = "order by " + COLUMN.SYNCDATAID.name;
+
+ private static final String SELECT_COLUMN =
+ COLUMN.SYNCDATAID.name + CommonConstants.COMMA +
+ COLUMN.PID.name + CommonConstants.COMMA +
+ COLUMN.TID.name + CommonConstants.COMMA +
+ COLUMN.SYNCTYPE.name + CommonConstants.COMMA +
+ COLUMN.SYNCVALUE.name + CommonConstants.COMMA +
+ COLUMN.ATTRIBUTETYPE.name + CommonConstants.COMMA +
+ COLUMN.SYNCDATATYPE.name + CommonConstants.COMMA +
+ COLUMN.PARENTID.name;
+ public static final String SELECT_QUERY =
+ "select " + SELECT_COLUMN + " from " + TABLENAME +
+ " order by " + COLUMN.SYNCDATAID.name;
+
+ public enum COLUMN {
+ SYNCDATAID(0, "SyncDataID"),
+ PID(1, "PID"),
+ TID(2, "TID"),
+ SYNCTYPE(3, "SyncType"),
+ SYNCVALUE(4, "SyncValue"),
+ ATTRIBUTETYPE(5, "AttributeType"),
+ SYNCDATATYPE(6, "SyncDataType"),
+ PARENTID(7, "ParentId");
+
+ 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 SyncDataDBTable() {
+ addColumn(new DBColumn(COLUMN.SYNCDATAID.name, DBConstants.PRIMARY_KEY, DBConstants.DBTYPE_INT4));
+ 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.SYNCTYPE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT1));
+ addColumn(new DBColumn(COLUMN.SYNCVALUE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.ATTRIBUTETYPE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT1));
+ addColumn(new DBColumn(COLUMN.SYNCDATATYPE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT1));
+ addColumn(new DBColumn(COLUMN.PARENTID.name, DBConstants.EMPTY, DBConstants.DBTYPE_INT4));
+ }
+
+ public List<List<Object>> getSyncDataFromDB() {
+ return selectAllColumnData(QUERY_OPTION);
+ }
+
+ @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.SYNCDATAID.index + 1, (Integer) (rowData.get(COLUMN.SYNCDATAID.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.SYNCTYPE.index + 1, (Byte) (rowData.get(COLUMN.SYNCTYPE.index)));
+ prep.setLong(COLUMN.SYNCVALUE.index + 1, (Long) (rowData.get(COLUMN.SYNCVALUE.index)));
+ prep.setByte(COLUMN.ATTRIBUTETYPE.index + 1, (Byte) (rowData.get(COLUMN.ATTRIBUTETYPE.index)));
+ prep.setByte(COLUMN.SYNCDATATYPE.index + 1, (Byte) (rowData.get(COLUMN.SYNCDATATYPE.index)));
+ prep.setInt(COLUMN.PARENTID.index + 1, (Integer) (rowData.get(COLUMN.PARENTID.index)));
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ isPrepared = false;
+ }
+ }
+
+ return isPrepared;
+ }
+
+ @Override
+ public List<Object> extractDataFromResultSet(ResultSet rs) {
+ List<Object> row = new ArrayList<Object>();
+ try {
+ row.add(Integer.valueOf(rs.getInt(COLUMN.SYNCDATAID.index + 1)));
+ row.add(Integer.valueOf(rs.getInt(COLUMN.PID.index + 1)));
+ row.add(Integer.valueOf(rs.getInt(COLUMN.TID.index + 1)));
+ row.add(Byte.valueOf(rs.getByte(COLUMN.SYNCTYPE.index + 1)));
+ row.add(Long.valueOf(rs.getLong(COLUMN.SYNCVALUE.index + 1)));
+ row.add(Byte.valueOf(rs.getByte(COLUMN.ATTRIBUTETYPE.index + 1)));
+ row.add(Byte.valueOf(rs.getByte(COLUMN.SYNCDATATYPE.index + 1)));
+ row.add(Integer.valueOf(rs.getInt(COLUMN.PARENTID.index + 1)));
+ } catch (SQLException e) {
+ e.printStackTrace();
+ return null;
+ }
+
+ return row;
+ }
+}
--- /dev/null
+/*\r
+ * Dynamic Analyzer\r
+ *\r
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.\r
+ *\r
+ * Contact: \r
+ * WooJin Jung <woojin2.jung@samsung.com>\r
+ * Juyoung Kim <j0.kim@samsung.com>\r
+ *\r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ * \r
+ * Contributors:\r
+ * - S-Core Co., Ltd\r
+ * \r
+ */\r
+\r
+package org.tizen.dynamicanalyzer.ui.thread.data;\r
+\r
+import java.util.ArrayList;\r
+import java.util.List;\r
+import java.util.concurrent.LinkedBlockingQueue;\r
+\r
+import org.tizen.dynamicanalyzer.common.AnalyzerConstants;\r
+import org.tizen.dynamicanalyzer.common.AnalyzerManager;\r
+import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;\r
+import org.tizen.dynamicanalyzer.ui.thread.ThreadChartManager;\r
+import org.tizen.dynamicanalyzer.ui.thread.sync.ThreadPageSyncData;\r
+import org.tizen.dynamicanalyzer.ui.thread.sync.ThreadPageSyncDataManager;\r
+//TODO: use DBInserter\r
+public class SyncDataInserter implements Runnable {\r
+ private static LinkedBlockingQueue<ThreadPageSyncData> syncDataQueue = new LinkedBlockingQueue<ThreadPageSyncData>();\r
+\r
+ private static volatile Thread inserterThread = null;\r
+\r
+ public static void startThread() {\r
+ if (inserterThread == null || !inserterThread.isAlive()) {\r
+ synchronized (SyncDataInserter.class) {\r
+ if (inserterThread == null || !inserterThread.isAlive()) {\r
+ inserterThread = new Thread(null,\r
+ new SyncDataInserter());\r
+ inserterThread.start();\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ public static void stopThread() {\r
+ if (inserterThread != null && inserterThread.isAlive()) {\r
+ try {\r
+ sendNotify();\r
+ inserterThread.join(AnalyzerConstants.THREAD_JOIN_WAIT_TIME);\r
+ } catch (InterruptedException e) {\r
+ e.printStackTrace();\r
+ }\r
+ }\r
+ }\r
+\r
+ public static void pushSyncData(ThreadPageSyncData syncData) {\r
+ syncDataQueue.offer(syncData);\r
+ }\r
+\r
+ public static void clear() {\r
+ stopThread();\r
+ }\r
+\r
+ @Override\r
+ public void run() {\r
+ while (!AnalyzerManager.isExit()) {\r
+ ThreadPageSyncData syncData = syncDataQueue.poll();\r
+\r
+ if (syncData != null) {\r
+ ArrayList<List<Object>> insertData = new ArrayList<List<Object>>(); \r
+ List<Object> insertRowData = new ArrayList<Object>();\r
+ try {\r
+ insertRowData.add(new Integer(syncData.getSyncDataID()));\r
+ insertRowData.add(new Integer(syncData.getPid()));\r
+ insertRowData.add(new Integer(syncData.getTid()));\r
+ Integer type = new Integer(syncData.getType());\r
+ byte syncType = type.byteValue();\r
+ insertRowData.add(new Byte(syncType));\r
+ insertRowData.add(new Long(syncData.getKey()));\r
+ String attrTypeStr = syncData.getAttrType();\r
+ byte attrType = -1;\r
+ if (attrTypeStr.equals(ThreadPageLabels.SYNC_ATTR_TYPE_NORMAL)) {\r
+ attrType = ThreadPageSyncDataManager.PTHREAD_MUTEX_NORMAL;\r
+ } else if (attrTypeStr.equals(ThreadPageLabels.SYNC_ATTR_TYPE_RECURSIVE)) {\r
+ attrType = ThreadPageSyncDataManager.PTHREAD_MUTEX_RECURSIVE;\r
+ } else if (attrTypeStr.equals(ThreadPageLabels.SYNC_ATTR_TYPE_ERRORCHECK)) {\r
+ attrType = ThreadPageSyncDataManager.PTHREAD_MUTEX_ERRORCHECK; \r
+ } else if (attrTypeStr.equals(ThreadPageLabels.SYNC_ATTR_TYPE_DEFAULT)) {\r
+ attrType = ThreadPageSyncDataManager.PTHREAD_MUTEX_DEFAULT;\r
+ } else {\r
+ attrType = -1;\r
+ }\r
+ insertRowData.add(new Byte(attrType));\r
+ insertRowData.add(new Byte(syncData.getSyncDataType()));\r
+ insertRowData.add(new Integer(syncData.getParentID()));\r
+ } catch (ArrayIndexOutOfBoundsException e) {\r
+ e.printStackTrace();\r
+ }\r
+ insertData.add(insertRowData);\r
+ if (insertData.size() > 0) {\r
+ ThreadChartManager.getInstance().getSyncDataDBTable().insertData(insertData);\r
+ }\r
+ }\r
+ } \r
+ }\r
+\r
+ public static void sendNotify() {\r
+// syncDataQueue.wake();\r
+ }\r
+}\r
--- /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.thread.data;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+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;
+import org.tizen.dynamicanalyzer.database.IResultSet;
+
+public class SyncEventDBTable extends DBTable implements IResultSet {
+ public static final String TABLENAME="SyncEvent";
+
+ private static final String SELECT_COLUMN =
+ COLUMN.EVENTTIME.name + CommonConstants.COMMA +
+ COLUMN.APITYPE.name + CommonConstants.COMMA +
+ COLUMN.TOOLTIP.name + CommonConstants.COMMA +
+ COLUMN.ERRORNO.name + CommonConstants.COMMA +
+ COLUMN.SYNCVALUE.name;
+ public static final String SELECT_QUERY =
+ "select " + SELECT_COLUMN + " from " + TABLENAME +
+ " where " + COLUMN.SYNCDATAID.name + " = %s ";
+
+ public enum COLUMN {
+ API_SEQNUMBER(0, "APISEQNUMBER"),
+ SYNCDATAID(1, "SyncDataID"),
+ EVENTTIME(2, "EventTime"),
+ APITYPE(3, "APIType"),
+ TOOLTIP(4, "Tooltip"),
+ ERRORNO(5, DBConstants.DBCOLUMN_ERROR_NUMBER),
+ SYNCVALUE(6, "SyncValue");
+
+ 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 SyncEventDBTable() {
+ addColumn(new DBColumn(COLUMN.API_SEQNUMBER.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.SYNCDATAID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.EVENTTIME.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.APITYPE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT1));
+ addColumn(new DBColumn(COLUMN.TOOLTIP.name, DBConstants.EMPTY,
+ DBConstants.VARCHAR, DALimit.TOOLTIP_LENGTH));
+ addColumn(new DBColumn(COLUMN.ERRORNO.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.SYNCVALUE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ setIndexColumn(COLUMN.SYNCDATAID.index);
+ }
+
+ public List<List<Object>> getSyncEventFromDB() {
+ return selectAllColumnData(null);
+ }
+
+ @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.API_SEQNUMBER.index + 1, (Long) (rowData.get(COLUMN.API_SEQNUMBER.index)));
+ prep.setInt(COLUMN.SYNCDATAID.index + 1, (Integer) (rowData.get(COLUMN.SYNCDATAID.index)));
+ prep.setLong(COLUMN.EVENTTIME.index + 1, (Long) (rowData.get(COLUMN.EVENTTIME.index)));
+ prep.setByte(COLUMN.APITYPE.index + 1, (Byte) (rowData.get(COLUMN.APITYPE.index)));
+ String tooltipStr = clipString((String) (rowData.get(COLUMN.TOOLTIP.index)),
+ DALimit.TOOLTIP_LENGTH, rowData.get(COLUMN.EVENTTIME.index).toString());
+ prep.setString(COLUMN.TOOLTIP.index + 1, tooltipStr);
+ prep.setLong(COLUMN.ERRORNO.index + 1, (Long) (rowData.get(COLUMN.ERRORNO.index)));
+ prep.setLong(COLUMN.SYNCVALUE.index + 1, (Long) (rowData.get(COLUMN.SYNCVALUE.index)));
+ } catch (SQLException e) {
+ e.printStackTrace();
+ isPrepared = false;
+ }
+ }
+
+ return isPrepared;
+ }
+
+ @Override
+ public List<Object> extractDataFromResultSet(ResultSet rs) {
+ List<Object> row = new ArrayList<Object>();
+ try {
+ row.add(Long.valueOf(rs.getLong(COLUMN.API_SEQNUMBER.index + 1)));
+ row.add(Integer.valueOf(rs.getInt(COLUMN.SYNCDATAID.index + 1)));
+ row.add(Long.valueOf(rs.getLong(COLUMN.EVENTTIME.index + 1)));
+ row.add(Byte.valueOf(rs.getByte(COLUMN.APITYPE.index + 1)));
+ row.add(rs.getString(COLUMN.TOOLTIP.index + 1));
+ row.add(Long.valueOf(rs.getLong(COLUMN.ERRORNO.index + 1)));
+ row.add(Long.valueOf(rs.getLong(COLUMN.SYNCVALUE.index + 1)));
+ } catch (SQLException e) {
+ e.printStackTrace();
+ return null;
+ }
+
+ return row;
+ }
+}
--- /dev/null
+/*\r
+ * Dynamic Analyzer\r
+ *\r
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.\r
+ *\r
+ * Contact: \r
+ * WooJin Jung <woojin2.jung@samsung.com>\r
+ * Juyoung Kim <j0.kim@samsung.com>\r
+ *\r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ * \r
+ * Contributors:\r
+ * - S-Core Co., Ltd\r
+ * \r
+ */\r
+\r
+package org.tizen.dynamicanalyzer.ui.thread.data;\r
+\r
+import java.util.ArrayList;\r
+import java.util.List;\r
+import java.util.concurrent.LinkedBlockingQueue;\r
+\r
+import org.tizen.dynamicanalyzer.common.AnalyzerConstants;\r
+import org.tizen.dynamicanalyzer.common.AnalyzerManager;\r
+import org.tizen.dynamicanalyzer.ui.thread.ThreadChartManager;\r
+import org.tizen.dynamicanalyzer.ui.thread.sync.ThreadPageSyncDataEvent;\r
+//TODO: use DBInserter\r
+public class SyncEventInserter implements Runnable {\r
+ private static LinkedBlockingQueue<ThreadPageSyncDataEvent> syncEventQueue = new LinkedBlockingQueue<ThreadPageSyncDataEvent>();\r
+\r
+ private static volatile Thread inserterThread = null;\r
+\r
+ public static void startThread() {\r
+ if (inserterThread == null || !inserterThread.isAlive()) {\r
+ synchronized (SyncEventInserter.class) {\r
+ if (inserterThread == null || !inserterThread.isAlive()) {\r
+ inserterThread = new Thread(null,\r
+ new SyncEventInserter());\r
+ inserterThread.start();\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ public static void stopThread() {\r
+ if (inserterThread != null && inserterThread.isAlive()) {\r
+ try {\r
+ sendNotify();\r
+ inserterThread.join(AnalyzerConstants.THREAD_JOIN_WAIT_TIME);\r
+ } catch (InterruptedException e) {\r
+ e.printStackTrace();\r
+ }\r
+ }\r
+ }\r
+\r
+ public static void pushSyncEvent(ThreadPageSyncDataEvent syncEvent) {\r
+ syncEventQueue.offer(syncEvent);\r
+ }\r
+\r
+ public static void clear() {\r
+ stopThread();\r
+ }\r
+\r
+ @Override\r
+ public void run() {\r
+ while (!AnalyzerManager.isExit()) {\r
+ ThreadPageSyncDataEvent syncEvent = syncEventQueue.poll();\r
+\r
+ if (syncEvent != null) {\r
+ ArrayList<List<Object>> insertData = new ArrayList<List<Object>>(); \r
+ List<Object> insertRowData = new ArrayList<Object>();\r
+ try {\r
+ insertRowData.add(new Long(syncEvent.getContents().getSeq()));\r
+ insertRowData.add(new Integer(syncEvent.getSyncDataID()));\r
+ insertRowData.add(new Long(syncEvent.getTime()));\r
+ Integer apiType = new Integer(syncEvent.getApiType());\r
+ insertRowData.add(new Byte(apiType.byteValue()));\r
+ insertRowData.add(new String(syncEvent.getTooltipContent()));\r
+ insertRowData.add(new Long(syncEvent.getErrorNum()));\r
+ insertRowData.add(new Long(syncEvent.getSyncVal()));\r
+ } catch (ArrayIndexOutOfBoundsException e) {\r
+ e.printStackTrace();\r
+ }\r
+ insertData.add(insertRowData);\r
+ if (insertData.size() > 0) {\r
+ ThreadChartManager.getInstance().getSyncEventDBTable().insertData(insertData);\r
+ }\r
+ }\r
+ } \r
+ }\r
+\r
+ public static void sendNotify() {\r
+// syncEventQueue.wake();\r
+ }\r
+}\r
--- /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.thread.data;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+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;
+import org.tizen.dynamicanalyzer.database.IResultSet;
+
+public class ThreadAPIDBTable extends DBTable implements IResultSet {
+ public static final String TABLENAME="ThreadAPI";
+
+ private static final String SELECT_COLUMN =
+ COLUMN.SEQ.name + CommonConstants.COMMA +
+ COLUMN.APICALLTIME.name + CommonConstants.COMMA +
+ COLUMN.APIID.name + CommonConstants.COMMA +
+ COLUMN.PID.name + CommonConstants.COMMA +
+ COLUMN.TID.name + CommonConstants.COMMA +
+ COLUMN.ARGUMENT.name + CommonConstants.COMMA +
+ COLUMN.RETURN.name + CommonConstants.COMMA +
+ COLUMN.ERRORNO.name;
+ public static final String SELECT_QUERY =
+ "select " + SELECT_COLUMN + " from " + TABLENAME +
+ " where " + COLUMN.THREADDATAID.name + " = %s";
+
+ public enum COLUMN {
+ SEQ(0, "SEQNUMBER"),
+ THREADDATAID(1, "ThreadDataID"),
+ APICALLTIME(2, "APICallTime"),
+ APIID(3, "APIID"),
+ PID(4, "PID"),
+ TID(5, "TID"),
+ ARGUMENT(6, DBConstants.DBCOLUMN_ARGUMENT),
+ RETURN(7, DBConstants.DBCOLUMN_RETURN_VALUE),
+ ERRORNO(8, DBConstants.DBCOLUMN_ERROR_NUMBER);
+
+ 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 ThreadAPIDBTable() {
+ addColumn(new DBColumn(COLUMN.SEQ.name, DBConstants.PRIMARY_KEY, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.THREADDATAID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.APICALLTIME.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.APIID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ 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.ARGUMENT.name, DBConstants.EMPTY,
+ DBConstants.DBTYPE_VARCHAR, DALimit.FUNCTION_ARGUMENTS_VALUE_LENGTH));
+ addColumn(new DBColumn(COLUMN.RETURN.name, DBConstants.EMPTY,
+ DBConstants.DBTYPE_VARCHAR, DALimit.FUNCTION_RETURN_VALUE_LENGTH));
+ addColumn(new DBColumn(COLUMN.ERRORNO.name, DBConstants.EMPTY, DBConstants.DBTYPE_LONG));
+ setIndexColumn(COLUMN.THREADDATAID.index);
+ }
+
+ public List<List<Object>> getThreadAPIFromDB() {
+ return selectAllColumnData(null);
+ }
+
+ @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.THREADDATAID.index + 1, (Integer) (rowData.get(COLUMN.THREADDATAID.index)));
+ prep.setLong(COLUMN.APICALLTIME.index + 1, (Long) (rowData.get(COLUMN.APICALLTIME.index)));
+ prep.setInt(COLUMN.APIID.index + 1, (Integer) (rowData.get(COLUMN.APIID.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)));
+ 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);
+ String retStr = clipString((String) (rowData.get(COLUMN.RETURN.index)),
+ DALimit.FUNCTION_RETURN_VALUE_LENGTH, rowData.get(COLUMN.SEQ.index).toString());
+ prep.setString(COLUMN.RETURN.index + 1, retStr);
+ prep.setLong(COLUMN.ERRORNO.index + 1, (Long) (rowData.get(COLUMN.ERRORNO.index)));
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ isPrepared = false;
+ }
+ }
+
+ return isPrepared;
+ }
+
+ @Override
+ public List<Object> extractDataFromResultSet(ResultSet rs) {
+ List<Object> row = new ArrayList<Object>();
+ try {
+ row.add(Long.valueOf(rs.getLong(COLUMN.SEQ.index + 1)));
+ row.add(Integer.valueOf(rs.getInt(COLUMN.THREADDATAID.index + 1)));
+ row.add(Long.valueOf(rs.getLong(COLUMN.APICALLTIME.index + 1)));
+ row.add(Integer.valueOf(rs.getInt(COLUMN.APIID.index + 1)));
+ row.add(Integer.valueOf(rs.getInt(COLUMN.PID.index + 1)));
+ row.add(Integer.valueOf(rs.getInt(COLUMN.TID.index + 1)));
+ row.add(rs.getString(COLUMN.ARGUMENT.index + 1));
+ row.add(rs.getString(COLUMN.RETURN.index + 1));
+ row.add(Long.valueOf(rs.getLong(COLUMN.ERRORNO.index + 1)));
+ } catch (SQLException e) {
+ e.printStackTrace();
+ return null;
+ }
+
+ return row;
+ }
+}
--- /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.thread.data;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.tizen.dynamicanalyzer.common.DALimit;
+import org.tizen.dynamicanalyzer.database.DBColumn;
+import org.tizen.dynamicanalyzer.database.DBConstants;
+import org.tizen.dynamicanalyzer.database.DBTable;
+import org.tizen.dynamicanalyzer.database.IResultSet;
+
+public class ThreadDataDBTable extends DBTable implements IResultSet {
+ public static final String TABLENAME="ThreadData";
+
+ public enum COLUMN {
+ THREADDATAID(0, "ThreadDataID"),
+ PID(1, "PID"),
+ TID(2, "TID"),
+ THREADTYPE(3, "ThreadType"),
+ ATTRIBUTETYPE(4, "AttributeType"),
+ STARTTIME(5, "StartTime"),
+ ENDTIME(6, "EndTime"),
+ FUNCTIONID(7, "FunctionId"),
+ CLASSNAME(8, "ClassName");
+
+ 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 ThreadDataDBTable() {
+ addColumn(new DBColumn(COLUMN.THREADDATAID.name, DBConstants.PRIMARY_KEY, DBConstants.DBTYPE_INT4));
+ 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.THREADTYPE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT1));
+ addColumn(new DBColumn(COLUMN.ATTRIBUTETYPE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT1));
+ addColumn(new DBColumn(COLUMN.STARTTIME.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.ENDTIME.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.FUNCTIONID.name, DBConstants.EMPTY, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.CLASSNAME.name, DBConstants.EMPTY,
+ DBConstants.VARCHAR, DALimit.CLASS_NAME_LENGTH));
+ }
+
+ public List<List<Object>> getThreadDataFromDB() {
+ return selectAllColumnData(null);
+ }
+
+ @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.THREADDATAID.index + 1, (Integer) (rowData.get(COLUMN.THREADDATAID.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.THREADTYPE.index + 1, (Byte) (rowData.get(COLUMN.THREADTYPE.index)));
+ prep.setByte(COLUMN.ATTRIBUTETYPE.index + 1, (Byte) (rowData.get(COLUMN.ATTRIBUTETYPE.index)));
+ prep.setLong(COLUMN.STARTTIME.index + 1, (Long) (rowData.get(COLUMN.STARTTIME.index)));
+ prep.setLong(COLUMN.ENDTIME.index + 1, (Long) (rowData.get(COLUMN.ENDTIME.index)));
+ prep.setInt(COLUMN.FUNCTIONID.index + 1, (Integer) (rowData.get(COLUMN.FUNCTIONID.index)));
+
+ String classNameStr = clipString((String) (rowData.get(COLUMN.CLASSNAME.index)),
+ DALimit.CLASS_NAME_LENGTH, rowData.get(COLUMN.THREADDATAID.index).toString());
+ prep.setString(COLUMN.CLASSNAME.index + 1, classNameStr);
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ isPrepared = false;
+ }
+ }
+
+ return isPrepared;
+ }
+
+ @Override
+ public List<Object> extractDataFromResultSet(ResultSet rs) {
+ List<Object> row = new ArrayList<Object>();
+ try {
+ row.add(Integer.valueOf(rs.getInt(COLUMN.THREADDATAID.index + 1)));
+ row.add(Integer.valueOf(rs.getInt(COLUMN.PID.index + 1)));
+ row.add(Integer.valueOf(rs.getInt(COLUMN.TID.index + 1)));
+ row.add(Byte.valueOf(rs.getByte(COLUMN.THREADTYPE.index + 1)));
+ row.add(Byte.valueOf(rs.getByte(COLUMN.ATTRIBUTETYPE.index + 1)));
+ row.add(Long.valueOf(rs.getLong(COLUMN.STARTTIME.index + 1)));
+ row.add(Long.valueOf(rs.getLong(COLUMN.ENDTIME.index + 1)));
+ row.add(Integer.valueOf(rs.getInt(COLUMN.FUNCTIONID.index + 1)));
+ row.add(rs.getString(COLUMN.CLASSNAME.index + 1));
+ } catch (SQLException e) {
+ e.printStackTrace();
+ return null;
+ }
+
+ return row;
+ }
+}
--- /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.thread.data;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+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;
+import org.tizen.dynamicanalyzer.database.IResultSet;
+
+public class ThreadEventDBTable extends DBTable implements IResultSet {
+ public static final String TABLENAME="ThreadEvent";
+
+ private static final String SELECT_COLUMN =
+ COLUMN.EVENTTIME.name + CommonConstants.COMMA +
+ COLUMN.TID.name + CommonConstants.COMMA +
+ COLUMN.APITYPE.name + CommonConstants.COMMA +
+ COLUMN.TOOLTIP.name + CommonConstants.COMMA +
+ COLUMN.ERRORNO.name + CommonConstants.COMMA +
+ COLUMN.EVENTTYPE.name + CommonConstants.COMMA +
+ COLUMN.THREADTYPE.name + CommonConstants.COMMA +
+ COLUMN.CALLERID.name;
+ public static final String SELECT_QUERY =
+ "select " + SELECT_COLUMN + " from " + TABLENAME +
+ " where " + COLUMN.THREADDATAID.name + " = %s ";
+
+ public enum COLUMN {
+ THREADDATAID(0, "ThreadDataID"),
+ EVENTTIME(1, "EventTime"),
+ TID(2, "TID"),
+ APITYPE(3, "APIType"),
+ TOOLTIP(4, "Tooltip"),
+ ERRORNO(5, DBConstants.DBCOLUMN_ERROR_NUMBER),
+ EVENTTYPE(6, "EventType"),
+ THREADTYPE(7, "ThreadType"),
+ CALLERID(8, "CallerID");
+
+ 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 ThreadEventDBTable() {
+ addColumn(new DBColumn(COLUMN.THREADDATAID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.EVENTTIME.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.TID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.APITYPE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT1));
+ addColumn(new DBColumn(COLUMN.TOOLTIP.name, DBConstants.EMPTY,
+ DBConstants.VARCHAR, DALimit.TOOLTIP_LENGTH));
+ addColumn(new DBColumn(COLUMN.ERRORNO.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.EVENTTYPE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT1));
+ addColumn(new DBColumn(COLUMN.THREADTYPE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.CALLERID.name, DBConstants.EMPTY, DBConstants.DBTYPE_INT4));
+ setIndexColumn(COLUMN.THREADDATAID.index);
+ }
+
+ public List<List<Object>> getThreadEventFromDB() {
+ return selectAllColumnData(null);
+ }
+
+ @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.THREADDATAID.index + 1, (Integer) (rowData.get(COLUMN.THREADDATAID.index)));
+ prep.setLong(COLUMN.EVENTTIME.index + 1, (Long) (rowData.get(COLUMN.EVENTTIME.index)));
+ prep.setInt(COLUMN.TID.index + 1, (Integer) (rowData.get(COLUMN.TID.index)));
+ prep.setByte(COLUMN.APITYPE.index + 1, (Byte) (rowData.get(COLUMN.APITYPE.index)));
+ String tooltipStr = clipString((String) (rowData.get(COLUMN.TOOLTIP.index)),
+ DALimit.TOOLTIP_LENGTH, rowData.get(COLUMN.EVENTTIME.index).toString());
+ prep.setString(COLUMN.TOOLTIP.index + 1, tooltipStr);
+ prep.setLong(COLUMN.ERRORNO.index + 1, (Long) (rowData.get(COLUMN.ERRORNO.index)));
+ prep.setByte(COLUMN.EVENTTYPE.index + 1, (Byte) (rowData.get(COLUMN.EVENTTYPE.index)));
+ prep.setInt(COLUMN.THREADTYPE.index + 1, (Integer) (rowData.get(COLUMN.THREADTYPE.index)));
+ prep.setInt(COLUMN.CALLERID.index + 1, (Integer) (rowData.get(COLUMN.CALLERID.index)));
+ } catch (SQLException e) {
+ e.printStackTrace();
+ isPrepared = false;
+ }
+ }
+
+ return isPrepared;
+ }
+
+ public List<Object> extractDataFromResultSet(ResultSet rs) {
+ List<Object> row = new ArrayList<Object>();
+ try {
+ row.add(Integer.valueOf(rs.getInt(COLUMN.THREADDATAID.index + 1)));
+ row.add(Long.valueOf(rs.getLong(COLUMN.EVENTTIME.index + 1)));
+ row.add(Integer.valueOf(rs.getInt(COLUMN.TID.index + 1)));
+ row.add(Byte.valueOf(rs.getByte(COLUMN.APITYPE.index + 1)));
+ row.add(rs.getString(COLUMN.TOOLTIP.index + 1));
+ row.add(Long.valueOf(rs.getLong(COLUMN.ERRORNO.index + 1)));
+ row.add(Byte.valueOf(rs.getByte(COLUMN.EVENTTYPE.index + 1)));
+ row.add(Integer.valueOf(rs.getInt(COLUMN.THREADTYPE.index + 1)));
+ row.add(Integer.valueOf(rs.getInt(COLUMN.CALLERID.index + 1)));
+ } catch (SQLException e) {
+ e.printStackTrace();
+ return null;
+ }
+
+ return row;
+ }
+}
--- /dev/null
+/*\r
+ * Dynamic Analyzer\r
+ *\r
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.\r
+ *\r
+ * Contact: \r
+ * WooJin Jung <woojin2.jung@samsung.com>\r
+ * Juyoung Kim <j0.kim@samsung.com>\r
+ *\r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ * \r
+ * Contributors:\r
+ * - S-Core Co., Ltd\r
+ * \r
+ */\r
+\r
+package org.tizen.dynamicanalyzer.ui.thread.data;\r
+\r
+import java.util.ArrayList;\r
+import java.util.List;\r
+import java.util.concurrent.LinkedBlockingQueue;\r
+\r
+import org.tizen.dynamicanalyzer.common.AnalyzerConstants;\r
+import org.tizen.dynamicanalyzer.common.AnalyzerManager;\r
+import org.tizen.dynamicanalyzer.swap.model.data.ThreadData;\r
+import org.tizen.dynamicanalyzer.ui.thread.ThreadChartManager;\r
+import org.tizen.dynamicanalyzer.ui.thread.thread.ThreadPageThreadDataEvent;\r
+// TODO: use DBInserter\r
+public class ThreadEventInserter implements Runnable {\r
+ private static LinkedBlockingQueue<ThreadPageThreadDataEvent> threadEventQueue = new LinkedBlockingQueue<ThreadPageThreadDataEvent>();\r
+\r
+ private static volatile Thread inserterThread = null;\r
+\r
+ public static void startThread() {\r
+ if (inserterThread == null || !inserterThread.isAlive()) {\r
+ synchronized (ThreadEventInserter.class) {\r
+ if (inserterThread == null || !inserterThread.isAlive()) {\r
+ inserterThread = new Thread(null,\r
+ new ThreadEventInserter());\r
+ inserterThread.start();\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ public static void stopThread() {\r
+ if (inserterThread != null && inserterThread.isAlive()) {\r
+ try {\r
+ sendNotify();\r
+ inserterThread.join(AnalyzerConstants.THREAD_JOIN_WAIT_TIME);\r
+ } catch (InterruptedException e) {\r
+ e.printStackTrace();\r
+ }\r
+ }\r
+ }\r
+\r
+ public static void pushThreadEvent(ThreadPageThreadDataEvent threadEvent) {\r
+ threadEventQueue.offer(threadEvent);\r
+ }\r
+\r
+ public static void clear() {\r
+ stopThread();\r
+ }\r
+\r
+ @Override\r
+ public void run() {\r
+ while (!AnalyzerManager.isExit()) {\r
+ ThreadPageThreadDataEvent threadEvent = threadEventQueue.poll();\r
+\r
+ if (threadEvent != null) {\r
+ ArrayList<List<Object>> insertData = new ArrayList<List<Object>>(); \r
+ List<Object> insertRowData = new ArrayList<Object>();\r
+ try {\r
+ insertRowData.add(new Integer(threadEvent.getThreadDataID()));\r
+ insertRowData.add(new Long(threadEvent.getTime()));\r
+ insertRowData.add(new Integer(threadEvent.getTid()));\r
+ Integer apiType = new Integer(threadEvent.getApiType());\r
+ insertRowData.add(new Byte(apiType.byteValue()));\r
+ insertRowData.add(new String(threadEvent.getTooltipContent()));\r
+ insertRowData.add(new Long(threadEvent.getErrorNum()));\r
+ Integer eventType = new Integer(threadEvent.getEventType());\r
+ insertRowData.add(new Byte(eventType.byteValue()));\r
+ insertRowData.add(new Integer(threadEvent.getThreadType()));\r
+ Integer callerTid = -1;\r
+ if (threadEvent.getCallerTid() != null) {\r
+ callerTid = new Integer(threadEvent.getCallerTid()); \r
+ }\r
+ insertRowData.add(callerTid);\r
+ } catch (ArrayIndexOutOfBoundsException e) {\r
+ e.printStackTrace();\r
+ }\r
+ insertData.add(insertRowData);\r
+ if (insertData.size() > 0) {\r
+ ThreadChartManager.getInstance().getThreadEventDBTable().insertData(insertData);\r
+ }\r
+ // save ThreadAPI\r
+ if (threadEvent.getEventType() == ThreadPageThreadDataEvent.TYPE_API) {\r
+ ArrayList<List<Object>> apiData = new ArrayList<List<Object>>(); \r
+ List<Object> apiRowData = new ArrayList<Object>();\r
+ ThreadData tData = (ThreadData) threadEvent.getContents();\r
+ try {\r
+ apiRowData.add(new Long(tData.getSeq()));\r
+ apiRowData.add(new Integer(threadEvent.getThreadDataID()));\r
+ apiRowData.add(new Long(tData.getTime()));\r
+ apiRowData.add(new Integer(tData.getApiId()));\r
+ apiRowData.add(new Integer(tData.getPid()));\r
+ apiRowData.add(new Integer(tData.getTid()));\r
+ apiRowData.add(new String(tData.getArgs()));\r
+ apiRowData.add(new String(tData.getReturn()));\r
+ apiRowData.add(new Long(tData.getErrno()));\r
+ } catch (ArrayIndexOutOfBoundsException e) {\r
+ e.printStackTrace();\r
+ }\r
+ apiData.add(apiRowData);\r
+ if (apiData.size() > 0) {\r
+ ThreadChartManager.getInstance().getThreadAPIDBTable().insertData(apiData);\r
+ } \r
+ }\r
+ }\r
+ } \r
+ }\r
+\r
+ public static void sendNotify() {\r
+// threadEventQueue.wake();\r
+ }\r
+}\r
import java.util.ArrayList;
import java.util.List;
+import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;
import org.tizen.dynamicanalyzer.resources.ColorResources;
private List<ThreadPageSyncData> children = new ArrayList<ThreadPageSyncData>();
private DAChartSeries apiSeries;
private DAChartSeries stateSeries;
+
+ public static final byte SYNC_PARENT = 0;
+ public static final byte SYNC_CHILD = 1;
+ public static final byte THREAD_CHILD = 2;
+
+ private static int internalSeq = 0;
+ private int syncDataID = -1;
+ private byte syncDataType = -1;
+ private int parentID = -1;
- public ThreadPageSyncData(String type, String name, String pid, String tid,
- String attrType) {
+ public ThreadPageSyncData(int type, String name, String pid, String tid,
+ String attrType, byte syncDataType) {
super(type, name, pid, tid, attrType);
+ this.syncDataType = syncDataType;
+ syncDataID = internalSeq++;
+ }
+
+ // using open trace
+ public ThreadPageSyncData(int id, int pid, int tid, int type, long syncValue,
+ String attrType, byte syncDataType, int parentID) {
+ super(type, String.valueOf(syncValue), String.valueOf(pid), String.valueOf(tid), attrType);
+ this.syncDataID = id;
+ this.syncDataType = syncDataType;
+ this.parentID = parentID;
}
protected void pushSync(ThreadPageSyncData sync) {
apiSeries = chart.getSeries(ThreadPageLabels.THREAD_CHART_SERIES_API);
}
- private boolean isSyncApi(int apiType) {
- if (apiType == LogCenterConstants.SYNC_API_TYPE_ACQUIRE_WAIT_END) {
+ public static boolean isSyncApi(int apiType) {
+ if (apiType == LogCenterConstants.SYNC_API_TYPE_ACQUIRE_WAIT_START) {
return false;
}
- if (apiType == LogCenterConstants.SYNC_API_TYPE_COND_WAIT_END) {
+ if (apiType == LogCenterConstants.SYNC_API_TYPE_COND_WAIT_START) {
return false;
}
return true;
case LogCenterConstants.SYNC_API_TYPE_NOTIFY_ALL:
case LogCenterConstants.SYNC_API_TYPE_OTHER:
if(((DAChartBoardItem)item).getChartBoard() != null){
- stateItem = new DAChartSeriesItem(syncEvent.getTime(),
+ stateItem = new DAChartSeriesItem(syncEvent.getDoubleTime(),
DAChartSeriesItem.SERIES_STATE_CONNECTION,
ColorResources.THREAD_GRAPH_LOCK_RELEASE_COLOR,
"");
} else {
- stateItem = new DAChartSeriesItem(syncEvent.getTime(),
+ stateItem = new DAChartSeriesItem(syncEvent.getDoubleTime(),
DAChartSeriesItem.SERIES_STATE_CONNECTION,
ColorResources.THREAD_GRAPH_LOCK_RELEASE_COLOR,
ThreadPageLabels.SYNC_CHART_ITEM_UNUSED);
case LogCenterConstants.SYNC_API_TYPE_ACQUIRE_WAIT_START:
case LogCenterConstants.SYNC_API_TYPE_COND_WAIT_START:
if(((DAChartBoardItem)item).getChartBoard() != null){
- stateItem = new DAChartSeriesItem(syncEvent.getTime(),
+ stateItem = new DAChartSeriesItem(syncEvent.getDoubleTime(),
DAChartSeriesItem.SERIES_STATE_CONNECTION,
ColorResources.THREAD_GRAPH_LOCK_RELEASE_COLOR,
"");
} else{
- stateItem = new DAChartSeriesItem(syncEvent.getTime(),
+ stateItem = new DAChartSeriesItem(syncEvent.getDoubleTime(),
DAChartSeriesItem.SERIES_STATE_CONTINUE,
ColorResources.THREAD_GRAPH_LOCK_WAIT_COLOR,
ThreadPageLabels.SYNC_CHART_ITEM_WAITED);
break;
case LogCenterConstants.SYNC_API_TYPE_RELEASE:
if(((DAChartBoardItem)item).getChartBoard() != null){
- stateItem = new DAChartSeriesItem(syncEvent.getTime(),
+ stateItem = new DAChartSeriesItem(syncEvent.getDoubleTime(),
DAChartSeriesItem.SERIES_STATE_CONNECTION,
ColorResources.THREAD_GRAPH_LOCK_RELEASE_COLOR,
"");
} else{
- stateItem = new DAChartSeriesItem(syncEvent.getTime(),
+ stateItem = new DAChartSeriesItem(syncEvent.getDoubleTime(),
DAChartSeriesItem.SERIES_STATE_CONNECTION,
ColorResources.THREAD_GRAPH_LOCK_RELEASE_COLOR,
ThreadPageLabels.SYNC_CHART_ITEM_UNUSED);
case LogCenterConstants.SYNC_API_TYPE_ACQUIRE_WAIT_END:
case LogCenterConstants.SYNC_API_TYPE_COND_WAIT_END:
if(((DAChartBoardItem)item).getChartBoard() != null){
- stateItem = new DAChartSeriesItem(syncEvent.getTime(),
+ stateItem = new DAChartSeriesItem(syncEvent.getDoubleTime(),
DAChartSeriesItem.SERIES_STATE_CONNECTION,
ColorResources.THREAD_GRAPH_LOCK_RELEASE_COLOR,
"");
} else{
- stateItem = new DAChartSeriesItem(syncEvent.getTime(),
+ stateItem = new DAChartSeriesItem(syncEvent.getDoubleTime(),
DAChartSeriesItem.SERIES_STATE_CONTINUE,
ColorResources.THREAD_GRAPH_LOCK_ACQUIRE_COLOR,
ThreadPageLabels.SYNC_CHART_ITEM_USED);
break;
case LogCenterConstants.SYNC_API_TYPE_TRY_ACQUIRE:
if(((DAChartBoardItem)item).getChartBoard() != null){
- stateItem = new DAChartSeriesItem(syncEvent.getTime(),
+ stateItem = new DAChartSeriesItem(syncEvent.getDoubleTime(),
DAChartSeriesItem.SERIES_STATE_CONNECTION,
ColorResources.THREAD_GRAPH_LOCK_RELEASE_COLOR,
"");
} else{
- stateItem = new DAChartSeriesItem(syncEvent.getTime(),
+ stateItem = new DAChartSeriesItem(syncEvent.getDoubleTime(),
DAChartSeriesItem.SERIES_STATE_CONTINUE,
ColorResources.THREAD_GRAPH_LOCK_ACQUIRE_COLOR,
ThreadPageLabels.SYNC_CHART_ITEM_USED);
return apiType;
}
-}
+
+ public String getTypeString() {
+ switch (getType()) {
+ case LogCenterConstants.SYNC_TYPE_TIZEN_MUTEX:
+ return ThreadPageLabels.SYNC_TYPE_TIZEN_MUTEX;
+ case LogCenterConstants.SYNC_TYPE_TIZEN_MONITOR:
+ return ThreadPageLabels.SYNC_TYPE_TIZEN_MONITOR;
+ case LogCenterConstants.SYNC_TYPE_TIZEN_SEMAPHORE:
+ return ThreadPageLabels.SYNC_TYPE_TIZEN_SEMAPHORE;
+ case LogCenterConstants.SYNC_TYPE_PTHREAD_MUTEX:
+ return ThreadPageLabels.SYNC_TYPE_PTHREAD_MUTEX;
+ case LogCenterConstants.SYNC_TYPE_PTHREAD_COND_VARIABLE:
+ return ThreadPageLabels.SYNC_TYPE_PTHREAD_COND_VARIABLE;
+ case LogCenterConstants.SYNC_TYPE_PTHREAD_RWLOCK:
+ return ThreadPageLabels.SYNC_TYPE_PTHREAD_RWLOCK;
+ case LogCenterConstants.SYNC_TYPE_PTHREAD_SPINLOCK:
+ return ThreadPageLabels.SYNC_TYPE_PTHREAD_SPINLOCK;
+ case LogCenterConstants.SYNC_TYPE_PTHREAD_BARRIER:
+ return ThreadPageLabels.SYNC_TYPE_PTHREAD_BARRIER;
+ default:
+ Logger.error("unknown sync type!!");
+ return CommonConstants.EMPTY;
+ }
+ }
+
+ public int getSyncDataID() {
+ return syncDataID;
+ }
+
+ public byte getSyncDataType() {
+ return syncDataType;
+ }
+
+ public int getParentID() {
+ return parentID;
+ }
+
+ public void setParentID(int parentID) {
+ this.parentID = parentID;
+ }
+
+ public static void clear() {
+ internalSeq = 0;
+ }
+}
\ No newline at end of file
public class ThreadPageSyncDataEvent extends ThreadPageDataEvent {
private String syncVal;
private int type = -1;
+ private int syncDataID = -1;
public ThreadPageSyncDataEvent(String syncVal, int type, int apiType,
- double time, String tid, String tooltip, long errorNum,
+ long time, String tid, String tooltip, long errorNum,
LogData contents) {
super(time, tid, apiType, tooltip, errorNum, contents);
this.syncVal = syncVal;
this.type = type;
}
+
+ // using open trace
+ public ThreadPageSyncDataEvent(long time, int apiType, String tooltip,
+ long errorNum, String syncVal) {
+ super(time, null, apiType, tooltip, errorNum, null);
+ this.syncVal = syncVal;
+ }
+
+ public ThreadPageSyncDataEvent clone() throws CloneNotSupportedException {
+ ThreadPageSyncDataEvent syncDataEvent = (ThreadPageSyncDataEvent) super.clone();
+ syncDataEvent.setSyncVal(syncVal);
+ syncDataEvent.setType(type);
+ syncDataEvent.setSyncDataID(syncDataID);
+
+ return syncDataEvent;
+ }
public String getSyncVal() {
return syncVal;
}
+
+ public void setSyncVal(String syncVal) {
+ this.syncVal = syncVal;
+ }
public int getType() {
return type;
}
-}
+
+ public void setType(int type) {
+ this.type = type;
+ }
+
+ public int getSyncDataID() {
+ return syncDataID;
+ }
+
+ public void setSyncDataID(int syncDataID) {
+ this.syncDataID = syncDataID;
+ }
+}
\ No newline at end of file
package org.tizen.dynamicanalyzer.ui.thread.sync;
import java.util.ArrayList;
-import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
+import java.util.Comparator;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
import org.tizen.dynamicanalyzer.ui.common.PopupStartMenuItemClickListener;
import org.tizen.dynamicanalyzer.ui.common.TimelineChartMouseEventListener;
import org.tizen.dynamicanalyzer.ui.common.TimelineChartMouseTrackAdapter;
+import org.tizen.dynamicanalyzer.ui.summary.SummaryDataManager;
import org.tizen.dynamicanalyzer.ui.thread.ThreadPageData;
-import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants;
+import org.tizen.dynamicanalyzer.ui.thread.data.SyncDataInserter;
+import org.tizen.dynamicanalyzer.ui.thread.data.SyncEventInserter;
import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
import org.tizen.dynamicanalyzer.util.Logger;
import org.tizen.dynamicanalyzer.widgets.chart.DAChart;
public class ThreadPageSyncDataManager {
private DAChartBoard board;
private List<ThreadPageSyncData> rows = new ArrayList<ThreadPageSyncData>();
+ private List<ThreadPageSyncData> rowsQueue = new ArrayList<ThreadPageSyncData>();
private List<ThreadPageSyncDataEvent> syncEventQueue = new ArrayList<ThreadPageSyncDataEvent>();
private HashMap<String, Integer> syncAttrMap = new HashMap<String, Integer>();
public static final int PTHREAD_MUTEX_NORMAL = 0;
public static final int PTHREAD_MUTEX_RECURSIVE = 1;
public static final int PTHREAD_MUTEX_ERRORCHECK = 2;
+ public static final int PTHREAD_MUTEX_DEFAULT = 3;
private int preSelectionPid = -1;
public ThreadPageSyncDataManager(DAChartBoard board) {
this.board = board;
}
+ public void pushRow(ThreadPageSyncData data) {
+ rowsQueue.add(data);
+ }
+
private void pushEvent(ThreadPageSyncDataEvent event) {
syncEventQueue.add(event);
}
return ThreadPageLabels.SYNC_ATTR_TYPE_RECURSIVE;
} else if (typeInt == PTHREAD_MUTEX_ERRORCHECK) {
return ThreadPageLabels.SYNC_ATTR_TYPE_ERRORCHECK;
+ } else if (typeInt == PTHREAD_MUTEX_DEFAULT) { // for open trace
+ return ThreadPageLabels.SYNC_ATTR_TYPE_DEFAULT;
} else {
return CommonConstants.EMPTY;
}
if (type == LogCenterConstants.SYNC_TYPE_TIZEN_MUTEX) {
return ThreadPageLabels.SYNC_ATTR_TYPE_RECURSIVE;
} else if (type == LogCenterConstants.SYNC_TYPE_PTHREAD_MUTEX) {
-
return ThreadPageLabels.SYNC_ATTR_TYPE_DEFAULT;
}
-
return CommonConstants.EMPTY;
}
}
SyncData syncData = (SyncData) input;
// System.out.println("input : " + input);
- double time = Double.parseDouble(Long.toString(syncData.getTime()))
- / TimelineConstants.MEGA_DOUBLE;
+ long time = syncData.getTime();
String tid = Integer.toString(syncData.getTid());
int type = syncData.getSyncType();
String name = Long.toString(syncData.getSyncValue());
long errorNum = syncData.getErrno();
+ if (errorNum != 0) {
+ SummaryDataManager.getInstance().getFailedApiDataMaker().makeData(syncData);
+ }
ThreadPageSyncDataEvent event;
switch (type) {
for (int i = 0; i < size; i++) {
input = (SyncData) inputs.get(i);
// System.out.println("input : " + input);
- double time = Double.parseDouble(Long.toString(input.getTime()))
- / TimelineConstants.MEGA_DOUBLE;
+ long time = input.getTime();
String tid = Integer.toString(input.getTid());
int type = input.getSyncType();
parseSyncs(inputs);
}
- private String getSyncTypeString(int syncType) {
- switch (syncType) {
- case LogCenterConstants.SYNC_TYPE_TIZEN_MUTEX:
- return ThreadPageLabels.SYNC_TYPE_TIZEN_MUTEX;
- case LogCenterConstants.SYNC_TYPE_TIZEN_MONITOR:
- return ThreadPageLabels.SYNC_TYPE_TIZEN_MONITOR;
- case LogCenterConstants.SYNC_TYPE_TIZEN_SEMAPHORE:
- return ThreadPageLabels.SYNC_TYPE_TIZEN_SEMAPHORE;
- case LogCenterConstants.SYNC_TYPE_PTHREAD_MUTEX:
- return ThreadPageLabels.SYNC_TYPE_PTHREAD_MUTEX;
- case LogCenterConstants.SYNC_TYPE_PTHREAD_COND_VARIABLE:
- return ThreadPageLabels.SYNC_TYPE_PTHREAD_COND_VARIABLE;
- case LogCenterConstants.SYNC_TYPE_PTHREAD_RWLOCK:
- return ThreadPageLabels.SYNC_TYPE_PTHREAD_RWLOCK;
- case LogCenterConstants.SYNC_TYPE_PTHREAD_SPINLOCK:
- return ThreadPageLabels.SYNC_TYPE_PTHREAD_SPINLOCK;
- case LogCenterConstants.SYNC_TYPE_PTHREAD_BARRIER:
- return ThreadPageLabels.SYNC_TYPE_PTHREAD_BARRIER;
- default:
- return CommonConstants.EMPTY;
- }
- }
-
private void initSyncChart(DAChart chart, boolean isParent) {
if (null == chart) {
return;
DAChart chart;
if (null == parent) {
- item = new DAChartBoardItem(board, sync.getType()
+ item = new DAChartBoardItem(board, sync.getTypeString()
+ ThreadPageLabels.THREAD_CHART_NAME_PREFIX
+ ThreadPageLabels.THREAD_CHART_NAME_OBJ + sync.getKey()
+ ThreadPageLabels.THREAD_CHART_NAME_POSTFIX);
Integer tid = Integer.valueOf(sync.getTid());
if (null == parent) {
- item = new DAChartBoardItem(board, sync.getType()
+ item = new DAChartBoardItem(board, sync.getTypeString()
+ ThreadPageLabels.THREAD_CHART_NAME_PREFIX
+ ThreadPageLabels.THREAD_CHART_NAME_OBJ + sync.getKey()
+ ThreadPageLabels.THREAD_CHART_NAME_POSTFIX);
public void checkUpdate() {
chartFilteringByPid();
- int size = syncEventQueue.size();
+ /* load ThreadPgeSyncData when open trace */
+ int size = rowsQueue.size();
+ if (size > 0) {
+ ThreadPageSyncData sync;
+ ThreadPageSyncData parent;
+ for (int i = 0; i < size; i++) {
+ sync = rowsQueue.get(0);
+ if (sync.getSyncDataType() == ThreadPageSyncData.SYNC_PARENT) {
+ rows.add(sync);
+ createSyncBoardItem(null, sync);
+ } else if (sync.getSyncDataType() == ThreadPageSyncData.SYNC_CHILD) {
+ parent = findParentData(sync.getKey());
+ if (null != parent) {
+ parent.pushSync(sync);
+ createSyncBoardItem(parent, sync,
+ new Comparator<DAChartBoardItem>() {
+ public int compare(DAChartBoardItem item1,
+ DAChartBoardItem item2) {
+ return getSortObject(item1) - getSortObject(item2);
+ }
+ });
+ } else {
+ Logger.error("cannot find parent sync data");
+ }
+ } else {
+ Logger.error("unknown sync data type");
+ }
+ rowsQueue.remove(0);
+ }
+ }
+
+ size = syncEventQueue.size();
if (size > 0) {
ThreadPageSyncData parent;
ThreadPageSyncData data;
syncAttrType = getAttrTypeString(event);
}
- parent = new ThreadPageSyncData(
- getSyncTypeString(event.getType()),
- syncVal, pid, event.getTid(), syncAttrType);
+ parent = new ThreadPageSyncData(event.getType(), syncVal, pid,
+ event.getTid(), syncAttrType, ThreadPageSyncData.SYNC_PARENT);
+ // save to DB
+ SyncDataInserter.pushSyncData(parent);
+ SyncDataInserter.startThread();
rows.add(parent);
createSyncBoardItem(null, parent);
}
parent.pushEvent(event);
+ event.setSyncDataID(parent.getSyncDataID());
+ // save to DB
+ SyncEventInserter.pushSyncEvent(event);
+ SyncEventInserter.startThread();
// child
data = parent.findChildData(event.getTid());
if (null == data) {
String attrType = parent.getAttrType();
- data = new ThreadPageSyncData(
- getSyncTypeString(event.getType()),
- syncVal, pid, event.getTid(), attrType);
+ data = new ThreadPageSyncData(event.getType(), syncVal, pid,
+ event.getTid(), attrType, ThreadPageSyncData.SYNC_CHILD);
+ data.setParentID(parent.getSyncDataID());
+ // save to DB
+ SyncDataInserter.pushSyncData(data);
+ SyncDataInserter.startThread();
parent.pushSync(data);
createSyncBoardItem(parent, data,
new Comparator<DAChartBoardItem>() {
});
}
data.pushEvent(event);
- syncEventQueue.remove(0);
+ try {
+ ThreadPageSyncDataEvent cloneEvent = (ThreadPageSyncDataEvent) event.clone();
+ cloneEvent.setSyncDataID(data.getSyncDataID());
+ // save to DB
+ SyncEventInserter.pushSyncEvent(cloneEvent);
+ } catch (CloneNotSupportedException e) {
+ e.printStackTrace();
+ continue;
+ } finally {
+ syncEventQueue.remove(0);
+ }
}
}
size = rows.size();
rows.clear(); // FIXME : clear chart
syncEventQueue.clear();
syncAttrMap.clear();
+ ThreadPageSyncData.clear(); // reset internal seq number
}
-}
+}
\ No newline at end of file
* Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
*
* Contact:
+ * WooJin Jung <woojin2.jung@samsung.com>
* yeongtaik byeon <yeongtaik.byeon@samsung.com>
* Juyoung Kim <j0.kim@samsung.com>
*
import java.util.ArrayList;
import java.util.List;
+import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;
-import org.tizen.dynamicanalyzer.swap.model.data.ThreadData;
+import org.tizen.dynamicanalyzer.common.Global;
+import org.tizen.dynamicanalyzer.ui.thread.ThreadChartManager;
import org.tizen.dynamicanalyzer.ui.thread.ThreadPageData;
import org.tizen.dynamicanalyzer.ui.thread.ThreadPageDataEvent;
import org.tizen.dynamicanalyzer.ui.thread.sync.ThreadPageSyncData;
import org.tizen.dynamicanalyzer.util.Logger;
+import org.tizen.dynamicanalyzer.utils.Formatter;
import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeries;
import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeriesItem;
import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoardItem;
public class ThreadPageThreadData extends ThreadPageData {
private List<ThreadPageSyncData> syncs = new ArrayList<ThreadPageSyncData>();
- private String StartTime;
- private String EndTime;
- private String threadFuncName;
- private String threadClassName;
+ private long StartTime = -1;
+ private long EndTime = -1;
+ private int threadFuncID;
+ private String threadClassName = CommonConstants.EMPTY;
private DAChartSeries loadSeries;
private DAChartSeries eventSeries;
private DAChartSeries apiSeries;
+
+ public static final byte TYPE_MAIN = 0;
+ public static final byte TYPE_PTHREAD = 1;
+ public static final byte TYPE_TIZEN = 2;
+
+ private static int internalSeq = 0;
+ private int threadDataID = -1;
- public ThreadPageThreadData(String type, String pid, String tid, String attrType,
- String funcName) {
+ public ThreadPageThreadData(int type, String pid, String tid, String attrType,
+ int funcID) {
super(type, String.valueOf(tid), pid, tid, attrType);
- this.threadFuncName = funcName;
+ this.threadFuncID = funcID;
+ threadDataID = internalSeq++;
+ }
+
+ // using open trace
+ public ThreadPageThreadData(int id, int pid, int tid, int threadType, String attrType,
+ long startTime, long endTime, int functionID, String className) {
+ super(threadType, String.valueOf(tid), String.valueOf(pid), String.valueOf(tid), attrType);
+ this.threadDataID = id;
+ this.threadFuncID = functionID;
+ this.StartTime = startTime;
+ this.EndTime = endTime;
+ this.threadClassName = className;
}
public void addDataEvent(ThreadPageThreadDataEvent dataEvent) {
contentsQueue.add(dataEvent);
}
+ public int getThreadFuncID() {
+ return threadFuncID;
+ }
+
public String getThreadFuncName() {
- return threadFuncName;
+ if (threadFuncID == -1) {
+ return CommonConstants.EMPTY;
+ } else {
+ return Global.getFunctionName(threadFuncID);
+ }
}
public String getThreadClassName() {
return ret;
}
- seriesItem = new DAChartSeriesItem(threadEvent.getTime(),
+ seriesItem = new DAChartSeriesItem(threadEvent.getDoubleTime(),
(double) (threadEvent.getThreadType() * 2.55),
threadEvent.getTooltipContent());
int eventApiType = threadEvent.getApiType();
if (eventApiType == LogCenterConstants.THREAD_API_TYPE_INTERNAL_START) {
- seriesItem = new DAChartSeriesItem(threadEvent.getTime(),
+ seriesItem = new DAChartSeriesItem(threadEvent.getDoubleTime(),
DAChartSeriesItem.SERIES_ARROW_LEFT,
threadEvent.getTooltipContent());
seriesItem.setBarWidth(Double.parseDouble(threadEvent
.getCallerTid()));
- setStartTime(String.valueOf(threadEvent.getTime()));
+ setStartTime(threadEvent.getTime());
} else if (eventApiType == LogCenterConstants.THREAD_API_TYPE_WAIT_END) {
- ThreadData data = (ThreadData) threadEvent.getContents();
- if (data.getApiName().equals(
- ThreadPageLabels.THREAD_API_TIZEN_JOIN)) {
- seriesItem = new DAChartSeriesItem(threadEvent.getTime(),
+ if (threadEvent.isJoinAPI()) {
+ seriesItem = new DAChartSeriesItem(threadEvent.getDoubleTime(),
DAChartSeriesItem.SERIES_ARROW_LEFT,
ThreadPageLabels.THREAD_CHART_ITEM_JOINED);
seriesItem.setBarWidth(Double.parseDouble(threadEvent
.getCallerTid()));
} else {
- seriesItem = new DAChartSeriesItem(threadEvent.getTime(),
+ seriesItem = new DAChartSeriesItem(threadEvent.getDoubleTime(),
DAChartSeriesItem.SERIES_ARROW_NONE,
threadEvent.getTooltipContent());
}
} else if (eventApiType == LogCenterConstants.THREAD_API_TYPE_INTERNAL_STOP) {
if (null != threadEvent.getCallerTid()) {
- seriesItem = new DAChartSeriesItem(threadEvent.getTime(),
+ seriesItem = new DAChartSeriesItem(threadEvent.getDoubleTime(),
DAChartSeriesItem.SERIES_ARROW_RIGHT,
threadEvent.getTooltipContent());
seriesItem.setBarWidth(Double.parseDouble(threadEvent
.getCallerTid()));
} else {
- seriesItem = new DAChartSeriesItem(threadEvent.getTime(),
+ seriesItem = new DAChartSeriesItem(threadEvent.getDoubleTime(),
DAChartSeriesItem.SERIES_ARROW_NONE,
threadEvent.getTooltipContent());
}
- setEndTime(String.valueOf(threadEvent.getTime()));
+ setEndTime(threadEvent.getTime());
+ // save ThreadData when endtime is set
+ if (AnalyzerManager.isRunning()) {
+ ThreadChartManager.getInstance().saveThreadPageThreadData(this);
+ }
} else {
- seriesItem = new DAChartSeriesItem(threadEvent.getTime(),
+ seriesItem = new DAChartSeriesItem(threadEvent.getDoubleTime(),
DAChartSeriesItem.SERIES_ARROW_NONE,
threadEvent.getTooltipContent());
}
}
}
- protected void pushSync(ThreadPageSyncData sync) {
+ public void pushSync(ThreadPageSyncData sync) {
syncs.add(sync);
hasUpdate = true;
}
return null;
}
- public String getStartTime() {
+ public String getTypeString() {
+ switch (getType()) {
+ case TYPE_MAIN:
+ return ThreadPageLabels.THREAD_ITEM_TYPE_MAIN;
+ case TYPE_PTHREAD:
+ return ThreadPageLabels.THREAD_ITEM_TYPE_PTHREAD;
+ case TYPE_TIZEN:
+ return ThreadPageLabels.THREAD_ITEM_TYPE_TIZEN;
+ default:
+ Logger.error("unknown thread type!!");
+ return CommonConstants.EMPTY;
+ }
+ }
+
+ public long getStartTime() {
return StartTime;
}
- public void setStartTime(String startTime) {
+ public void setStartTime(long startTime) {
StartTime = startTime;
}
+
+ public String getStartTimeString() { // to show in details view
+ if (StartTime == -1) {
+ return null;
+ } else {
+ double startTime = Formatter.longTimeToDoubleTime(StartTime);
+ return String.valueOf(startTime);
+ }
+ }
- public String getEndTime() {
+ public long getEndTime() {
return EndTime;
}
- public void setEndTime(String endTime) {
+ public void setEndTime(long endTime) {
EndTime = endTime;
}
-}
+
+ public String getEndTimeString() { // to show in details view
+ if (EndTime == -1) {
+ return null;
+ } else {
+ double endTime = Formatter.longTimeToDoubleTime(EndTime);
+ return String.valueOf(endTime);
+ }
+ }
+
+ public int getThreadDataID() {
+ return threadDataID;
+ }
+
+ public static void clear() {
+ internalSeq = 0;
+ }
+}
\ No newline at end of file
* Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
*
* Contact:
+ * WooJin Jung <woojin2.jung@samsung.com>
* yeongtaik byeon <yeongtaik.byeon@samsung.com>
* Juyoung Kim <j0.kim@samsung.com>
*
private DAChartSeriesItem chartItem;
private String callID = null;
private String callerTid = null;
+ private int threadDataID = -1;
+ private boolean isJoinAPI = false;
public ThreadPageThreadDataEvent(int eventType, int threadType,
- int apiType, double time, String tid, String tooltip,
+ int apiType, long time, String tid, String tooltip,
long errorNum, LogData contents) {
super(time, tid, apiType, tooltip, errorNum, contents);
setEventType(eventType);
public void setCallerTid(String callerTid) {
this.callerTid = callerTid;
}
-}
+
+ public int getThreadDataID() {
+ return threadDataID;
+ }
+
+ public void setThreadDataID(int id) {
+ this.threadDataID = id;
+ }
+
+ public boolean isJoinAPI() {
+ return isJoinAPI;
+ }
+
+ public void setJoinAPI(boolean isJoinAPI) {
+ this.isJoinAPI = isJoinAPI;
+ }
+
+}
\ No newline at end of file
package org.tizen.dynamicanalyzer.ui.thread.thread;
import java.util.ArrayList;
-import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
+import java.util.Comparator;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
-import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.common.SymbolManager;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;
import org.tizen.dynamicanalyzer.nl.TimelineChartLabels;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.resources.ColorResources;
import org.tizen.dynamicanalyzer.resources.FontResources;
import org.tizen.dynamicanalyzer.resources.ImageResources;
import org.tizen.dynamicanalyzer.ui.summary.SummaryDataManager;
import org.tizen.dynamicanalyzer.ui.summary.warning.WarningCase;
import org.tizen.dynamicanalyzer.ui.thread.ThreadPageData;
+import org.tizen.dynamicanalyzer.ui.thread.data.SyncAPIInserter;
+import org.tizen.dynamicanalyzer.ui.thread.data.SyncDataInserter;
+import org.tizen.dynamicanalyzer.ui.thread.data.SyncEventInserter;
+import org.tizen.dynamicanalyzer.ui.thread.data.ThreadEventInserter;
import org.tizen.dynamicanalyzer.ui.thread.sync.ThreadPageSyncData;
import org.tizen.dynamicanalyzer.ui.thread.sync.ThreadPageSyncDataEvent;
import org.tizen.dynamicanalyzer.ui.thread.sync.ThreadPageSyncDataManager;
-import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants;
import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
import org.tizen.dynamicanalyzer.util.Logger;
import org.tizen.dynamicanalyzer.widgets.chart.DAChart;
private List<ThreadPageSyncDataEvent> syncEventQueue = new ArrayList<ThreadPageSyncDataEvent>();
private List<ThreadPageThreadDataEvent> eventQueue = new ArrayList<ThreadPageThreadDataEvent>();
private List<ThreadPageThreadDataEvent> callEventQueue = new ArrayList<ThreadPageThreadDataEvent>();
+ // load from database
+ private List<ThreadPageSyncData> syncQueue = new ArrayList<ThreadPageSyncData>();
+
private HashMap<String, Integer> threadAttrMap = new HashMap<String, Integer>();
private HashMap<String, Integer> syncAttrMap = new HashMap<String, Integer>();
// threadFuncMap : (pthreadId, function address)
public ThreadPageThreadDataManager(DAChartBoard board) {
this.setBoard(board);
}
+
+ public List<ThreadPageThreadData> getRows() {
+ return rows;
+ }
- private void pushRow(ThreadPageThreadData data) {
+ public void pushRow(ThreadPageThreadData data) {
rowsQueue.add(data);
hasUpdate = true;
}
syncEventQueue.add(syncEvent);
hasUpdate = true;
}
+
+ public void pushSyncData(ThreadPageSyncData syncData) {
+ syncQueue.add(syncData);
+ }
private void createBoardItem(ThreadPageThreadData data) {
// DACustomChartBoardItem item = new DACustomChartBoardItem(board,
// data.getName());
- DAChartBoardItem item = new DAChartBoardItem(board, data.getType()
+ DAChartBoardItem item = new DAChartBoardItem(board, data.getTypeString()
+ ThreadPageLabels.THREAD_CHART_NAME_PREFIX
+ ThreadPageLabels.THREAD_CHART_NAME_PID + data.getPid()
+ ThreadPageLabels.THREAD_CHART_NAME_COMMA
// data.getName());
Integer tid = Integer.valueOf(data.getTid());
- DAChartBoardItem item = new DAChartBoardItem(board, data.getType()
+ DAChartBoardItem item = new DAChartBoardItem(board, data.getTypeString()
+ ThreadPageLabels.THREAD_CHART_NAME_PREFIX
+ ThreadPageLabels.THREAD_CHART_NAME_PID + data.getPid()
+ ThreadPageLabels.THREAD_CHART_NAME_COMMA
return false;
}
- DAChartBoardItem item = new DAChartBoardItem(parent, sync.getType()
+ DAChartBoardItem item = new DAChartBoardItem(parent, sync.getTypeString()
+ ThreadPageLabels.THREAD_CHART_NAME_PREFIX
+ ThreadPageLabels.THREAD_CHART_NAME_OBJ + sync.getKey()
+ ThreadPageLabels.THREAD_CHART_NAME_POSTFIX);
}
public void createMainThreadItem(int tid) {
+ int funcID = Global.getFunctionID("main");
ThreadPageThreadData mainData = new ThreadPageThreadData(
- ThreadPageLabels.THREAD_ITEM_TYPE_MAIN, String.valueOf(tid),
- String.valueOf(tid), CommonConstants.EMPTY, "main");
+ ThreadPageThreadData.TYPE_MAIN, String.valueOf(tid),
+ String.valueOf(tid), CommonConstants.EMPTY, funcID);
pushRow(mainData);
}
loads = processDataList[i].getThreadLoad();
String[] temp = loads.split(",");
int tempSize = temp.length;
- double time;
+ long time;
for (int j = 0; j + 1 < tempSize; j += 2) {
try {
tid = temp[j];
// continue;
// }
load = (int) (Double.parseDouble(temp[j + 1]));
- time = Double.parseDouble(Long.toString(input.getTime()))
- / TimelineConstants.MEGA_DOUBLE;
+ time = input.getTime();
ThreadPageThreadDataEvent event = new ThreadPageThreadDataEvent(
ThreadPageThreadDataEvent.TYPE_LOAD, load, -1, time, tid,
String.valueOf(load)
}
}
hasUpdate = true;
-
// loads = sysLog.getThreadLoad(); // TODO SystemData interface changed.
// // loads = input.get(LogCenterConstants.DEVICE_THREAD_LOAD_INDEX);
// String[] temp = loads.split(",");
loads = processDataList[j].getThreadLoad();
String[] temp = loads.split(",");
int tempSize = temp.length;
- double time;
+ long time;
for (int k = 0; k + 1 < tempSize; k += 2) {
try {
tid = temp[k];
// continue;
// }
load = (int) (Double.parseDouble(temp[k + 1]));
- time = Double.parseDouble(Long.toString(input.getTime()))
- / TimelineConstants.MEGA_DOUBLE;
+ time = input.getTime();
ThreadPageThreadDataEvent event = new ThreadPageThreadDataEvent(
ThreadPageThreadDataEvent.TYPE_LOAD, load, -1, time, tid,
String.valueOf(load)
}
}
-
// loads = input.getThreadLoad(); // TODO SystemData interface changed.
// String[] temp = loads.split(",");
// int tempSize = temp.length;
}
private void parsePthread(ThreadData input) {
- double time = Double.parseDouble(Long.toString(input.getTime()))
- / TimelineConstants.MEGA_DOUBLE;
+ long time = input.getTime();
String pid = Integer.toString(input.getPid());
String tid = Integer.toString(input.getTid());
int apiType = input.getApiType();
long errorNum = input.getErrno();
ThreadPageThreadDataEvent event;
String pthreadId = Long.toString(input.getPThreadId());
+
+ if (errorNum != 0) {
+ SummaryDataManager.getInstance().getFailedApiDataMaker().makeData(input);
+ }
switch (apiType) {
case LogCenterConstants.THREAD_API_TYPE_NEW:
case LogCenterConstants.THREAD_API_TYPE_INTERNAL_START:
Integer threadAttrTypeInt = threadAttrMap.get(pthreadId);
String threadAttrType;
- String funcName;
+ int funcID;
if (null != threadAttrTypeInt) {
threadAttrType = getAttrTypeByTypeInt(threadAttrTypeInt);
} else {
threadAttrType = ThreadPageLabels.THREAD_ATTR_TYPE_JOINABLE;
}
- // get thread function name for this pthread
- funcName = Global.getFunctionName(SymbolManager
- .getFuncId(null, threadFuncMap.get(pthreadId),
- input.getPid(), input.getTime()));
+ // get thread function id for this pthread
+ funcID = SymbolManager.getFuncId(null, threadFuncMap.get(pthreadId),
+ input.getPid(), input.getTime());
ThreadPageThreadData data = new ThreadPageThreadData(
- ThreadPageLabels.THREAD_ITEM_TYPE_PTHREAD, pid, tid,
- threadAttrType, funcName);
+ ThreadPageThreadData.TYPE_PTHREAD, pid, tid,
+ threadAttrType, funcID);
pushRow(data);
event = new ThreadPageThreadDataEvent(
ThreadPageThreadDataEvent.TYPE_EVENT,
}
private void parseTIZEN(ThreadData input) {
- double time = Double.parseDouble(Long.toString(input.getTime()))
- / TimelineConstants.MEGA_DOUBLE;
+ long time = input.getTime();
String pid = Integer.toString(input.getPid());
String tid = Integer.toString(input.getTid());
int apiType = input.getApiType();
ThreadPageThreadData data;
ThreadPageThreadDataEvent event;
long errorNum = input.getErrno();
+
+ if (errorNum != 0) {
+ SummaryDataManager.getInstance().getFailedApiDataMaker().makeData(input);
+ }
+
switch (apiType) {
case LogCenterConstants.THREAD_API_TYPE_NEW:
case LogCenterConstants.THREAD_API_TYPE_STOP:
break;
case LogCenterConstants.THREAD_API_TYPE_INTERNAL_START:
data = new ThreadPageThreadData(
- ThreadPageLabels.THREAD_ITEM_TYPE_TIZEN, pid, tid,
- ThreadPageLabels.THREAD_ATTR_TYPE_JOINABLE, CommonConstants.EMPTY);
+ ThreadPageThreadData.TYPE_TIZEN, pid, tid,
+ ThreadPageLabels.THREAD_ATTR_TYPE_JOINABLE, -1);
// TIZEN thread includes the internal thread
if ((className = checkCalledThread(callID)) != null) {
data.setThreadClassName(className);
return;
}
SyncData syncData = (SyncData) input;
- double time = Double.parseDouble(Long.toString(input.getTime()))
- / TimelineConstants.MEGA_DOUBLE;
+ long time = input.getTime();
String tid = Integer.toString(syncData.getTid());
// FIXME
SyncData input;
for (int i = 0; i < size; i++) {
input = (SyncData) inputs.get(i);
- double time = Double.parseDouble(Long.toString(input.getTime()))
- / TimelineConstants.MEGA_DOUBLE;
+ long time = input.getTime();
String tid = Integer.toString(input.getTid());
// FIXME
return null;
}
- private String getSyncTypeString(int syncType) {
- switch (syncType) {
- case LogCenterConstants.SYNC_TYPE_TIZEN_MUTEX:
- return ThreadPageLabels.SYNC_TYPE_TIZEN_MUTEX;
- case LogCenterConstants.SYNC_TYPE_TIZEN_MONITOR:
- return ThreadPageLabels.SYNC_TYPE_TIZEN_MONITOR;
- case LogCenterConstants.SYNC_TYPE_TIZEN_SEMAPHORE:
- return ThreadPageLabels.SYNC_TYPE_TIZEN_SEMAPHORE;
- case LogCenterConstants.SYNC_TYPE_PTHREAD_MUTEX:
- return ThreadPageLabels.SYNC_TYPE_PTHREAD_MUTEX;
- case LogCenterConstants.SYNC_TYPE_PTHREAD_COND_VARIABLE:
- return ThreadPageLabels.SYNC_TYPE_PTHREAD_COND_VARIABLE;
- case LogCenterConstants.SYNC_TYPE_PTHREAD_RWLOCK:
- return ThreadPageLabels.SYNC_TYPE_PTHREAD_RWLOCK;
- case LogCenterConstants.SYNC_TYPE_PTHREAD_SPINLOCK:
- return ThreadPageLabels.SYNC_TYPE_PTHREAD_SPINLOCK;
- case LogCenterConstants.SYNC_TYPE_PTHREAD_BARRIER:
- return ThreadPageLabels.SYNC_TYPE_PTHREAD_BARRIER;
- default:
- return CommonConstants.EMPTY;
- }
- }
-
private void chartFilteringByPid() {
if(null == board || null == board.getItemList()){
return;
data = findParentData(event.getTid());
if (null != data) {
data.pushEvent(event);
+ event.setThreadDataID(data.getThreadDataID());
+ // save to DB
+ ThreadEventInserter.pushThreadEvent(event);
+ ThreadEventInserter.startThread();
eventQueue.remove(remainCalleeEventCount);
} else {
remainCalleeEventCount++;
}
}
}
-
+
+ /* load ThreadPageSyncData when open trace */
+ size = syncQueue.size();
+ if (size > 0) {
+ ThreadPageThreadData data;
+ ThreadPageSyncData sync;
+ for (int i = 0; i < size; i++) {
+ sync = syncQueue.get(0);
+ data = findParentData(sync.getTid());
+ if (null != data) {
+ createSyncBoardItem(data, sync);
+ data.pushSync(sync);
+ data.setHasUpdate();
+ }
+ syncQueue.remove(0);
+ }
+ }
+
size = syncEventQueue.size();
if (size > 0) {
ThreadPageThreadData data;
.getAttrTypeString(event);
}
- sync = new ThreadPageSyncData(
- getSyncTypeString(event.getType()),
- syncVal, pid, event.getTid(),
- syncAttrType);
+ sync = new ThreadPageSyncData(event.getType(), syncVal, pid,
+ event.getTid(), syncAttrType, ThreadPageSyncData.THREAD_CHILD);
+ sync.setParentID(data.getThreadDataID());
+ // save to DB
+ SyncDataInserter.pushSyncData(sync);
+ SyncDataInserter.startThread();
createSyncBoardItem(data, sync);
data.pushSync(sync);
}
sync.pushEvent(event);
+ event.setSyncDataID(sync.getSyncDataID());
+ // save to DB
+ SyncEventInserter.pushSyncEvent(event);
+ SyncEventInserter.startThread();
+ // save syncAPI to DB
+ if (ThreadPageSyncData.isSyncApi(event.getApiType())) {
+ SyncAPIInserter.pushSyncEvent((SyncData) event.getContents());
+ SyncAPIInserter.startThread();
+ }
data.setHasUpdate();
}
syncEventQueue.remove(0);
rowsQueue.clear();
eventQueue.clear();
callEventQueue.clear();
+ threadAttrMap.clear();
syncAttrMap.clear();
callRowsQueue.clear();
syncEventQueue.clear();
+ threadFuncMap.clear();
hasUpdate = false;
+ ThreadPageThreadData.clear(); // reset internal seq number
}
-}
+}
\ No newline at end of file
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));
+ DBConstants.DBTYPE_VARCHAR, DALimit.FUNCTION_ARGUMENTS_VALUE_LENGTH));
setIndexColumn(COLUMN.STARTTIME.index);
}
return value;
}
- public static double toLongTimeForDoubleTime(long time) {
+ public static double longTimeToDoubleTime(long time) {
return time / TimelineConstants.MEGA_DOUBLE;
}
projects / sdk / tools / dynamic-analyzer.git / commitdiff