--- /dev/null
+package org.tizen.dynamicanalyzer.common;
+
+import org.tizen.dynamicanalyzer.model.DeviceInfo;
+import org.tizen.dynamicanalyzer.project.Project;
+
+// This class is for global information that can be accessed from anywhere in dynamic analyzer code.
+// So this class contains only static methods and variables.
+public class GlobalInformation {
+ private static DeviceInfo currentDevice;
+ private static Project currentProject;
+
+ public static DeviceInfo getCurrentDeviceInfo() {
+ return currentDevice;
+ }
+
+ public static Project getCurrentProject() {
+ return currentProject;
+ }
+
+ public static void setCurrentDeviceInfo(DeviceInfo device) {
+ currentDevice = device;
+ }
+
+ public static void setCurrentProject(Project project) {
+ currentProject = project;
+ }
+}
--- /dev/null
+package org.tizen.dynamicanalyzer.database;
+
+import org.tizen.dynamicanalyzer.constant.CommonConstants;
+
+public class DBColumn {
+ private String name;
+ private String option;
+ private String type;
+
+ public DBColumn(String name, String option, String type) {
+ this.name = name;
+ this.option = option;
+ this.type = type;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public String getOption() {
+ return option;
+ }
+
+ public String getType() {
+ return type;
+ }
+
+ public String getColumnString() {
+ return name + CommonConstants.SPACE + type + CommonConstants.SPACE
+ + option;
+ }
+
+}
--- /dev/null
+package org.tizen.dynamicanalyzer.database;
+
+import org.tizen.dynamicanalyzer.constant.CommonConstants;
+
+public class DBConstants {
+ // options constant
+ public static final String EMPTY = CommonConstants.EMPTY;
+ public static final String NOT_NULL = "not null";//$NON-NLS-1$
+
+ // types type constant
+ public static final String VARCHAR = "VARCHAR";//$NON-NLS-1$
+ public static final String TEXT = "VARCHAR(256)";//$NON-NLS-1$
+ public static final String BIG_TEXT = "VARCHAR(1024)";//$NON-NLS-1$
+ public static final String BIGBIG_TEXT = "VARCHAR(16384)";//$NON-NLS-1$
+ public static final String INTEGER = "INTEGER";//$NON-NLS-1$
+ public static final String LONG = "BIGINT";//$NON-NLS-1$
+
+ // common column name
+ public static final String COMMON_COLUMN_RID = "Rid";//$NON-NLS-1$
+ public static final String COMMON_COLUMN_ID = "Id";//$NON-NLS-1$
+ public static final String COMMON_COLUMN_SEQ = "SeqNumber";//$NON-NLS-1$
+ public static final String COMMON_COLUMN_TIME = "Time";//$NON-NLS-1$
+ public static final String COMMON_COLUMN_PID = "Pid";//$NON-NLS-1$
+ public static final String COMMON_COLUMN_TID = "Tid";//$NON-NLS-1$
+}
--- /dev/null
+package org.tizen.dynamicanalyzer.database;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.tizen.dynamicanalyzer.constant.CommonConstants;
+
+public abstract class DBTable {
+ private List<DBColumn> columns = new ArrayList<DBColumn>();
+
+ public abstract String getTableName();
+
+ public final List<DBColumn> getColumns() {
+ return columns;
+ }
+
+ public final int getColumnSize() {
+ return columns.size();
+ }
+
+ protected final void addColumn(DBColumn col) {
+ columns.add(col);
+ }
+
+ public final void createTable() {
+ StringBuffer query = new StringBuffer();
+ query.append("create table ");
+ query.append(getTableName());
+ query.append(CommonConstants.SPACE + CommonConstants.OPEN_BRACKET);
+
+ int size = columns.size();
+ for (int i = 0; i < size; i++) {
+ query.append(columns.get(i).getColumnString());
+ if (i == size - 1) {
+ query.append(CommonConstants.CLOSE_BRACKET);
+ } else {
+ query.append(CommonConstants.COMMA);
+ }
+ }
+ query.append(CommonConstants.SEMICOLON);
+
+ String queryString = query.toString();
+ SqlConnectionManager.executeUpdate(queryString);
+ }
+
+ public final void insertData(List<List<Object>> data) {
+ List<String> columnType = new ArrayList<String>();
+ StringBuffer query = new StringBuffer();
+ query.append("insert into ").append(getTableName()).append(" values( ");
+
+ int columnsize = columns.size();
+ for (int i = 0; i < columnsize; i++) {
+ columnType.add(columns.get(i).getType());
+
+ if (i == columnsize - 1) {
+ query.append(" ? )");
+ } else {
+ query.append("?, ");
+ }
+ }
+ query.append(CommonConstants.SEMICOLON);
+
+ // execute prepared with data
+ SqlConnectionManager
+ .executePrepared(query.toString(), data, columnType);
+ }
+
+ // select data from this table
+ // if column list is null, then all column will be selected
+ public final List<List<Object>> selectData(List<String> column, String option) {
+ StringBuffer query = new StringBuffer();
+ query.append("select ");
+
+ if(column != null) {
+ int columnsize = column.size();
+ for (int i = 0; i < columnsize; i++) {
+ query.append(column.get(i));
+ if(i < columnsize - 1)
+ query.append(", ");//$NON-NLS-1$
+ }
+ } else {
+ int columnsize = columns.size();
+ for (int i = 0; i < columnsize; i++) {
+ query.append(columns.get(i).getName());
+ if(i < columnsize - 1)
+ query.append(", ");//$NON-NLS-1$
+ }
+ }
+
+ query.append(" from ").append(getTableName());
+ query.append(" ").append(option);
+
+ return SqlConnectionManager.executeQuery(query.toString());
+ }
+
+ public final void createIndexTable(String indexColumn) {
+ String queryString = "create index " + getTableName() + "_index on "//$NON-NLS-1$//$NON-NLS-2$
+ + getTableName() + CommonConstants.OPEN_BRACKET + indexColumn
+ + CommonConstants.CLOSE_BRACKET;
+
+ SqlConnectionManager.executeUpdate(queryString);
+ }
+}
--- /dev/null
+package org.tizen.dynamicanalyzer.database;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.SQLWarning;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.tizen.dynamicanalyzer.util.CommonUtil;
+
+public class SqlConnectionManager {
+
+ private static Connection connection = null;
+
+ public static boolean establishConnection(String dbFilePath) {
+ boolean result = true;
+ try {
+ synchronized (connection) {
+ if (connection == null) {
+ Class.forName("org.hsqldb.jdbcDriver");
+ String dbUrl = "jdbc:hsqldb:"
+ + dbFilePath
+ + ";shutdown=true;hsqldb.default_table_type=cached;hsqldb.large_data=true;hdqldb.log_data=false"; //$NON-NLS-1$
+ connection = DriverManager.getConnection(dbUrl, "SA", "");
+ SQLWarning warning = connection.getWarnings();
+ while (warning != null) {
+ System.out.println("[DB] Message: "
+ + warning.getMessage());
+ System.out.println("[DB] SQL state: "
+ + warning.getSQLState());
+ System.out.println("[DB] Vendor code: "
+ + warning.getErrorCode());
+ warning = warning.getNextWarning();
+ }
+ }
+ }
+ } catch (ClassNotFoundException e) {
+ e.printStackTrace();
+ } catch (SQLException e) {
+ e.printStackTrace();
+ } finally {
+ if (connection == null)
+ result = false;
+ else
+ result = true;
+ }
+
+ return result;
+ }
+
+ public static void closeConnection() {
+ synchronized (connection) {
+ if (connection != null) {
+ try {
+ Statement st = connection.createStatement();
+ st.execute("SHUTDOWN");
+ CommonUtil.tryClose(st);
+ connection.close();
+ } catch (SQLException se) {
+ if (!se.getSQLState().equals("XJ015")) {
+ System.out.println("DB did not shutdown normally");
+ }
+ }
+ connection = null;
+ }
+ }
+ }
+
+ private static void semaphoreAcquire() {
+
+ }
+
+ private static void semaphoreRelease() {
+
+ }
+
+ public static void executeUpdate(String statement) {
+ Statement sm = null;
+ try {
+ if (connection != null) {
+ semaphoreAcquire();
+ sm = connection.createStatement();
+ sm.executeUpdate(statement);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ } finally {
+ CommonUtil.tryClose(sm);
+ semaphoreRelease();
+ }
+ }
+
+ public static void executePrepared(String query, List<List<Object>> data,
+ List<String> columnType) {
+ PreparedStatement prep = null;
+ try {
+ if (connection != null) {
+ prep = connection.prepareStatement(query);
+
+ // count ? in query
+ int questionCount = 0;
+ int querylen = query.length();
+ for (int i = 0; i < querylen; i++) {
+ if (query.charAt(i) == '?')
+ questionCount++;
+ }
+
+ // set data into prepared statement
+ Object col;
+ int datasize = data.size();
+ int columnsize = columnType.size();
+ if (columnsize != questionCount) {
+ System.out
+ .println("[ERR] column count of columnType is not matches!!");
+ return;
+ }
+
+ connection.setAutoCommit(false);
+
+ for (int k = 0; k < datasize; k++) {
+ List<Object> row = data.get(k);
+ int datacolsize = row.size();
+ if (datacolsize == columnsize) { // column count is equal
+ boolean isPrepared = true;
+
+ for (int i = 0; i < columnsize; i++) {
+ col = row.get(i);
+
+ try {
+ if (columnType.get(i).equals(DBConstants.TEXT)) {
+ prep.setString(i, (String) col);
+ } else if (columnType.get(i).equals(
+ DBConstants.BIG_TEXT)) {
+ prep.setString(i, (String) col);
+ } else if (columnType.get(i).equals(
+ DBConstants.BIGBIG_TEXT)) {
+ prep.setString(i, (String) col);
+ } else if (columnType.get(i).equals(
+ DBConstants.INTEGER)) {
+ if (col == null) {
+ System.out
+ .println("[ERR] Integer column data is null !!");
+ isPrepared = false;
+ break;
+ } else {
+ prep.setInt(i, (Integer) col);
+ }
+ } else if (columnType.get(i).equals(
+ DBConstants.LONG)) {
+ if (col == null) {
+ System.out
+ .println("[ERR] Long column data is null !!");
+ isPrepared = false;
+ break;
+ } else {
+ prep.setLong(i, (Long) col);
+ }
+ } else {
+ System.out
+ .println("[ERR] not supported DB column type!!");
+ isPrepared = false;
+ break;
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+ }
+
+ try {
+ if (isPrepared) {
+ prep.addBatch();
+ }
+ prep.clearParameters();
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+ } else { // column count is not equal
+ System.out
+ .println("[ERR] column count is not equal !!");
+ }
+ }
+
+ prep.executeBatch();
+ connection.commit();
+ connection.setAutoCommit(true);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ } finally {
+ CommonUtil.tryClose(prep);
+ }
+ }
+
+ public static List<List<Object>> executeQuery(String query) {
+ Statement sm = null;
+ ResultSet rs = null;
+ List<List<Object>> result = null;
+ try {
+ if (connection != null) {
+ semaphoreAcquire();
+ sm = connection.createStatement();
+ rs = sm.executeQuery(query);
+ if (rs != null) {
+ result = new ArrayList<List<Object>>();
+ ResultSetMetaData rsMetaData = rs.getMetaData();
+ int columnCount = rsMetaData.getColumnCount();
+ while (rs.next()) {
+ List<Object> rowData = new ArrayList<Object>();
+ // ResultSet index starts from 1
+ for (int i = 1; i < columnCount + 1; i++) {
+ if (rsMetaData.getColumnTypeName(i).contains(
+ DBConstants.INTEGER)) {
+ rowData.add(new Integer(rs.getInt(i)));
+ } else if (rsMetaData.getColumnTypeName(i)
+ .contains(DBConstants.LONG)) {
+ rowData.add(new Long(rs.getLong(i)));
+ } else if (rsMetaData.getColumnTypeName(i)
+ .contains(DBConstants.VARCHAR)) {
+ rowData.add(rs.getString(i));
+ } else {
+ System.out.println("[ERR] undefined type : "
+ + rsMetaData.getColumnTypeName(i));
+ }
+ }
+ result.add(rowData);
+ }
+ }
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ } finally {
+ CommonUtil.tryClose(sm);
+ semaphoreRelease();
+ }
+
+ return result;
+ }
+}
List<String> info = dbInfo.get(0);\r
TargetInfo targetInfo = new TargetInfo();\r
targetInfo.loadSaveFormat(info);\r
- AnalyzerManager.getProject().setTargetInfo(targetInfo);\r
+ DACommunicator.getSelectedDevice().setTargetInfo(targetInfo);\r
}\r
\r
List<String> pids = SqlManager.getInstance().getPids();\r
}\r
String subOption = "where pid = " + process.getPid()\r
+ " and time = \'"\r
- + process.getStartTime().getSaveFormat() + "\'";\r
+ + process.getStartTime().toString() + "\'";\r
List<List<String>> objInfo = SqlManager.getInstance()\r
.loadLibObj(subOption);\r
if (null == objInfo) {\r
private Grid grid = null;
private GridItem oldItem = null;
private Shell tooltip;
- private boolean enabled = true; /* source view */
+ private boolean enabled = true; /* source view */
private boolean onViewSourceFromContext = false;
-
-
+
private static final int MARGIN = 5;
private static final int SPACING = 0;
private static final int SOURCE_LINE_TOP = 5;
setViewCursor(isToggled);
break;
case SWT.MouseEnter:
-// grid.setFocus();
+ // grid.setFocus();
if (isToggled && enabled && !onViewSourceFromContext) {
-//// createTooltip(event);
- GridItem item = grid.getItem(new Point(event.x, event.y));
- SourceLine sl = getCallerSourceLine(item);
- viewSource(event.x, event.y, sl, false);
+ // // createTooltip(event);
+ GridItem item = grid.getItem(new Point(event.x, event.y));
+ SourceLine sl = getCallerSourceLine(item);
+ viewSource(event.x, event.y, sl, false);
}
break;
case SWT.MouseExit:
- if (!onViewSourceFromContext) {
- disposeTooltip();
- }
+ if (!onViewSourceFromContext) {
+ disposeTooltip();
+ }
break;
case SWT.MouseMove:
- if (!onViewSourceFromContext) {
- GridItem gridItem = grid.getItem(new Point(event.x, event.y));
- if (null == oldItem) {
- oldItem = gridItem;
- }
- if (null != tooltip) {
- if (null != gridItem) {
- if (!gridItem.equals((GridItem) oldItem)) {
- oldItem = gridItem;
- } else {
- return;
- }
- }
- tooltip.dispose();
- tooltip = null;
- }
- }
+ if (!onViewSourceFromContext) {
+ GridItem gridItem = grid.getItem(new Point(event.x, event.y));
+ if (null == oldItem) {
+ oldItem = gridItem;
+ }
+ if (null != tooltip) {
+ if (null != gridItem) {
+ if (!gridItem.equals((GridItem) oldItem)) {
+ oldItem = gridItem;
+ } else {
+ return;
+ }
+ }
+ tooltip.dispose();
+ tooltip = null;
+ }
+ }
break;
case SWT.MouseDoubleClick:
if (isToggled && enabled) {
-// openIDE(event);
- GridItem item = grid.getItem(new Point(event.x, event.y));
- SourceLine sl = getCallerSourceLine(item);
- openIDE(sl, item);
+ // openIDE(event);
+ GridItem item = grid.getItem(new Point(event.x, event.y));
+ SourceLine sl = getCallerSourceLine(item);
+ openIDE(sl, item);
}
break;
case SWT.MouseHover:
-// grid.setFocus();
+ // grid.setFocus();
if (isToggled && enabled && !onViewSourceFromContext) {
-// createTooltip(event);
- GridItem item = grid.getItem(new Point(event.x, event.y));
- SourceLine sl = getCallerSourceLine(item);
- viewSource(event.x, event.y, sl, false);
+ // createTooltip(event);
+ GridItem item = grid.getItem(new Point(event.x, event.y));
+ SourceLine sl = getCallerSourceLine(item);
+ viewSource(event.x, event.y, sl, false);
}
break;
default:
public void setEnable(boolean enabled) {
this.enabled = enabled;
}
-
+
public SourceLine getCallerSourceLine(GridItem item) {
- if (item == null) {
- return null;
- }
- // Gets source path and line.
- DATableDataFormat tableData = (DATableDataFormat) item.getData();
- LogData data = null;
- long addr = -1;
- // boolean isPieBuild = AnalyzerUtil.isPieBuild(data.getPid());
- int pid = -1;
- long time = 0;
- String libName = null;
-
- switch (tableData.getType()) {
- case AnalyzerConstants.TYPE_TABLE_CALLSTACK:
- addr = (Long) item.getData(AnalyzerConstants.CALLSTACK_KEY_ADDR);
- pid = (Integer) item.getData(AnalyzerConstants.CALLSTACK_KEY_PID);
- time = (Long) item.getData(AnalyzerConstants.CALLSTACK_KEY_TIME);
- libName = (String) item
- .getData(AnalyzerConstants.CALLSTACK_KEY_LIBNAME);
- break;
- case AnalyzerConstants.TYPE_TABLE_FAILED:
- List<String> failedData = tableData.getData();
- addr = Long.parseLong(failedData.get(8));
- pid = Integer.parseInt(failedData.get(7));
- time = Long.parseLong(failedData.get(1));
- libName = failedData.get(9);
- break;
- case AnalyzerConstants.TYPE_TABLE_LEAK:
- List<String> leakData = tableData.getData();
- addr = Long.parseLong(leakData.get(9));
- pid = Integer.parseInt(leakData.get(1));
- time = Long.parseLong(leakData.get(4));
- libName = leakData.get(7);
- break;
- case AnalyzerConstants.TYPE_TABLE_WARNING:
- data = tableData.getLogData();
- ProbeCommonData pData = (ProbeCommonData) data;
- addr = pData.getCallerPcAddr();
- pid = data.getPid();
- time = data.getTime();
- libName = pData.getLibName();
- break;
- case AnalyzerConstants.TYPE_TABLE_CALLTRACE:
- data = tableData.getLogData();
- if (data instanceof UserFunctionData) {
- addr = ((UserFunctionData) data).getCallerPcAddr();
- libName = ((UserFunctionData) data).getLibName();
- } else if (data instanceof ProfileData) {
- addr = ((ProfileData) data).getCallerPcAddr();
- libName = ((ProfileData) data).getLibName();
- }
- pid = data.getPid();
- time = data.getTime();
- break;
- default: // normal
- data = tableData.getLogData();
- ProbeCommonData wData = (ProbeCommonData) data;
- addr = wData.getCallerPcAddr();
- pid = data.getPid();
- time = data.getTime();
- libName = wData.getLibName();
- }
- return getSourceLine(addr, pid, time, libName);
+ if (item == null) {
+ return null;
+ }
+ // Gets source path and line.
+ DATableDataFormat tableData = (DATableDataFormat) item.getData();
+ LogData data = null;
+ long addr = -1;
+ // boolean isPieBuild = AnalyzerUtil.isPieBuild(data.getPid());
+ int pid = -1;
+ long time = 0;
+ String libName = null;
+
+ switch (tableData.getType()) {
+ case AnalyzerConstants.TYPE_TABLE_CALLSTACK:
+ addr = (Long) item.getData(AnalyzerConstants.CALLSTACK_KEY_ADDR);
+ pid = (Integer) item.getData(AnalyzerConstants.CALLSTACK_KEY_PID);
+ time = (Long) item.getData(AnalyzerConstants.CALLSTACK_KEY_TIME);
+ libName = (String) item
+ .getData(AnalyzerConstants.CALLSTACK_KEY_LIBNAME);
+ break;
+ case AnalyzerConstants.TYPE_TABLE_FAILED:
+ List<Object> failedData = tableData.getData();
+ addr = (Long) failedData.get(8);
+ pid = (Integer) failedData.get(7);
+ time = (Long) failedData.get(1);
+ libName = (String) failedData.get(9);
+ break;
+ case AnalyzerConstants.TYPE_TABLE_LEAK:
+ List<Object> leakData = tableData.getData();
+ addr = (Long) leakData.get(9);
+ pid = (Integer) leakData.get(1);
+ time = (Long) leakData.get(4);
+ libName = (String) leakData.get(7);
+ break;
+ case AnalyzerConstants.TYPE_TABLE_WARNING:
+ data = tableData.getLogData();
+ ProbeCommonData pData = (ProbeCommonData) data;
+ addr = pData.getCallerPcAddr();
+ pid = data.getPid();
+ time = data.getTime();
+ libName = pData.getLibName();
+ break;
+ case AnalyzerConstants.TYPE_TABLE_CALLTRACE:
+ data = tableData.getLogData();
+ if (data instanceof UserFunctionData) {
+ addr = ((UserFunctionData) data).getCallerPcAddr();
+ libName = ((UserFunctionData) data).getLibName();
+ } else if (data instanceof ProfileData) {
+ addr = ((ProfileData) data).getCallerPcAddr();
+ libName = ((ProfileData) data).getLibName();
+ }
+ pid = data.getPid();
+ time = data.getTime();
+ break;
+ default: // normal
+ data = tableData.getLogData();
+ ProbeCommonData wData = (ProbeCommonData) data;
+ addr = wData.getCallerPcAddr();
+ pid = data.getPid();
+ time = data.getTime();
+ libName = wData.getLibName();
+ }
+ return getSourceLine(addr, pid, time, libName);
}
-
+
public SourceLine getDefinitionSourceLine(GridItem item) {
- if (item == null) {
- return null;
- }
- DATableDataFormat tableData = (DATableDataFormat) item.getData();
- long addr = -1;
- String libName = null;
+ if (item == null) {
+ return null;
+ }
+ DATableDataFormat tableData = (DATableDataFormat) item.getData();
+ long addr = -1;
+ String libName = null;
int pid = -1;
long time = 0;
-
- switch (tableData.getType()) {
- case AnalyzerConstants.TYPE_TABLE_CALLTRACE:
- LogData data = tableData.getLogData();
- if (data instanceof UserFunctionData) {
- addr = ((UserFunctionData) data).getPcAddr();
- libName = ((UserFunctionData) data).getLibName();
- } else if (data instanceof ProfileData) {
- addr = ((ProfileData) data).getPcAddr();
- libName = ((ProfileData) data).getLibName();
- }
- pid = data.getPid();
- time = data.getTime();
- break;
- default:
- /*
- * Do Nothing.
- */
- break;
- }
- return getSourceLine(addr, pid, time, libName);
+
+ switch (tableData.getType()) {
+ case AnalyzerConstants.TYPE_TABLE_CALLTRACE:
+ LogData data = tableData.getLogData();
+ if (data instanceof UserFunctionData) {
+ addr = ((UserFunctionData) data).getPcAddr();
+ libName = ((UserFunctionData) data).getLibName();
+ } else if (data instanceof ProfileData) {
+ addr = ((ProfileData) data).getPcAddr();
+ libName = ((ProfileData) data).getLibName();
+ }
+ pid = data.getPid();
+ time = data.getTime();
+ break;
+ default:
+ /*
+ * Do Nothing.
+ */
+ break;
+ }
+ return getSourceLine(addr, pid, time, libName);
}
-
- public void viewSource(int x, int y, SourceLine sl, boolean onViewSourceFromContext) {
- this.onViewSourceFromContext = onViewSourceFromContext;
- GridItem item = grid.getItem(new Point(x, y));
- if (null != item) {
+
+ public void viewSource(int x, int y, SourceLine sl,
+ boolean onViewSourceFromContext) {
+ this.onViewSourceFromContext = onViewSourceFromContext;
+ GridItem item = grid.getItem(new Point(x, y));
+ if (null != item) {
disposeTooltip();
if (null == sl
Shell shell = WorkbenchUtil.getWorkbenchWindow().getShell();
final Display display = shell.getDisplay();
display.addFilter(SWT.FocusOut, new Listener() {
- @Override
- public void handleEvent(Event event) {
- disposeTooltip();
- display.removeFilter(SWT.FocusOut, this);
- }
+ @Override
+ public void handleEvent(Event event) {
+ disposeTooltip();
+ display.removeFilter(SWT.FocusOut, this);
+ }
});
display.addFilter(SWT.MouseDown, new Listener() {
- @Override
- public void handleEvent(Event event) {
- disposeTooltip();
- display.removeFilter(SWT.MouseDown, this);
- }
+ @Override
+ public void handleEvent(Event event) {
+ disposeTooltip();
+ display.removeFilter(SWT.MouseDown, this);
+ }
});
tooltip = new Shell(shell, SWT.ON_TOP | SWT.NO_FOCUS | SWT.TOOL);
tooltip.setBackground(ColorResources.TOOLTIP);
tooltipShow(x, y);
}
-
+
}
-
+
public void openIDE(SourceLine sl, GridItem gridItem) {
if (null == gridItem) {
return;
}
if ((null == sl) || (!sl.isValid())
- || (IDECommunicator.isConnected() == false)) {
- createErrorPopup(AnalyzerLabels.IDE_NOT_LAUNCHED);
- return;
+ || (IDECommunicator.isConnected() == false)) {
+ createErrorPopup(AnalyzerLabels.IDE_NOT_LAUNCHED);
+ return;
}
String filePath = getSourcePath(gridItem, sl);
int lineNum = sl.getLineNumber();
IDECommunicator.sendCodeInfoToIDE(filePath, Integer.toString(lineNum));
}
-
+
private void setViewCursor(boolean toggled) {
if (!toggled) {
grid.setCursor(defaultCursor);
-// disposeTooltip();
+ // disposeTooltip();
} else {
grid.setCursor(sourceCursor);
}
String filePath = sourcePath.substring(index + 4, sourcePath.length());
return filePath;
}
-
+
private void tooltipShow(int x, int y) {
Point size = tooltip.computeSize(SWT.DEFAULT, SWT.DEFAULT);
Point pt = grid.toDisplay(x, y);
onViewSourceFromContext = false;
}
}
-
+
private String getLibPath(GridItem item) {
DATableDataFormat tableData = (DATableDataFormat) item.getData();
String libName = null;
libName = item.getText(2);
break;
case AnalyzerConstants.TYPE_TABLE_FAILED:
- List<String> failedData = tableData.getData();
- libName = failedData.get(9);
+ List<Object> failedData = tableData.getData();
+ libName = (String) failedData.get(9);
break;
case AnalyzerConstants.TYPE_TABLE_LEAK:
- List<String> leakData = tableData.getData();
- libName = leakData.get(7);
+ List<Object> leakData = tableData.getData();
+ libName = (String) leakData.get(7);
break;
case AnalyzerConstants.TYPE_TABLE_WARNING:
ProbeCommonData pData = (ProbeCommonData) tableData.getLogData();
}
return false;
}
-
- private SourceLine getSourceLine(long addr, int pid, long time, String libName) {
- ProcessInfoPackage processInfoPkg = AnalyzerManager.getProject()
- .getProcessInfo(pid);
+
+ private SourceLine getSourceLine(long addr, int pid, long time,
+ String libName) {
+ ProcessInfoPackage processInfoPkg = AnalyzerManager.getProject()
+ .getProcessInfoPackage(pid);
ProcessInfo processInfo = processInfoPkg.getProcessInfo(time);
BinaryInfo binInfo = processInfo.getTargetBinary(addr);
if (binInfo == null) {
import org.tizen.dynamicanalyzer.common.path.PathManager;
import org.tizen.dynamicanalyzer.communicator.DACommunicator;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
+import org.tizen.dynamicanalyzer.database.SqlConnectionManager;
import org.tizen.dynamicanalyzer.handlers.ReplayTraceHandler;
import org.tizen.dynamicanalyzer.model.DeviceInfo;
import org.tizen.dynamicanalyzer.sql.SqlManager;
-import org.tizen.dynamicanalyzer.swap.channel.control.TargetInfo;
import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants;
import org.tizen.dynamicanalyzer.swap.channel.data.ProcessInfo;
import org.tizen.dynamicanalyzer.swap.channel.data.ProcessInfoPackage;
+import org.tizen.dynamicanalyzer.swap.logparser.DataManagerRegistry;
import org.tizen.dynamicanalyzer.swap.model.ByteUtils;
import org.tizen.dynamicanalyzer.swap.model.DATime;
import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
// public static final String TABLE_NAME = "project";
private static final String VERSION = "version";
+ private static final String PROTOCOL_VERSION = "protocolVersion";
private static final String DEVICE = "device";
private static final String PACKAGE_ID = "pakID";
private static final String APP_NAME = "appName";
private static final String MAIN_PID = "mainPID";
private final static int MAX_FILENAME_LENGTH = 50;
- private final String DEFAULT_TIME_FORMAT = "_yyyy-MM-dd-HH-mm-ss";//$NON-NLS-1$
+ private final static String DEFAULT_TIME_FORMAT = "_yyyy-MM-dd-HH-mm-ss";//$NON-NLS-1$
- private String version = null;
- private String device = null;
- private String pkgId = null;
- private String appName = null;
-
- private String createTime = null;
- private long lastTime = 0;
- private long stopTime = -1;
- private DATime profilingStartTime = new DATime();
-
- private long lastLogNum = 0;
- private long lastDeviceLogNum = 0;
- private long lastProfileLogNum = 0;
-
- private String savePath;
-
- private int mainPid = -1;
+ private long logCount_Total = 0;
+ private long logCount_System = 0;
+ private long logCount_Profile = 0;
private byte[] replayEvent = null;
- private HashMap<String, String> projextInfoFileHashMap = new HashMap<String, String>();
-
- private HashMap<Integer, ProcessInfoPackage> processInfoPackHash = new HashMap<Integer, ProcessInfoPackage>();
+ private HashMap<String, String> projectInfoMap = new HashMap<String, String>();
- public TargetInfo getTargetInfo() {
- TargetInfo targetInfo = DACommunicator.getSelectedDevice()
- .getTargetInfo();
- return targetInfo;
- }
+ private HashMap<Integer, ProcessInfoPackage> processInfoPackageMap = new HashMap<Integer, ProcessInfoPackage>();
- public void setTargetInfo(TargetInfo targetInfo) {
- DACommunicator.getSelectedDevice().setTargetInfo(targetInfo);
- }
-
- public ProcessInfoPackage getProcessInfo(int pid) {
- ProcessInfoPackage processInfoPkg = processInfoPackHash.get(pid);
- return processInfoPkg;
+ public ProcessInfoPackage getProcessInfoPackage(int pid) {
+ return processInfoPackageMap.get(pid);
}
public void setVersion(String ver) {
- this.version = ver;
+ projectInfoMap.put(VERSION, ver);
}
public String getVersion() {
- return this.version;
+ return projectInfoMap.get(VERSION);
}
public void setDevice(String dev) {
- this.device = dev;
+ projectInfoMap.put(DEVICE, dev);
}
public String getDevice() {
- return this.device;
+ return projectInfoMap.get(DEVICE);
}
public void setPkgId(String pkgId) {
- this.pkgId = pkgId;
+ projectInfoMap.put(PACKAGE_ID, pkgId);
}
public String getPkgId() {
- return this.pkgId;
+ return projectInfoMap.get(PACKAGE_ID);
}
public void setAppName(String name) {
- this.appName = name;
+ projectInfoMap.put(APP_NAME, name);
}
public String getAppName() {
- return this.appName;
+ return projectInfoMap.get(APP_NAME);
}
public void setCreateTime(String createTime) {
- this.createTime = createTime;
+ projectInfoMap.put(CREATE_TIME, createTime);
}
public String getCreateTime() {
- return this.createTime;
+ return projectInfoMap.get(CREATE_TIME);
}
public void setLastTime(long lastTime) {
- this.lastTime = lastTime;
+ projectInfoMap.put(LAST_TIME, Long.toString(lastTime));
}
public long getLastTime() {
- return this.lastTime;
+ String last_time = projectInfoMap.get(LAST_TIME);
+ if (last_time != null && !last_time.isEmpty())
+ return Long.parseLong(last_time);
+ else
+ return 0;
}
public void setStopTime(long time) {
- this.stopTime = time;
+ projectInfoMap.put(STOP_TIME, Long.toString(time));
}
public long getStopTime() {
- return this.stopTime;
+ String stoptime = projectInfoMap.get(STOP_TIME);
+ if (stoptime != null && !stoptime.isEmpty())
+ return Long.parseLong(stoptime);
+ else
+ return -1;
}
public void setProfileStartTime(DATime time) {
+ projectInfoMap.put(PROF_START_TIME, time.toString());
System.out.printf("profile starttime : %d\n", time.getSec());
- this.profilingStartTime = time;
}
public DATime getProfileStartTime() {
- return profilingStartTime;
+ String profstarttime = projectInfoMap.get(PROF_START_TIME);
+ if (profstarttime != null && !profstarttime.isEmpty())
+ return new DATime(profstarttime);
+ else
+ return new DATime();
}
+ // TODO (greatim) : last number means log count ? i don't think so
public void setLastLogNum(long last, int type) {
if (type == DataChannelConstants.MSG_DATA_SYSTEM) {
- if (last > lastDeviceLogNum) {
- setDeviceLogCount(last);
+ if (last > logCount_System) {
+ logCount_System = last;
}
} else if (type == DataChannelConstants.MSG_DATA_SAMPLE) {
- if (last > lastProfileLogNum) {
- setProfileLogCount(last);
+ if (last > logCount_Profile) {
+ logCount_Profile = last;
}
} else {
- if (last > lastLogNum) {
- setLogCount(last);
+ if (last > logCount_Total) {
+ logCount_Total = last;
}
}
}
- public void setLogCount(long count) {
- this.lastLogNum = count;
- }
-
public long getLogCount() {
- return this.lastLogNum;
- }
-
- public void setDeviceLogCount(long count) {
- this.lastDeviceLogNum = count;
+ return logCount_Total;
}
public long getDeviceLogCount() {
- return this.lastDeviceLogNum;
- }
-
- public void setProfileLogCount(long count) {
- this.lastProfileLogNum = count;
+ return logCount_System;
}
public long getProfileLogCount() {
- return this.lastProfileLogNum;
+ return logCount_Profile;
}
public void setSavePath(String path) {
- this.savePath = path;
+ projectInfoMap.put(SAVE_PATH, path);
}
public String getSavePath() {
- return this.savePath;
+ return projectInfoMap.get(SAVE_PATH);
}
public void setMainPid(int mainPid) {
- this.mainPid = mainPid;
+ projectInfoMap.put(MAIN_PID, Integer.toString(mainPid));
}
public int getMainPid() {
- return this.mainPid;
+ String mainpid = projectInfoMap.get(MAIN_PID);
+ if (mainpid != null && !mainpid.isEmpty())
+ return Integer.parseInt(mainpid);
+ else
+ return -1;
+ }
+
+ public double getProtocolVersion() {
+ String protocolVer = projectInfoMap.get(PROTOCOL_VERSION);
+ if (protocolVer != null && !protocolVer.isEmpty())
+ return Double.parseDouble(protocolVer);
+ else
+ return 0;
+ }
+
+ public void setProtocolVersion(double protocolVersion) {
+ projectInfoMap.put(PROTOCOL_VERSION, Double.toString(protocolVersion));
}
public void setCoreCount(int count) {
- getTargetInfo().setCpuCount(count);
+ DACommunicator.getSelectedDevice().getTargetInfo().setCpuCount(count);
}
public int getCoreCount() {
- return getTargetInfo().getCpuCount();
+ return DACommunicator.getSelectedDevice().getTargetInfo().getCpuCount();
}
public int getMaxBrightness() {
- return getTargetInfo().getMaxBrightness();
+ return DACommunicator.getSelectedDevice().getTargetInfo()
+ .getMaxBrightness();
}
public long getSystemMemorySize() {
- return getTargetInfo().getSystemMemorySize();
+ return DACommunicator.getSelectedDevice().getTargetInfo()
+ .getSystemMemorySize();
}
// for save
AnalyzerManager.setProject(this);
+ // establish database connection
+ boolean conn_res = SqlConnectionManager
+ .establishConnection(getSavePath() + File.separator
+ + AnalyzerConstants.DATABASE_NAME);
+
// create table
+ DataManagerRegistry.createDBTables();
SqlManager.getInstance().createTables();
SqlManager.getInstance().createProbeTable();
}
public long getBaseAddress(int pid, long time) {
- ProcessInfoPackage pInfoPack = processInfoPackHash.get(pid);
+ ProcessInfoPackage pInfoPack = processInfoPackageMap.get(pid);
ProcessInfo processInfo = pInfoPack.getProcessInfo(time);
return processInfo.getLowestAddress();
}
public long getHighestAddress(int pid, long time) {
- ProcessInfoPackage pInfoPack = processInfoPackHash.get(pid);
+ ProcessInfoPackage pInfoPack = processInfoPackageMap.get(pid);
ProcessInfo processInfo = pInfoPack.getProcessInfo(time);
return processInfo.getHighestAddress();
}
}
public HashMap<Integer, ProcessInfoPackage> getProcessInfoPackHash() {
- return processInfoPackHash;
+ return processInfoPackageMap;
}
public void loadSaveFormat(List<String> data) {
setStopTime(Long.parseLong(data
.get(AnalyzerConstants.PROJECT_STOP_TIME_INDEX)));
DATime profilingStartTime = new DATime();
- profilingStartTime.loadSaveFormat(data
+ profilingStartTime.fromString(data
.get(AnalyzerConstants.PROJECT_PROF_START_TIME_INDEX));
setProfileStartTime(profilingStartTime);
- setLogCount(Long.parseLong(data
- .get(AnalyzerConstants.PROJECT_LOG_COUNT_INDEX)));
- setDeviceLogCount(Long.parseLong(data
- .get(AnalyzerConstants.PROJECT_SYSTEM_COUNT_INDEX)));
- setProfileLogCount(Long.parseLong(data
- .get(AnalyzerConstants.PROJECT_PROFILE_COUNT_INDEX)));
+
+ logCount_Total = Long.parseLong(data
+ .get(AnalyzerConstants.PROJECT_LOG_COUNT_INDEX));
+ logCount_System = Long.parseLong(data
+ .get(AnalyzerConstants.PROJECT_SYSTEM_COUNT_INDEX));
+ logCount_Profile = Long.parseLong(data
+ .get(AnalyzerConstants.PROJECT_PROFILE_COUNT_INDEX));
setMainPid(Integer.parseInt(data
.get(AnalyzerConstants.PROJECT_MAIN_PID_INDEX)));
}
projectInfoDBList.add(getCreateTime());
projectInfoDBList.add(Long.toString(getLastTime()));
projectInfoDBList.add(Long.toString(getStopTime()));
- projectInfoDBList.add(getProfileStartTime().getSaveFormat());
+ projectInfoDBList.add(getProfileStartTime().toString());
projectInfoDBList.add(Long.toString(getLogCount()));
projectInfoDBList.add(Long.toString(getDeviceLogCount()));
projectInfoDBList.add(Long.toString(getProfileLogCount()));
projectInfoDBList.add(getSavePath());
projectInfoDBList.add(Integer.toString(getMainPid()));
- projextInfoFileHashMap.put(VERSION, getVersion());
- projextInfoFileHashMap.put(DEVICE, getDevice());
- projextInfoFileHashMap.put(PACKAGE_ID, getPkgId());
- projextInfoFileHashMap.put(APP_NAME, getAppName());
- projextInfoFileHashMap.put(CREATE_TIME, getCreateTime());
- projextInfoFileHashMap.put(LAST_TIME, Long.toString(getLastTime()));
- projextInfoFileHashMap.put(STOP_TIME, Long.toString(getStopTime()));
- projextInfoFileHashMap.put(PROF_START_TIME, getProfileStartTime()
- .getSaveFormat());
- projextInfoFileHashMap.put(LOG_COUNT, Long.toString(getLogCount()));
- projextInfoFileHashMap.put(SYSTEM_COUNT,
- Long.toString(getDeviceLogCount()));
- projextInfoFileHashMap.put(PROFILE_COUNT,
- Long.toString(getProfileLogCount()));
- projextInfoFileHashMap.put(SAVE_PATH, getSavePath());
- projextInfoFileHashMap.put(MAIN_PID, Integer.toString(getMainPid()));
+ projectInfoMap.put(LOG_COUNT, Long.toString(getLogCount()));
+ projectInfoMap.put(SYSTEM_COUNT, Long.toString(getDeviceLogCount()));
+ projectInfoMap.put(PROFILE_COUNT, Long.toString(getProfileLogCount()));
+
return projectInfoDBList;
}
if (null == project || !project.isValid()) {
System.out.println("project not saved");
} else {
- projectInfoFilePath = PathManager.getProjectInfoPath(project.getSavePath());
+ projectInfoFilePath = PathManager.getProjectInfoPath(project
+ .getSavePath());
}
File configFile = new File(projectInfoFilePath);
buffWriter = new BufferedWriter(fileWriter);
printWriter = new PrintWriter(buffWriter);
- Iterator<String> iter = projextInfoFileHashMap.keySet().iterator();
+ Iterator<String> iter = projectInfoMap.keySet().iterator();
while (iter.hasNext()) {
String key = (String) iter.next();
- String val = projextInfoFileHashMap.get(key);
+ String val = projectInfoMap.get(key);
printWriter.println(key + CommonConstants.EQUAL + val);
printWriter.checkError();
}
setStopTime(Long.parseLong(val));
} else if (infoKey.equals(PROF_START_TIME)) {
DATime profilingStartTime = new DATime();
- profilingStartTime.loadSaveFormat(val);
+ profilingStartTime.fromString(val);
setProfileStartTime(profilingStartTime);
} else if (infoKey.equals(LOG_COUNT)) {
- setLogCount(Long.parseLong(val));
+ logCount_Total = Long.parseLong(val);
} else if (infoKey.equals(SYSTEM_COUNT)) {
- setDeviceLogCount(Long.parseLong(val));
+ logCount_System = Long.parseLong(val);
} else if (infoKey.equals(PROFILE_COUNT)) {
- setProfileLogCount(Long.parseLong(val));
+ logCount_Profile = Long.parseLong(val);
} else if (infoKey.equals(SAVE_PATH)) {
setSavePath(val);
} else if (infoKey.equals(MAIN_PID)) {
protected String getColumnString(int index) {
if (columnNames.length <= index) {
return null;
+ } else {
+ return columnNames[index] + CommonConstants.SPACE
+ + columnTypes[index] + CommonConstants.SPACE
+ + columnOptions[index];
}
- return columnNames[index] + CommonConstants.SPACE + columnTypes[index]
- + CommonConstants.SPACE + columnOptions[index];
}
public String getTableName() {
for (int i = 0; i < columnNames.length; i++) {
strBuffer.append(getColumnString(i));
- if (i + 1 == columnNames.length) {
+ if (i == columnNames.length - 1) {
strBuffer.append(CommonConstants.CLOSE_BRACKET);
} else {
strBuffer.append(CommonConstants.COMMA);
}
}
strBuffer.append(CommonConstants.SEMICOLON);
+
return strBuffer.toString();
+ } else {
+ return null;
}
- return null;
}
public String selectAllQuery() {
strBuffer.append("select "); //$NON-NLS-1$
for (int i = 0; i < columnNames.length; i++) {
strBuffer.append(columnNames[i]);
- if (i + 1 != columnNames.length) {
+ if (i != columnNames.length - 1) {
strBuffer.append(CommonConstants.COMMA);
}
}
strBuffer.append(" from ");//$NON-NLS-1$
strBuffer.append(tableName);
strBuffer.append(CommonConstants.SEMICOLON);
+
return strBuffer.toString();
+ } else {
+ return null;
}
- return null;
}
public String insertQuery() {
for (int i = 0; i < columnNames.length; i++) {
strBuffer.append("?"); //$NON-NLS-1$
- if (i + 1 == columnNames.length) {
+ if (i == columnNames.length - 1) {
strBuffer.append(");"); //$NON-NLS-1$
break;
} else {
strBuffer.append(","); //$NON-NLS-1$
}
}
+
return strBuffer.toString();
+ } else {
+ return null;
}
- return null;
}
protected boolean isValid() {
|| columnNames.length != columnTypes.length) {
return false;
}
+
return true;
}
public void setColumnTypes(String[] columnTypes) {
this.columnTypes = columnTypes;
}
-
- public String getQuestionMarks() {
- StringBuffer questionMarks = new StringBuffer();
- for (int i = 0; i < columnNames.length; i++) {
- questionMarks.append(CommonConstants.QUESION_MARK);
- if (i + 1 != columnNames.length) {
- questionMarks.append(CommonConstants.COMMA);
- }
- }
- return questionMarks.toString();
- }
}
// tableInfos.set(TABLE_INDEX_GLES20_CHANGE_INFO,
// Gles20ChangeInfoTableInfo);
}
-
+/*
// context switch data
{
String[] names = { COMMON_COLUMN_SEQ_NUMBER, COMMON_COLUMN_PID,
TABLE_NAME_FUNCTION_CALL_DATA, names, options, types);
tableInfos.set(TABLE_INDEX_FUNCTION_CALL_DATA, funcCallInfo);
}
+*/
}
public DBTableInfo getTableInfo(int tableInfoIndex) {
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.communicator.DACommunicator;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
import org.tizen.dynamicanalyzer.project.Project;
}
}
- System.out.println("dddd : "+ query.toString());
+ System.out.println("dddd : " + query.toString());
return query.toString();
}
logData.makePreparedStatement(prep);
if (logData.getId() == DataChannelConstants.MSG_FUNCTION_ENTRY) {
ProcessInfoPackage processInfoPkg = AnalyzerManager
- .getProject().getProcessInfo(logData.getPid());
+ .getProject().getProcessInfoPackage(
+ logData.getPid());
processInfoPkg.addFunctionEntryInsertLogCount();
}
public void insertProject() {
DBTableInfo info = DBTableManager.getInstance().getTableInfo(
DBTableManager.TABLE_INDEX_PROJECT);
- String insertQuery = "insert into " + info.getTableName() + " values ( " + info.getQuestionMarks() + " );"; //$NON-NLS-1$
+ String insertQuery = info.insertQuery();
+ if (insertQuery != null) {
+ Project project = AnalyzerManager.getProject();
- Project project = AnalyzerManager.getProject();
-
- List<String> insetRowData = project.makeSaveProjectInfo();
- ;
- List<List<String>> insetData = new ArrayList<List<String>>();
- insetData.add(insetRowData);
+ List<String> insetRowData = project.makeSaveProjectInfo();
+ List<List<String>> insetData = new ArrayList<List<String>>();
+ insetData.add(insetRowData);
- insertQuery(insertQuery, insetData);
+ insertQuery(insertQuery, insetData);
+ } else {
+ System.out.println("[ERR] insert project info failed!!");
+ }
}
public void insertTargetInfo() {
DBTableInfo info = DBTableManager.getInstance().getTableInfo(
DBTableManager.TABLE_INDEX_TARGET_INFO);
- String insertQuery = "insert into " + info.getTableName() + " values ( " + info.getQuestionMarks() + " );"; //$NON-NLS-1$
-
- TargetInfo targetInfo = AnalyzerManager.getProject().getTargetInfo();
- List<String> insetRowData = new ArrayList<String>();
+ String insertQuery = info.insertQuery();
+ if (insertQuery != null) {
+ TargetInfo targetInfo = DACommunicator.getSelectedDevice()
+ .getTargetInfo();
+ List<String> insetRowData = new ArrayList<String>();
- insetRowData.add(Long.toString(targetInfo.getSystemMemorySize()));
- insetRowData.add(Long.toString(targetInfo.getStorageSize()));
- insetRowData.add(Integer.toString(targetInfo.getBluetoothSupport()));
- insetRowData.add(Integer.toString(targetInfo.getGpsSupport()));
- insetRowData.add(Integer.toString(targetInfo.getWifiSupport()));
- insetRowData.add(Integer.toString(targetInfo.getCameraCount()));
- insetRowData.add(targetInfo.getNetworkType());
- insetRowData.add(Integer.toString(targetInfo.getMaxBrightness()));
- insetRowData.add(Integer.toString(targetInfo.getCpuCount()));
- insetRowData.add(Integer.toString(targetInfo.getDeviceCount()));
- insetRowData.add(targetInfo.getDevices());
+ insetRowData.add(Long.toString(targetInfo.getSystemMemorySize()));
+ insetRowData.add(Long.toString(targetInfo.getStorageSize()));
+ insetRowData
+ .add(Integer.toString(targetInfo.getBluetoothSupport()));
+ insetRowData.add(Integer.toString(targetInfo.getGpsSupport()));
+ insetRowData.add(Integer.toString(targetInfo.getWifiSupport()));
+ insetRowData.add(Integer.toString(targetInfo.getCameraCount()));
+ insetRowData.add(targetInfo.getNetworkType());
+ insetRowData.add(Integer.toString(targetInfo.getMaxBrightness()));
+ insetRowData.add(Integer.toString(targetInfo.getCpuCount()));
+ insetRowData.add(Integer.toString(targetInfo.getDeviceCount()));
+ insetRowData.add(targetInfo.getDevices());
- List<List<String>> insetData = new ArrayList<List<String>>();
- insetData.add(insetRowData);
+ List<List<String>> insetData = new ArrayList<List<String>>();
+ insetData.add(insetRowData);
- insertQuery(insertQuery, insetData);
+ insertQuery(insertQuery, insetData);
+ } else {
+ System.out.println("[ERR] insert target info failed!!");
+ }
}
public void insertProcessInfo() {
pInfoPackList.addAll(AnalyzerManager.getProject()
.getProcessInfoPackHash().values());
- for (ProcessInfoPackage pip : pInfoPackList) {
- List<ProcessInfo> processInfoList = pip.getProcessSnapshots();
- String insertQuery = "insert into " + info.getTableName() + " values (" + info.getQuestionMarks() + ");"; //$NON-NLS-1$
-
- for (int i = 0; i < processInfoList.size(); i++) {
- ProcessInfo pInfo = processInfoList.get(i);
- List<String> insertRowData = new ArrayList<String>();
- insertRowData.add(Integer.toString(pInfo.getPid()));
- insertRowData.add(pInfo.getSaveFormat());
- List<List<String>> insetData = new ArrayList<List<String>>();
- insetData.add(insertRowData);
-
- insertQuery(insertQuery, insetData);
- insertLibObj(pInfo);
+ String insertQuery = info.insertQuery();
+ if (insertQuery != null) {
+ for (ProcessInfoPackage pip : pInfoPackList) {
+ List<ProcessInfo> processInfoList = pip.getProcessSnapshots();
+
+ for (int i = 0; i < processInfoList.size(); i++) {
+ ProcessInfo pInfo = processInfoList.get(i);
+ List<String> insertRowData = new ArrayList<String>();
+ insertRowData.add(Integer.toString(pInfo.getPid()));
+ insertRowData.add(pInfo.getSaveFormat());
+ List<List<String>> insetData = new ArrayList<List<String>>();
+ insetData.add(insertRowData);
+
+ insertQuery(insertQuery, insetData);
+ insertLibObj(pInfo);
+ }
}
+ } else {
+ System.out.println("[ERR] insert process info failed!!");
}
}
List<LibraryObject> libs = pInfo.getLibObjs();
DBTableInfo info = DBTableManager.getInstance().getTableInfo(
DBTableManager.TABLE_INDEX_LIB_OBJ);
- String insertQuery = "insert into " + info.getTableName() + " values (" + info.getQuestionMarks() + ");"; //$NON-NLS-1$
- String pid = Integer.toString(pInfo.getPid());
- String time = pInfo.getStartTime().getSaveFormat();
- List<List<String>> insetData = new ArrayList<List<String>>();
- for (LibraryObject lib : libs) {
- List<String> insertRowData = new ArrayList<String>();
- insertRowData.add(pid);
- insertRowData.add(time);
- insertRowData.add(Long.toString(lib.getLowestAddress()));
- insertRowData.add(Long.toString(lib.getHighestAddress()));
- insertRowData.add(lib.getLibPath());
- insetData.add(insertRowData);
- }
+ String insertQuery = info.insertQuery();
+ if (insertQuery != null) {
+ String pid = Integer.toString(pInfo.getPid());
+ String time = pInfo.getStartTime().toString();
+ List<List<String>> insetData = new ArrayList<List<String>>();
+ for (LibraryObject lib : libs) {
+ List<String> insertRowData = new ArrayList<String>();
+ insertRowData.add(pid);
+ insertRowData.add(time);
+ insertRowData.add(Long.toString(lib.getLowestAddress()));
+ insertRowData.add(Long.toString(lib.getHighestAddress()));
+ insertRowData.add(lib.getLibPath());
+ insetData.add(insertRowData);
+ }
- insertQuery(insertQuery, insetData);
+ insertQuery(insertQuery, insetData);
+ } else {
+ System.out.println("[ERR] insert library object failed!!");
+ }
}
public boolean insertQuery(String query, List<List<String>> input) {
prep.setString(j + 1, rowData.get(j));
}
prep.addBatch();
-
+
}
if (dataRowSize > 0) {
conn.setAutoCommit(false);
stat = conn.createStatement();
String query = String.format("delete from replay");//$NON-NLS-1$
StringBuffer queryBuffer = new StringBuffer(query);
-// for (int i = 0; i < input.size(); i++) {
-// if (i == 0) {
-// queryBuffer.append(" where ");
-// }
-// queryBuffer.append(" rid = ").append(input.get(i));
-// if (i < input.size() - 1) {
-// queryBuffer.append(" or ");
-// }
-// }
+ // for (int i = 0; i < input.size(); i++) {
+ // if (i == 0) {
+ // queryBuffer.append(" where ");
+ // }
+ // queryBuffer.append(" rid = ").append(input.get(i));
+ // if (i < input.size() - 1) {
+ // queryBuffer.append(" or ");
+ // }
+ // }
if (isQueryPrint) {
System.out.println("query : " + queryBuffer.toString());
}
public String getUserFunctionPosition(int pid, long time) {
ProcessInfoPackage processInfoPkg = AnalyzerManager
- .getProject().getProcessInfo(pid);
+ .getProject().getProcessInfoPackage(pid);
ProcessInfo processInfo = processInfoPkg.getProcessInfo(time);
return processInfo.getMainTargetBinaryPath();
String apiName = log.getApiName();
if (apiName.equals("OspMain")) { //$NON-NLS-1$
ProcessInfoPackage processInfoPkg = AnalyzerManager
- .getProject().getProcessInfo(log.getPid());
+ .getProject().getProcessInfoPackage(log.getPid());
// SWAPLogParser.setDropCallTraceLog(true);
processInfoPkg.setDropLog(true);
}
public boolean isAddrInBinaryRange(int pid, long time, long addr) {
ProcessInfoPackage processInfoPkg = AnalyzerManager.getProject()
- .getProcessInfo(pid);
+ .getProcessInfoPackage(pid);
ProcessInfo processInfo = processInfoPkg.getProcessInfo(time);
if (null == processInfo) {
return false;
public boolean isPieBuild(int pid, long time) {
ProcessInfoPackage processInfoPkg = AnalyzerManager.getProject()
- .getProcessInfo(pid);
+ .getProcessInfoPackage(pid);
ProcessInfo processInfo = processInfoPkg.getProcessInfo(time);
if (null == processInfo) {
return false;
StringBuffer saveFormat = new StringBuffer();
saveFormat.append(pid).append(CommonConstants.CMD_SPLIT);
saveFormat.append(ppid).append(CommonConstants.CMD_SPLIT);
- saveFormat.append(startTime.getSaveFormat()).append(
+ saveFormat.append(startTime.toString()).append(
CommonConstants.CMD_SPLIT);
saveFormat.append(lowestAddress).append(CommonConstants.CMD_SPLIT);
saveFormat.append(highestAddress).append(CommonConstants.CMD_SPLIT);
String[] splitData = saveData.split("\\|");
pid = Integer.parseInt(splitData[0]);
ppid = Integer.parseInt(splitData[1]);
- startTime.loadSaveFormat(new String(splitData[2]));
+ startTime.fromString(new String(splitData[2]));
lowestAddress = Long.parseLong(splitData[3]);
highestAddress = Long.parseLong(splitData[4]);
targetBinaryPath = new String(splitData[5]);
package org.tizen.dynamicanalyzer.swap.logparser;
import java.util.HashMap;
+import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
+import org.tizen.dynamicanalyzer.database.DBTable;
+
public class DataManagerRegistry {
private static HashMap<String, PageDataManager> dataManagers = null;
if (ret)
break;
}
-
+
return ret;
}
entry.getValue().updateLog(pack);
}
}
+
+ public static void createDBTables() {
+ for (Map.Entry<String, PageDataManager> entry : dataManagers.entrySet()) {
+ List<DBTable> tables = entry.getValue().getDBTableList();
+ int size = tables.size();
+ for (int i = 0; i < size; i++) {
+ tables.get(i).createTable();
+ }
+ }
+ }
}
+ AnalyzerUtil.toHexdecimal(id) + " libPath : " + libPath
+ " low : " + AnalyzerUtil.toHexdecimal(lowAddr)
+ " high: " + AnalyzerUtil.toHexdecimal(highAddr)
- + " chage time : " + changeTime.getSaveFormat()
+ + " chage time : " + changeTime.toString()
+ " total count : " + pInfo.getLibObjs().size());
} else {
System.out.println("MAP CHANGED REMOVE "
+ AnalyzerUtil.toHexdecimal(id) + " libPath : " + libPath
+ " low : " + AnalyzerUtil.toHexdecimal(lowAddr)
+ " high: " + AnalyzerUtil.toHexdecimal(highAddr)
- + " chage time : " + changeTime.getSaveFormat()
+ + " chage time : " + changeTime.toString()
+ " total count : " + pInfo.getDepLibCount());
int size = libObjs.size();
package org.tizen.dynamicanalyzer.swap.logparser;
+import java.util.ArrayList;
+import java.util.List;
+
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.database.DBTable;
public abstract class PageDataManager implements Runnable {
private String name = null;
private Thread thread = null;
private ReadBlockingQueue<LogPackage> logPackQueue = new ReadBlockingQueue<LogPackage>();
+ private List<DBTable> dbTableList = new ArrayList<DBTable>();
public final String getName() {
if (name == null) {
protected final LogPackage pollPack() {
return logPackQueue.poll();
}
-
+
+ protected final void addDBTable(DBTable table) {
+ dbTableList.add(table);
+ }
+
+ public final List<DBTable> getDBTableList() {
+ return dbTableList;
+ }
+
public final void startThread() {
if (thread == null || !thread.isAlive()) {
thread = new Thread(null, this, getName());
protected void sendNotify() {
logPackQueue.wake();
}
+
}
long pcAddr = pData.getPcAddr();
ProcessInfoPackage processInfoPkg = AnalyzerManager
- .getProject().getProcessInfo(pData.getPid());
+ .getProject().getProcessInfoPackage(pData.getPid());
String apiName = pData.getApiName();
if (null == apiName || apiName.isEmpty()
// String functionName = null;
ProcessInfoPackage processInfoPkg = AnalyzerManager.getProject()
- .getProcessInfo(input.getPid());
+ .getProcessInfoPackage(input.getPid());
ProcessInfo processInfo = processInfoPkg
.getProcessInfo(input.getTime());
import org.tizen.dynamicanalyzer.constant.CommonConstants;
public class DATime {
- private int sec = 0;
- private int nano = 0;
+ private int sec;
+ private int nano;
+
+ public DATime() {
+ sec = 0;
+ nano = 0;
+ }
+
+ public DATime(String timestring) {
+ fromString(timestring);
+ }
public int getSec() {
return sec;
return ByteUtils.getByte(sec, nano);
}
- public String getSaveFormat() {
+ @Override
+ public String toString() {
return Integer.toString(sec) + CommonConstants.DASH
+ Integer.toString(nano);
}
- public void loadSaveFormat(String saveData) {
+ public void fromString(String saveData) {
String[] splitData = saveData.split(CommonConstants.DASH);
sec = Integer.parseInt(splitData[0]);
nano = Integer.parseInt(splitData[1]);
public long getLongTime() {
long ret = 0;
- long secLong = sec* 1000000;
- long nanoLong = nano/1000;
+ long secLong = sec * 1000000;
+ long nanoLong = nano / 1000;
ret = secLong + nanoLong;
return ret;
}
System.out.println("id : " + AnalyzerUtil.toHexdecimal(id)
+ " time : " + time);
System.out.println("profile start time : "
- + startTime.getSaveFormat() + " time : " + sec + ","
+ + startTime.toString() + " time : " + sec + ","
+ nano);
}
index += INT_SIZE;
ProcessInfoPackage processInfoPkg = AnalyzerManager.getProject()
- .getProcessInfo(pid);
+ .getProcessInfoPackage(pid);
if (time > 0) {
ProcessInfo processInfo = processInfoPkg.getProcessInfo(time);
}
ProcessInfoPackage processInfoPkg = AnalyzerManager.getProject()
- .getProcessInfo(pid);
+ .getProcessInfoPackage(pid);
if (time > 0) {
ProcessInfo processInfo = processInfoPkg.getProcessInfo(time);
BinaryInfo binInfo = processInfo.getTargetBinary(pcAddr);
long time = -1;
String libName = null;
if (tableData.getType() == AnalyzerConstants.TYPE_TABLE_FAILED) {
- List<String> failedData = tableData.getData();
- seqNum = Integer.parseInt(failedData.get(0));
+ List<Object> failedData = tableData.getData();
+ seqNum = (Integer) failedData.get(0);
// addr = Long.parseLong(failedData.get(8));
- pid = Integer.parseInt(failedData.get(7));
- time = Long.parseLong(failedData.get(1));
- libName = failedData.get(9);
+ pid = (Integer) failedData.get(7);
+ time = (Long) failedData.get(1);
+ libName = (String) failedData.get(9);
} else if (tableData.getType() == AnalyzerConstants.TYPE_TABLE_LEAK) {
- List<String> leakData = tableData.getData();
- seqNum = Integer.parseInt(leakData.get(2));
+ List<Object> leakData = tableData.getData();
+ seqNum = (Integer) leakData.get(2);
// addr = Long.parseLong(leakData.get(9));
- pid = Integer.parseInt(leakData.get(1));
- time = Long.parseLong(leakData.get(4));
- libName = leakData.get(7);
+ pid = (Integer) leakData.get(1);
+ time = (Long) leakData.get(4);
+ libName = (String) leakData.get(7);
} else {
LogData logData = tableData.getLogData();
seqNum = logData.getSeq();
DATableDataFormat tableData = (DATableDataFormat) selection[0]
.getData();
if (tableData.getType() == AnalyzerConstants.TYPE_TABLE_FAILED) {
- List<String> failedData = tableData.getData();
- startTime = Long.parseLong(failedData.get(1));
+ List<Object> failedData = tableData.getData();
+ startTime = (Long) failedData.get(1);
} else if (tableData.getType() == AnalyzerConstants.TYPE_TABLE_LEAK) {
- List<String> leakData = tableData.getData();
- startTime = Long.parseLong(leakData.get(4));
+ List<Object> leakData = tableData.getData();
+ startTime = (Long) leakData.get(4);
} else {
LogData startData = ((DATableDataFormat) selection[0]
.getData()).getLogData();
DATableDataFormat lastTableData = (DATableDataFormat) selection[0]
.getData();
if (lastTableData.getType() == AnalyzerConstants.TYPE_TABLE_FAILED) {
- List<String> failedData = tableData.getData();
- endTime = Long.parseLong(failedData.get(1));
+ List<Object> failedData = tableData.getData();
+ endTime = (Long) failedData.get(1);
} else if (lastTableData.getType() == AnalyzerConstants.TYPE_TABLE_LEAK) {
- List<String> leakData = tableData.getData();
- endTime = Long.parseLong(leakData.get(4));
+ List<Object> leakData = tableData.getData();
+ endTime = (Long) leakData.get(4);
} else {
LogData endData = ((DATableDataFormat) selection[selection.length - 1]
.getData()).getLogData();
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.kernel.data.FunctionDataDBTable;
import org.tizen.dynamicanalyzer.ui.kernel.data.KernelDataMaker;
+import org.tizen.dynamicanalyzer.ui.kernel.data.KernelDataManager;
import org.tizen.dynamicanalyzer.ui.kernel.data.KernelDataPerThread;
import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants;
import org.tizen.dynamicanalyzer.widgets.chart.DAChart;
public class CallFlowChart extends DAChartBoard {
private KernelDataPerThread selectedData = null;
private boolean dirty = false;
- private final KernelDataMaker dataMaker = KernelDataMaker.getInstance();
+ private final KernelDataMaker dataMaker = KernelDataManager.getInstance()
+ .getDataMaker();
private HashMap<String, DAChartSeries> seriesMap = null;
public CallFlowChart(Composite parent, String title) {
public void updateChart() {
// remove all previous items
- if(dirty) {
+ if (dirty) {
itemListClear();
if (seriesMap != null) {
seriesMap.clear();
update();
return;
}
-
- if(dirty) {
+
+ if (dirty) {
// get data from db
- List<List<String>> funcnames = dataMaker.getFuncnameFromDB(selectedData
- .getTid());
+ List<List<Object>> funcnames = dataMaker
+ .getFuncnameFromDB(selectedData.getTid());
int fsize = funcnames.size();
-
+
// create board item for these functions
DAChartBoardHeightChangeableItem funcItem = new DAChartBoardHeightChangeableItem(
this, KernelPageLabels.CALL_FLOW_BOARD_NAME_TID + " "
+ selectedData.getTid());
initCallflowChart(funcItem, fsize);
-
+
seriesMap = new HashMap<String, DAChartSeries>(fsize * 2);
DAChart funcChart = funcItem.getChart();
for (int i = 0; i < fsize; i++) {
- String funcname = funcnames.get(i).get(0);
+ String funcname = (String) funcnames.get(i).get(0);
DAChartSeries funcseries = new DAChartSeries(funcname, -1,
ColorResources.RED, true);
funcChart.addSeries(funcseries);
funcseries.setData(new Integer(i));
seriesMap.put(funcname, funcseries);
}
-
+
dirty = false;
}
long starttime = (long) (getVisibleStartTime() * TimelineConstants.MEGA_DOUBLE);
long endtime = (long) (getVisibleEndTime() * TimelineConstants.MEGA_DOUBLE);
- List<List<String>> functionData = dataMaker.getFunctionDataFromDB(
+ List<List<Object>> functionData = dataMaker.getFunctionDataFromDB(
starttime, endtime, selectedData.getTid());
if (functionData == null || functionData.isEmpty()) {
return;
int prevSeriesNum = -1;
for (int i = 0; i < fsize; i++) {
- List<String> idata = functionData.get(i);
- String funcname = idata
- .get(KernelDataMaker.FUNCTION_DATA_COLUMN_INDEX_FUNCNAME);
- double funcStart = (double) (Long.parseLong(idata
- .get(KernelDataMaker.FUNCTION_DATA_COLUMN_INDEX_STARTTIME)))
+ List<Object> idata = functionData.get(i);
+ String funcname = (String) idata
+ .get(FunctionDataDBTable.COLUMN_INDEX_FUNCNAME);
+ double funcStart = (double) ((Long) idata
+ .get(FunctionDataDBTable.COLUMN_INDEX_STARTTIME))
/ TimelineConstants.MEGA_DOUBLE;
- double funcEnd = (double) (Long.parseLong(idata
- .get(KernelDataMaker.FUNCTION_DATA_COLUMN_INDEX_ENDTIME)))
+ double funcEnd = (double) ((Long) idata
+ .get(FunctionDataDBTable.COLUMN_INDEX_ENDTIME))
/ TimelineConstants.MEGA_DOUBLE;
DAChartSeries funcSeries = seriesMap.get(funcname);
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.kernel.data.ContextDataDBTable;
+import org.tizen.dynamicanalyzer.ui.kernel.data.FunctionDataDBTable;
import org.tizen.dynamicanalyzer.ui.kernel.data.KernelDataMaker;
+import org.tizen.dynamicanalyzer.ui.kernel.data.KernelDataManager;
import org.tizen.dynamicanalyzer.ui.kernel.data.KernelDataPerThread;
import org.tizen.dynamicanalyzer.ui.kernel.data.KernelDataPerThreadComparator;
import org.tizen.dynamicanalyzer.ui.kernel.data.KernelSelectionData;
public class ContextSwitchingChart extends DAChartBoard {
public static final String KERNEL_CHART_DATA_TYPE = "kernel_data_type";
- private final KernelDataMaker dataMaker = KernelDataMaker.getInstance();
+ private final KernelDataMaker dataMaker = KernelDataManager.getInstance()
+ .getDataMaker();
private int savedSelectedPid = 0;
long starttime = (long) (getVisibleStartTime() * TimelineConstants.MEGA_DOUBLE);
long endtime = (long) (getVisibleEndTime() * TimelineConstants.MEGA_DOUBLE);
- List<List<String>> contextData = dataMaker.getContextDataFromDB(
+ List<List<Object>> contextData = dataMaker.getContextDataFromDB(
starttime, endtime);
- List<List<String>> functionData = dataMaker.getFunctionDataFromDB(
+ List<List<Object>> functionData = dataMaker.getFunctionDataFromDB(
starttime, endtime, -1);
if (contextData != null) {
int csize = contextData.size();
for (int i = 0; i < csize; i++) {
- List<String> idata = contextData.get(i);
- int tid = Integer.parseInt(idata
- .get(KernelDataMaker.CONTEXT_DATA_COLUMN_INDEX_TID));
- int cpunum = Integer.parseInt(idata
- .get(KernelDataMaker.CONTEXT_DATA_COLUMN_INDEX_CPU));
- double contextStart = (double) (Long
- .parseLong(idata
- .get(KernelDataMaker.CONTEXT_DATA_COLUMN_INDEX_STARTTIME)))
+ List<Object> idata = contextData.get(i);
+ int tid = (Integer) idata
+ .get(ContextDataDBTable.COLUMN_INDEX_TID);
+ int cpunum = (Integer) idata
+ .get(ContextDataDBTable.COLUMN_INDEX_CPU);
+ double contextStart = (double) ((Long) idata
+ .get(ContextDataDBTable.COLUMN_INDEX_STARTTIME))
/ TimelineConstants.MEGA_DOUBLE;
- double contextEnd = (double) (Long
- .parseLong(idata
- .get(KernelDataMaker.CONTEXT_DATA_COLUMN_INDEX_ENDTIME)))
+ double contextEnd = (double) ((Long) idata
+ .get(ContextDataDBTable.COLUMN_INDEX_ENDTIME))
/ TimelineConstants.MEGA_DOUBLE;
DAChartBoardItem coreItem = findCoreBoardItem(threads, tid);
if (functionData != null) {
int fsize = functionData.size();
for (int i = 0; i < fsize; i++) {
- List<String> idata = functionData.get(i);
- int tid = Integer.parseInt(idata
- .get(KernelDataMaker.FUNCTION_DATA_COLUMN_INDEX_TID));
- String funcname = idata
- .get(KernelDataMaker.FUNCTION_DATA_COLUMN_INDEX_FUNCNAME);
- double funcStart = (double) (Long
- .parseLong(idata
- .get(KernelDataMaker.FUNCTION_DATA_COLUMN_INDEX_STARTTIME)))
+ List<Object> idata = functionData.get(i);
+ int tid = (Integer) idata
+ .get(FunctionDataDBTable.COLUMN_INDEX_TID);
+ String funcname = (String) idata
+ .get(FunctionDataDBTable.COLUMN_INDEX_FUNCNAME);
+ double funcStart = (double) ((Long) idata
+ .get(FunctionDataDBTable.COLUMN_INDEX_STARTTIME))
/ TimelineConstants.MEGA_DOUBLE;
- double funcEnd = (double) (Long
- .parseLong(idata
- .get(KernelDataMaker.FUNCTION_DATA_COLUMN_INDEX_ENDTIME)))
+ double funcEnd = (double) ((Long) idata
+ .get(FunctionDataDBTable.COLUMN_INDEX_ENDTIME))
/ TimelineConstants.MEGA_DOUBLE;
- int type = Integer
- .parseInt(idata
- .get(KernelDataMaker.FUNCTION_DATA_COLUMN_INDEX_STARTTYPE))
- + Integer
- .parseInt(idata
- .get(KernelDataMaker.FUNCTION_DATA_COLUMN_INDEX_ENDTYPE));
+ int type = (Integer) idata
+ .get(FunctionDataDBTable.COLUMN_INDEX_STARTTYPE)
+ + (Integer) idata
+ .get(FunctionDataDBTable.COLUMN_INDEX_ENDTYPE);
DAChartBoardItem functionItem = findFunctionBoardItem(threads,
tid);
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.DASelectionData;
+import org.tizen.dynamicanalyzer.database.DBConstants;
import org.tizen.dynamicanalyzer.model.TableInput;
-import org.tizen.dynamicanalyzer.sql.DBTableManager;
-import org.tizen.dynamicanalyzer.ui.kernel.data.KernelDataMaker;
+import org.tizen.dynamicanalyzer.ui.kernel.data.ContextDataDBTable;
+import org.tizen.dynamicanalyzer.ui.kernel.data.FunctionDataDBTable;
+import org.tizen.dynamicanalyzer.ui.kernel.data.KernelDataManager;
import org.tizen.dynamicanalyzer.ui.kernel.data.KernelDataPerThread;
import org.tizen.dynamicanalyzer.ui.range.RangeDataManager;
import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
public KernelListTable(Composite parent, int compStyle, int tableStyle) {
super(parent, compStyle, tableStyle);
- setDataType(false, KernelDataMaker.CONTEXT_DATA_COLUMN_INDEX_STARTTIME);
+ setDataType(false, ContextDataDBTable.COLUMN_INDEX_STARTTIME);
setContextMenu(AnalyzerConstants.CONTEXT_TABLE_RANGE);
table.addSelectionListener(new SelectionListener() {
return;
}
int size = ti.length;
- List<String> startData = ((DATableDataFormat) ti[0].getData())
+ List<Object> startData = ((DATableDataFormat) ti[0].getData())
.getData();
- List<String> endData = ((DATableDataFormat) ti[size - 1]
+ List<Object> endData = ((DATableDataFormat) ti[size - 1]
.getData()).getData();
- long startTime = Long.parseLong(startData.get(timeColumnIndex));
- long endTime = Long.parseLong(endData.get(timeColumnIndex));
+ long startTime = (Long) startData.get(timeColumnIndex);
+ long endTime = (Long) endData.get(timeColumnIndex);
- DASelectionData data = new DASelectionData(KernelPage.listViewID,
- startTime, endTime, ti, table);
+ DASelectionData data = new DASelectionData(
+ KernelPage.listViewID, startTime, endTime, ti, table);
AnalyzerManager.getCurrentPage().updateView(data);
}
@Override
protected List<TableInput> makeTableInput() {
List<TableInput> input = new ArrayList<TableInput>();
- List<List<String>> queriedData = getQueriedStringData();
+ List<List<Object>> queriedData = getQueriedObjectData();
if (queriedData == null) {
return null;
}
int size = queriedData.size();
for (int i = 0; i < size; i++) {
- List<String> row = queriedData.get(i);
+ List<Object> row = queriedData.get(i);
List<String> text = new ArrayList<String>();
int seqnum;
long starttime, endtime, exectime;
if (isCoreSelected) {
- seqnum = Integer.parseInt(row
- .get(KernelDataMaker.CONTEXT_DATA_COLUMN_INDEX_SEQ));
- starttime = Long
- .parseLong(row
- .get(KernelDataMaker.CONTEXT_DATA_COLUMN_INDEX_STARTTIME));
- endtime = Long
- .parseLong(row
- .get(KernelDataMaker.CONTEXT_DATA_COLUMN_INDEX_ENDTIME));
+ seqnum = (Integer) row.get(ContextDataDBTable.COLUMN_INDEX_SEQ);
+ starttime = (Long) row
+ .get(ContextDataDBTable.COLUMN_INDEX_STARTTIME);
+ endtime = (Long) row
+ .get(ContextDataDBTable.COLUMN_INDEX_ENDTIME);
exectime = endtime - starttime;
- text.add(row.get(KernelDataMaker.CONTEXT_DATA_COLUMN_INDEX_SEQ));
- text.add(row.get(KernelDataMaker.CONTEXT_DATA_COLUMN_INDEX_PID));
- text.add(row.get(KernelDataMaker.CONTEXT_DATA_COLUMN_INDEX_TID));
- text.add(row.get(KernelDataMaker.CONTEXT_DATA_COLUMN_INDEX_CPU));
+ text.add(row.get(ContextDataDBTable.COLUMN_INDEX_SEQ)
+ .toString());
+ text.add(row.get(ContextDataDBTable.COLUMN_INDEX_PID)
+ .toString());
+ text.add(row.get(ContextDataDBTable.COLUMN_INDEX_TID)
+ .toString());
+ text.add(row.get(ContextDataDBTable.COLUMN_INDEX_CPU)
+ .toString());
text.add(Formatter.toTimeFormat(starttime));
text.add(Formatter.toTimeFormat(endtime));
text.add(Formatter.toTimeFormat(exectime));
- text.add(row
- .get(KernelDataMaker.CONTEXT_DATA_COLUMN_INDEX_STARTADDR));
- text.add(row
- .get(KernelDataMaker.CONTEXT_DATA_COLUMN_INDEX_ENDADDR));
+ text.add(row.get(ContextDataDBTable.COLUMN_INDEX_STARTADDR)
+ .toString());
+ text.add(row.get(ContextDataDBTable.COLUMN_INDEX_ENDADDR)
+ .toString());
text.add("");
} else {
- seqnum = Integer.parseInt(row
- .get(KernelDataMaker.FUNCTION_DATA_COLUMN_INDEX_SEQ));
- starttime = Long
- .parseLong(row
- .get(KernelDataMaker.FUNCTION_DATA_COLUMN_INDEX_STARTTIME));
- endtime = Long
- .parseLong(row
- .get(KernelDataMaker.FUNCTION_DATA_COLUMN_INDEX_ENDTIME));
+ seqnum = (Integer) row
+ .get(FunctionDataDBTable.COLUMN_INDEX_SEQ);
+ starttime = (Long) row
+ .get(FunctionDataDBTable.COLUMN_INDEX_STARTTIME);
+ endtime = (Long) row
+ .get(FunctionDataDBTable.COLUMN_INDEX_ENDTIME);
exectime = endtime - starttime;
- text.add(row
- .get(KernelDataMaker.FUNCTION_DATA_COLUMN_INDEX_SEQ));
- text.add(row
- .get(KernelDataMaker.FUNCTION_DATA_COLUMN_INDEX_PID));
- text.add(row
- .get(KernelDataMaker.FUNCTION_DATA_COLUMN_INDEX_TID));
- text.add(row
- .get(KernelDataMaker.FUNCTION_DATA_COLUMN_INDEX_CPU));
+ text.add(row.get(FunctionDataDBTable.COLUMN_INDEX_SEQ)
+ .toString());
+ text.add(row.get(FunctionDataDBTable.COLUMN_INDEX_PID)
+ .toString());
+ text.add(row.get(FunctionDataDBTable.COLUMN_INDEX_TID)
+ .toString());
+ text.add(row.get(FunctionDataDBTable.COLUMN_INDEX_CPU)
+ .toString());
text.add(Formatter.toTimeFormat(starttime));
text.add(Formatter.toTimeFormat(endtime));
text.add(Formatter.toTimeFormat(exectime));
- text.add(row
- .get(KernelDataMaker.FUNCTION_DATA_COLUMN_INDEX_STARTADDR));
- text.add(row
- .get(KernelDataMaker.FUNCTION_DATA_COLUMN_INDEX_ENDADDR));
- text.add(row
- .get(KernelDataMaker.FUNCTION_DATA_COLUMN_INDEX_FUNCNAME));
+ text.add(row.get(FunctionDataDBTable.COLUMN_INDEX_STARTADDR)
+ .toString());
+ text.add(row.get(FunctionDataDBTable.COLUMN_INDEX_ENDADDR)
+ .toString());
+ text.add(row.get(FunctionDataDBTable.COLUMN_INDEX_FUNCNAME)
+ .toString());
}
// create DATableDataFormat
String tablename;
if (isCoreSelected) {
- tablename = DBTableManager
- .getInstance()
- .getTableInfo(
- DBTableManager.TABLE_INDEX_CONTEXT_SWITCH_DATA)
+ tablename = KernelDataManager.getInstance().getContextDataTable()
.getTableName();
} else {
- tablename = DBTableManager
- .getInstance()
- .getTableInfo(DBTableManager.TABLE_INDEX_FUNCTION_CALL_DATA)
+ tablename = KernelDataManager.getInstance().getFunctionDataTable()
.getTableName();
}
@Override
protected String getSelectQueryOption() {
- String never_option = DBTableManager.COMMON_COLUMN_TID + " = -1";
+ String never_option = DBConstants.COMMON_COLUMN_TID + " = -1";
if (selectedData == null) {
return never_option;
int selectedPid = ToolbarArea.getInstance().getSelectedPid();
if (selectedPid == 0 || selectedData.getPid() == selectedPid) {
- String option = DBTableManager.COMMON_COLUMN_TID + " = "
- + selectedData.getTid() + " order by "
- + DBTableManager.CUSTOM_COLUMN_START_TIME;
+ String option = DBConstants.COMMON_COLUMN_TID + " = "
+ + selectedData.getTid() + " order by ";
+
+ if (isCoreSelected)
+ option += ContextDataDBTable.STARTTIME;
+ else
+ option += FunctionDataDBTable.STARTTIME;
return option;
} else {
@Override
protected String getSelectQueryCountOption() {
- String never_option = DBTableManager.COMMON_COLUMN_TID + " = -1";
+ String never_option = DBConstants.COMMON_COLUMN_TID + " = -1";
if (selectedData == null) {
return never_option;
int selectedPid = ToolbarArea.getInstance().getSelectedPid();
if (selectedPid == 0 || selectedData.getPid() == selectedPid) {
- String option = DBTableManager.COMMON_COLUMN_TID + " = "
+ String option = DBConstants.COMMON_COLUMN_TID + " = "
+ selectedData.getTid();
return option;
@Override
protected String getTimeColumnName() {
- String timestr = DBTableManager.CUSTOM_COLUMN_START_TIME;
+ String timestr;
+ if (isCoreSelected)
+ timestr = ContextDataDBTable.STARTTIME;
+ else
+ timestr = FunctionDataDBTable.STARTTIME;
+
return timestr;
}
import java.util.List;\r
\r
import org.tizen.dynamicanalyzer.common.AnalyzerManager;\r
-import org.tizen.dynamicanalyzer.sql.DBTableManager;\r
-import org.tizen.dynamicanalyzer.sql.SqlManager;\r
import org.tizen.dynamicanalyzer.swap.logparser.ReadBlockingQueue;\r
\r
public class ContextDataDBInserter implements Runnable {\r
- private static ReadBlockingQueue<List<List<String>>> contextDataQueue = new ReadBlockingQueue<List<List<String>>>();\r
+ private static ReadBlockingQueue<List<List<Object>>> contextDataQueue = new ReadBlockingQueue<List<List<Object>>>();\r
\r
private static volatile Thread inserterThread = null;\r
\r
}\r
}\r
\r
- public static void pushContextData(List<List<String>> data) {\r
+ public static void pushContextData(List<List<Object>> data) {\r
contextDataQueue.offer(data);\r
}\r
\r
@Override\r
public void run() {\r
while (!AnalyzerManager.isExit()) {\r
- List<List<String>> contextData = contextDataQueue.poll();\r
+ List<List<Object>> contextData = contextDataQueue.poll();\r
\r
if (contextData != null) {\r
- SqlManager\r
- .getInstance()\r
- .insertQuery(\r
- DBTableManager\r
- .getInstance()\r
- .getTableInfo(\r
- DBTableManager.TABLE_INDEX_CONTEXT_SWITCH_DATA)\r
- .insertQuery(), contextData);\r
+ KernelDataManager.getInstance().getContextDataTable().insertData(contextData);\r
}\r
}\r
}\r
--- /dev/null
+package org.tizen.dynamicanalyzer.ui.kernel.data;
+
+import org.tizen.dynamicanalyzer.database.DBColumn;
+import org.tizen.dynamicanalyzer.database.DBConstants;
+import org.tizen.dynamicanalyzer.database.DBTable;
+
+public class ContextDataDBTable extends DBTable {
+ private static final String TABLENAME = "ContextSwitchData";
+
+ public static final String SEQ = DBConstants.COMMON_COLUMN_SEQ;
+ public static final String PID = DBConstants.COMMON_COLUMN_PID;
+ public static final String TID = DBConstants.COMMON_COLUMN_TID;
+ public static final String CPUNUM = "CpuNum";
+ public static final String STARTTIME = "StartTime";
+ public static final String STARTADDR = "StartPcAddr";
+ public static final String ENDTIME = "EndTime";
+ public static final String ENDADDR = "EndPcAddr";
+
+ public final static int COLUMN_INDEX_SEQ = 0;
+ public final static int COLUMN_INDEX_PID = 1;
+ public final static int COLUMN_INDEX_TID = 2;
+ public final static int COLUMN_INDEX_CPU = 3;
+ public final static int COLUMN_INDEX_STARTTIME = 4;
+ public final static int COLUMN_INDEX_STARTADDR = 5;
+ public final static int COLUMN_INDEX_ENDTIME = 6;
+ public final static int COLUMN_INDEX_ENDADDR = 7;
+
+ @Override
+ public String getTableName() {
+ return TABLENAME;
+ }
+
+ public ContextDataDBTable() {
+ addColumn(new DBColumn(SEQ, DBConstants.NOT_NULL, DBConstants.INTEGER));
+ addColumn(new DBColumn(PID, DBConstants.NOT_NULL, DBConstants.INTEGER));
+ addColumn(new DBColumn(TID, DBConstants.NOT_NULL, DBConstants.INTEGER));
+ addColumn(new DBColumn(CPUNUM, DBConstants.EMPTY, DBConstants.INTEGER));
+ addColumn(new DBColumn(STARTTIME, DBConstants.EMPTY, DBConstants.LONG));
+ addColumn(new DBColumn(STARTADDR, DBConstants.EMPTY, DBConstants.LONG));
+ addColumn(new DBColumn(ENDTIME, DBConstants.EMPTY, DBConstants.LONG));
+ addColumn(new DBColumn(ENDADDR, DBConstants.EMPTY, DBConstants.LONG));
+ }
+
+}
import java.util.List;\r
\r
import org.tizen.dynamicanalyzer.common.AnalyzerManager;\r
-import org.tizen.dynamicanalyzer.sql.DBTableManager;\r
-import org.tizen.dynamicanalyzer.sql.SqlManager;\r
import org.tizen.dynamicanalyzer.swap.logparser.ReadBlockingQueue;\r
\r
public class FunctionDataDBInserter implements Runnable {\r
- private static ReadBlockingQueue<List<List<String>>> functionDataQueue = new ReadBlockingQueue<List<List<String>>>();\r
+ private static ReadBlockingQueue<List<List<Object>>> functionDataQueue = new ReadBlockingQueue<List<List<Object>>>();\r
\r
private static volatile Thread inserterThread = null;\r
\r
}\r
}\r
\r
- public static void pushFunctionData(List<List<String>> data) {\r
+ public static void pushFunctionData(List<List<Object>> data) {\r
functionDataQueue.offer(data);\r
}\r
\r
@Override\r
public void run() {\r
while (!AnalyzerManager.isExit()) {\r
- List<List<String>> functionData = functionDataQueue.poll();\r
+ List<List<Object>> functionData = functionDataQueue.poll();\r
\r
if (functionData != null) {\r
- SqlManager\r
- .getInstance()\r
- .insertQuery(\r
- DBTableManager\r
- .getInstance()\r
- .getTableInfo(\r
- DBTableManager.TABLE_INDEX_FUNCTION_CALL_DATA)\r
- .insertQuery(), functionData);\r
+ KernelDataManager.getInstance().getFunctionDataTable().insertData(functionData);\r
}\r
}\r
}\r
--- /dev/null
+package org.tizen.dynamicanalyzer.ui.kernel.data;
+
+import org.tizen.dynamicanalyzer.database.DBColumn;
+import org.tizen.dynamicanalyzer.database.DBConstants;
+import org.tizen.dynamicanalyzer.database.DBTable;
+
+public class FunctionDataDBTable extends DBTable {
+ private static final String TABLENAME = "FunctionCallData";
+
+ public static final String SEQ = DBConstants.COMMON_COLUMN_SEQ;
+ public static final String PID = DBConstants.COMMON_COLUMN_PID;
+ public static final String TID = DBConstants.COMMON_COLUMN_TID;
+ public static final String CPUNUM = "CpuNum";
+ public static final String STARTTIME = "StartTime";
+ public static final String STARTTYPE = "StartType";
+ public static final String STARTADDR = "StartPcAddr";
+ public static final String ENDTIME = "EndTime";
+ public static final String ENDTYPE = "EndType";
+ public static final String ENDADDR = "EndPcAddr";
+ public static final String FUNCNAME = "FunctionName";
+
+ public final static int COLUMN_INDEX_SEQ = 0;
+ public final static int COLUMN_INDEX_PID = 1;
+ public final static int COLUMN_INDEX_TID = 2;
+ public final static int COLUMN_INDEX_CPU = 3;
+ public final static int COLUMN_INDEX_STARTTIME = 4;
+ public final static int COLUMN_INDEX_STARTTYPE = 5;
+ public final static int COLUMN_INDEX_STARTADDR = 6;
+ public final static int COLUMN_INDEX_ENDTIME = 7;
+ public final static int COLUMN_INDEX_ENDTYPE = 8;
+ public final static int COLUMN_INDEX_ENDADDR = 9;
+ public final static int COLUMN_INDEX_FUNCNAME = 10;
+
+ @Override
+ public String getTableName() {
+ return TABLENAME;
+ }
+
+ public FunctionDataDBTable() {
+ addColumn(new DBColumn(SEQ, DBConstants.NOT_NULL, DBConstants.INTEGER));
+ addColumn(new DBColumn(PID, DBConstants.NOT_NULL, DBConstants.INTEGER));
+ addColumn(new DBColumn(TID, DBConstants.NOT_NULL, DBConstants.INTEGER));
+ addColumn(new DBColumn(CPUNUM, DBConstants.EMPTY, DBConstants.INTEGER));
+ addColumn(new DBColumn(STARTTIME, DBConstants.EMPTY, DBConstants.LONG));
+ addColumn(new DBColumn(STARTTYPE, DBConstants.EMPTY,
+ DBConstants.INTEGER));
+ addColumn(new DBColumn(STARTADDR, DBConstants.EMPTY, DBConstants.LONG));
+ addColumn(new DBColumn(ENDTIME, DBConstants.EMPTY, DBConstants.LONG));
+ addColumn(new DBColumn(ENDTYPE, DBConstants.EMPTY, DBConstants.INTEGER));
+ addColumn(new DBColumn(ENDADDR, DBConstants.EMPTY, DBConstants.LONG));
+ addColumn(new DBColumn(FUNCNAME, DBConstants.EMPTY, DBConstants.TEXT));
+ }
+}
import java.util.List;
import java.util.Stack;
-import org.tizen.dynamicanalyzer.sql.DBTableInfo;
-import org.tizen.dynamicanalyzer.sql.DBTableManager;
-import org.tizen.dynamicanalyzer.sql.SqlManager;
+import org.tizen.dynamicanalyzer.database.DBTable;
import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants;
import org.tizen.dynamicanalyzer.swap.model.data.ContextSwitchData;
import org.tizen.dynamicanalyzer.swap.model.data.LogData;
public static final int END_TYPE_PAUSED = 2;
public static final int END_TYPE_CALL = 3;
- public final static int CONTEXT_DATA_COLUMN_INDEX_SEQ = 0;
- public final static int CONTEXT_DATA_COLUMN_INDEX_PID = 1;
- public final static int CONTEXT_DATA_COLUMN_INDEX_TID = 2;
- public final static int CONTEXT_DATA_COLUMN_INDEX_CPU = 3;
- public final static int CONTEXT_DATA_COLUMN_INDEX_STARTTIME = 4;
- public final static int CONTEXT_DATA_COLUMN_INDEX_STARTADDR = 5;
- public final static int CONTEXT_DATA_COLUMN_INDEX_ENDTIME = 6;
- public final static int CONTEXT_DATA_COLUMN_INDEX_ENDADDR = 7;
-
- public final static int FUNCTION_DATA_COLUMN_INDEX_SEQ = 0;
- public final static int FUNCTION_DATA_COLUMN_INDEX_PID = 1;
- public final static int FUNCTION_DATA_COLUMN_INDEX_TID = 2;
- public final static int FUNCTION_DATA_COLUMN_INDEX_CPU = 3;
- public final static int FUNCTION_DATA_COLUMN_INDEX_STARTTIME = 4;
- public final static int FUNCTION_DATA_COLUMN_INDEX_STARTTYPE = 5;
- public final static int FUNCTION_DATA_COLUMN_INDEX_STARTADDR = 6;
- public final static int FUNCTION_DATA_COLUMN_INDEX_ENDTIME = 7;
- public final static int FUNCTION_DATA_COLUMN_INDEX_ENDTYPE = 8;
- public final static int FUNCTION_DATA_COLUMN_INDEX_ENDADDR = 9;
- public final static int FUNCTION_DATA_COLUMN_INDEX_FUNCNAME = 10;
-
- private static KernelDataMaker instance = null;
-
// 'threads' may be necessary to synchronize but i didn't
// because i think that it does not make critical error
private ArrayList<KernelDataPerThread> threads;
- private ArrayList<List<String>> contextDataList;
- private ArrayList<List<String>> functionDataList;
+ private ArrayList<List<Object>> contextDataList;
+ private ArrayList<List<Object>> functionDataList;
public KernelDataMaker() {
threads = new ArrayList<KernelDataPerThread>();
- contextDataList = new ArrayList<List<String>>();
- functionDataList = new ArrayList<List<String>>();
- }
-
- public synchronized static KernelDataMaker getInstance() {
- if (instance == null) {
- instance = new KernelDataMaker();
- }
-
- return instance;
+ contextDataList = new ArrayList<List<Object>>();
+ functionDataList = new ArrayList<List<Object>>();
}
private KernelDataPerThread findKernelData(int tid) {
} else {
kdata.setCorelog(null);
- ArrayList<String> dbdata = new ArrayList<String>();
- dbdata.add(String.valueOf(precore.getSeq()));
- dbdata.add(String.valueOf(precore.getPid()));
- dbdata.add(String.valueOf(precore.getTid()));
- dbdata.add(String.valueOf(precore.getCpuNum()));
- dbdata.add(String.valueOf(precore.getTime()));
- dbdata.add(String.valueOf(precore.getPcAddr()));
- dbdata.add(String.valueOf(csdata.getTime()));
- dbdata.add(String.valueOf(csdata.getPcAddr()));
+ ArrayList<Object> dbdata = new ArrayList<Object>();
+ dbdata.add(new Integer(precore.getSeq()));
+ dbdata.add(new Integer(precore.getPid()));
+ dbdata.add(new Integer(precore.getTid()));
+ dbdata.add(new Integer(precore.getCpuNum()));
+ dbdata.add(new Long(precore.getTime()));
+ dbdata.add(new Long(precore.getPcAddr()));
+ dbdata.add(new Long(csdata.getTime()));
+ dbdata.add(new Long(csdata.getPcAddr()));
contextDataList.add(dbdata);
kdata.incCoreFragmentCount();
ProfileData lastfunc = prefunc.peek();
int lastfunc_type = prefunc_type.peek();
- ArrayList<String> dbfuncdata = new ArrayList<String>();
- dbfuncdata.add(String.valueOf(csdata.getSeq()));
- dbfuncdata.add(String.valueOf(csdata.getPid()));
- dbfuncdata.add(String.valueOf(csdata.getTid()));
- dbfuncdata.add(String.valueOf(csdata.getCpuNum()));
- dbfuncdata.add(String.valueOf(lastfunc.getTime()));
- dbfuncdata.add(String.valueOf(lastfunc_type));
- dbfuncdata
- .add(String.valueOf(lastfunc.getPcAddr()));
- dbfuncdata.add(String.valueOf(csdata.getTime()));
- dbfuncdata.add(String.valueOf(END_TYPE_PAUSED));
- dbfuncdata.add(String.valueOf(csdata.getPcAddr()));
+ ArrayList<Object> dbfuncdata = new ArrayList<Object>();
+ dbfuncdata.add(new Integer(csdata.getSeq()));
+ dbfuncdata.add(new Integer(csdata.getPid()));
+ dbfuncdata.add(new Integer(csdata.getTid()));
+ dbfuncdata.add(new Integer(csdata.getCpuNum()));
+ dbfuncdata.add(new Long(lastfunc.getTime()));
+ dbfuncdata.add(new Integer(lastfunc_type));
+ dbfuncdata.add(new Long(lastfunc.getPcAddr()));
+ dbfuncdata.add(new Long(csdata.getTime()));
+ dbfuncdata.add(new Integer(END_TYPE_PAUSED));
+ dbfuncdata.add(new Long(csdata.getPcAddr()));
dbfuncdata.add(lastfunc.getApiName());
functionDataList.add(dbfuncdata);
kdata.incFuncFragmentCount();
ProfileData lastfunc = prefunc.peek();
int lastfunc_type = prefunc_type.peek();
- ArrayList<String> dbfuncdata = new ArrayList<String>();
- dbfuncdata.add(String.valueOf(fndata.getSeq()));
- dbfuncdata.add(String.valueOf(fndata.getPid()));
- dbfuncdata.add(String.valueOf(fndata.getTid()));
- dbfuncdata.add(String.valueOf(fndata.getCpuNum()));
- dbfuncdata.add(String.valueOf(lastfunc.getTime()));
- dbfuncdata.add(String.valueOf(lastfunc_type));
- dbfuncdata.add(String.valueOf(lastfunc.getPcAddr()));
- dbfuncdata.add(String.valueOf(fndata.getTime()));
- dbfuncdata.add(String.valueOf(END_TYPE_CALL));
- dbfuncdata.add(String.valueOf(fndata.getPcAddr()));
+ ArrayList<Object> dbfuncdata = new ArrayList<Object>();
+ dbfuncdata.add(new Integer(fndata.getSeq()));
+ dbfuncdata.add(new Integer(fndata.getPid()));
+ dbfuncdata.add(new Integer(fndata.getTid()));
+ dbfuncdata.add(new Integer(fndata.getCpuNum()));
+ dbfuncdata.add(new Long(lastfunc.getTime()));
+ dbfuncdata.add(new Integer(lastfunc_type));
+ dbfuncdata.add(new Long(lastfunc.getPcAddr()));
+ dbfuncdata.add(new Long(fndata.getTime()));
+ dbfuncdata.add(new Integer(END_TYPE_CALL));
+ dbfuncdata.add(new Long(fndata.getPcAddr()));
dbfuncdata.add(lastfunc.getApiName());
functionDataList.add(dbfuncdata);
kdata.incFuncFragmentCount();
assert (lastfunc.getApiName() == fndata.getApiName());
- ArrayList<String> dbfuncdata = new ArrayList<String>();
- dbfuncdata.add(String.valueOf(fndata.getSeq()));
- dbfuncdata.add(String.valueOf(fndata.getPid()));
- dbfuncdata.add(String.valueOf(fndata.getTid()));
- dbfuncdata.add(String.valueOf(fndata.getCpuNum()));
- dbfuncdata.add(String.valueOf(lastfunc.getTime()));
- dbfuncdata.add(String.valueOf(lastfunc_type));
- dbfuncdata.add(String.valueOf(lastfunc.getPcAddr()));
- dbfuncdata.add(String.valueOf(fndata.getTime()));
- dbfuncdata.add(String.valueOf(END_TYPE_END));
- dbfuncdata.add(String.valueOf(fndata.getPcAddr()));
+ ArrayList<Object> dbfuncdata = new ArrayList<Object>();
+ dbfuncdata.add(new Integer(fndata.getSeq()));
+ dbfuncdata.add(new Integer(fndata.getPid()));
+ dbfuncdata.add(new Integer(fndata.getTid()));
+ dbfuncdata.add(new Integer(fndata.getCpuNum()));
+ dbfuncdata.add(new Long(lastfunc.getTime()));
+ dbfuncdata.add(new Integer(lastfunc_type));
+ dbfuncdata.add(new Long(lastfunc.getPcAddr()));
+ dbfuncdata.add(new Long(fndata.getTime()));
+ dbfuncdata.add(new Integer(END_TYPE_END));
+ dbfuncdata.add(new Long(fndata.getPcAddr()));
dbfuncdata.add(lastfunc.getApiName());
functionDataList.add(dbfuncdata);
kdata.incFuncFragmentCount();
}
@SuppressWarnings("unchecked")
- List<List<String>> clist = (List<List<String>>) contextDataList.clone();
+ List<List<Object>> clist = (List<List<Object>>) contextDataList.clone();
contextDataList.clear();
@SuppressWarnings("unchecked")
- List<List<String>> flist = (List<List<String>>) functionDataList
+ List<List<Object>> flist = (List<List<Object>>) functionDataList
.clone();
functionDataList.clear();
functionDataList.clear();
}
- public List<List<String>> getContextDataFromDB(long start, long end) {
- DBTableManager dbManager = DBTableManager.getInstance();
- DBTableInfo csTable = dbManager
- .getTableInfo(DBTableManager.TABLE_INDEX_CONTEXT_SWITCH_DATA);
- SqlManager sql = SqlManager.getInstance();
+ public List<List<Object>> getContextDataFromDB(long start, long end) {
+ String where = "where " + ContextDataDBTable.STARTTIME + " < " + end
+ + " and " + ContextDataDBTable.ENDTIME + " > " + start
+ + " order by " + ContextDataDBTable.STARTTIME;
- String where = "where " + DBTableManager.CUSTOM_COLUMN_START_TIME
- + " < " + end + " and " + DBTableManager.CUSTOM_COLUMN_END_TIME
- + " > " + start + " order by "
- + DBTableManager.CUSTOM_COLUMN_START_TIME;
+ DBTable table = KernelDataManager.getInstance().getContextDataTable();
- String[] csColumns = csTable.getColumnNames();
-
- List<List<String>> queriedContextData = sql.selectQuery(null,
- csColumns, csTable.getTableName(), where);
-
- return queriedContextData;
+ return table.selectData(null, where);
}
- public List<List<String>> getFunctionDataFromDB(long start, long end,
+ public List<List<Object>> getFunctionDataFromDB(long start, long end,
int tid) {
- DBTableManager dbManager = DBTableManager.getInstance();
- DBTableInfo fnTable = dbManager
- .getTableInfo(DBTableManager.TABLE_INDEX_FUNCTION_CALL_DATA);
- SqlManager sql = SqlManager.getInstance();
-
String where = "where ";
if (tid >= 0) {
- where = where + DBTableManager.COMMON_COLUMN_TID + " = " + tid
- + " and ";
+ where = where + FunctionDataDBTable.TID + " = " + tid + " and ";
}
- where = where + DBTableManager.CUSTOM_COLUMN_START_TIME + " < " + end
- + " and " + DBTableManager.CUSTOM_COLUMN_END_TIME + " > "
- + start + " order by "
- + DBTableManager.CUSTOM_COLUMN_START_TIME;
+ where = where + FunctionDataDBTable.STARTTIME + " < " + end + " and "
+ + FunctionDataDBTable.ENDTIME + " > " + start + " order by "
+ + FunctionDataDBTable.STARTTIME;
- String[] fnColumns = fnTable.getColumnNames();
+ DBTable table = KernelDataManager.getInstance().getFunctionDataTable();
- List<List<String>> queriedFunctionData = sql.selectQuery(null,
- fnColumns, fnTable.getTableName(), where);
-
- return queriedFunctionData;
+ return table.selectData(null, where);
}
- public List<List<String>> getFuncnameFromDB(int tid) {
- DBTableManager dbManager = DBTableManager.getInstance();
- DBTableInfo fnTable = dbManager
- .getTableInfo(DBTableManager.TABLE_INDEX_FUNCTION_CALL_DATA);
- SqlManager sql = SqlManager.getInstance();
-
- String where = "where " + DBTableManager.COMMON_COLUMN_TID + " = "
- + tid + " group by " + DBTableManager.CUSTOM_COLUMN_FUNCNAME;
+ public List<List<Object>> getFuncnameFromDB(int tid) {
+ String where = "where " + FunctionDataDBTable.TID + " = "
+ + tid + " group by " + FunctionDataDBTable.FUNCNAME;
- String[] fnColumns = fnTable.getColumnNames();
- String[] qColumns = new String[] { fnColumns[FUNCTION_DATA_COLUMN_INDEX_FUNCNAME] };
+ List<String> selectColumn = new ArrayList<String>();
+ selectColumn.add(FunctionDataDBTable.FUNCNAME);
- List<List<String>> queriedFunctionName = sql.selectQuery(null,
- qColumns, fnTable.getTableName(), where);
+ DBTable table = KernelDataManager.getInstance().getFunctionDataTable();
- return queriedFunctionName;
+ return table.selectData(selectColumn, where);
}
public List<KernelDataPerThread> getThreadData() {
import java.util.List;
import java.util.PriorityQueue;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.database.DBTable;
import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants;
import org.tizen.dynamicanalyzer.swap.logparser.LogPackage;
import org.tizen.dynamicanalyzer.swap.logparser.Logs;
public class KernelDataManager extends PageDataManager {
private static KernelDataManager instance = null;
private KernelDataMaker kdataMaker = null;
+
+ private ContextDataDBTable contextDataTable = null;
+ private FunctionDataDBTable functionDataTable = null;
+
+ private KernelDataManager() {
+ kdataMaker = new KernelDataMaker();
+ contextDataTable = new ContextDataDBTable();
+ addDBTable(contextDataTable);
+ functionDataTable = new FunctionDataDBTable();
+ addDBTable(functionDataTable);
+ }
+
+ public DBTable getContextDataTable() {
+ return contextDataTable;
+ }
- public KernelDataManager() {
- kdataMaker = KernelDataMaker.getInstance();
+ public DBTable getFunctionDataTable() {
+ return functionDataTable;
+ }
+
+ public KernelDataMaker getDataMaker() {
+ return kdataMaker;
}
public synchronized static KernelDataManager getInstance() {
}
return instance;
}
-
+
@Override
public void run() {
while (!AnalyzerManager.isExit()) {
.getPid());
if (input.getId() != DataChannelConstants.MSG_DATA_SAMPLE) {
ProcessInfoPackage processInfoPkg = AnalyzerManager
- .getProject().getProcessInfo(input.getPid());
+ .getProject().getProcessInfoPackage(input.getPid());
ProcessInfo processInfo = processInfoPkg
.getProcessInfo(input.getTime());
long pcAddr = input.getPcAddr();
DATableDataFormat dataFormat = (DATableDataFormat) items[0]
.getData();
- String timeStr = dataFormat.getData().get(LeakData.INDEX_TIME);
- long time = Long.parseLong(timeStr);
+ long time = (Long) dataFormat.getData()
+ .get(LeakData.INDEX_TIME);
String id = SummaryPage.leakViewID;
if (isRange) {
String symbol = null;
long pcAddr = sampleLog.getPcAddr();
ProcessInfoPackage processInfoPkg = AnalyzerManager
- .getProject().getProcessInfo(sampleLog.getPid());
+ .getProject().getProcessInfoPackage(sampleLog.getPid());
ProcessInfo processInfo = processInfoPkg.getProcessInfo(sampleLog
.getTime());
int selectedPid = ToolbarArea.getInstance().getSelectedPid();
if (selectedPid != 0) {
ProcessInfoPackage processInfoPkg = AnalyzerManager.getProject()
- .getProcessInfo(selectedPid);
+ .getProcessInfoPackage(selectedPid);
itemCount = processInfoPkg.getFunctionEntryInsertLogCount();
} else {
Set<Entry<Integer, ProcessInfoPackage>> set = AnalyzerManager
}
DATableDataFormat dataFormat = (DATableDataFormat) items[0]
.getData();
- String className = dataFormat.getData().get(
+ String className = (String) dataFormat.getData().get(
dataFormat.getData().size() - 1);
UIDataManager.getInstance().setTableSeleteClassName(className);
protected Object obj = null;
protected long selectionKey = -1;
protected int type = 0;
- protected List<String> data = new ArrayList<String>();
+ protected List<Object> data = new ArrayList<Object>();
public DATableDataFormat(long selectionKey) {
this.selectionKey = selectionKey;
return type;
}
- public List<String> getData() {
+ public List<Object> getData() {
return data;
}
}
import org.eclipse.swt.widgets.ScrollBar;
import org.eclipse.swt.widgets.Shell;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.database.SqlConnectionManager;
import org.tizen.dynamicanalyzer.model.FindProperty;
import org.tizen.dynamicanalyzer.model.TableInput;
import org.tizen.dynamicanalyzer.resources.ColorResources;
import org.tizen.dynamicanalyzer.util.WorkbenchUtil;
public abstract class DAWindowingTableComposite extends DATableComposite {
+ private static final String queryto_GetItemCount = "select count(*) from %s where %s";
+ private static final String queryto_GetLimitedItem = "select limit %s %s %s from %s where %s";
protected Composite scrollComp;
protected ScrollBar vScrollbar;
private int previousTableLength = 0;
private List<LogData> queriedLogData = null;
- private List<List<String>> queriedStringData = null;
+ private List<List<Object>> queriedObjectData = null;
public DAWindowingTableComposite(Composite parent, int compStyle,
int tableStyle) {
selectionStartTime = td.getLogData().getTime();
selectionEndTime = td.getLogData().getTime();
} else {
- selectionStartTime = Long.parseLong(td.getData().get(
- timeColumnIndex));
+ selectionStartTime = (Long) td.getData().get(
+ timeColumnIndex);
selectionEndTime = selectionStartTime;
}
selectionStartTime = td.getLogData().getTime();
selectionEndTime = td.getLogData().getTime();
} else {
- selectionStartTime = Long.parseLong(td.getData().get(
- timeColumnIndex));
+ selectionStartTime = (Long) td.getData().get(timeColumnIndex);
selectionEndTime = selectionStartTime;
}
selectionList.add(i);
}
} else {
- long time = Long.parseLong(gridData.getData().get(
- timeColumnIndex));
+ long time = (Long) gridData.getData().get(timeColumnIndex);
if (selectionStartTime <= time && time <= selectionEndTime) {
isSelectionItem = true;
focusIndex = i;
totalItemCount = getItemCountByPid();
} else {
if (totalItemCount == 0) { // open
- totalItemCount = SqlManager.getInstance().getTableItemCount(
+ String query = String.format(queryto_GetItemCount,
getDBTableName(), getSelectQueryCountOption());
+ List<List<Object>> result = SqlConnectionManager
+ .executeQuery(query);
+ totalItemCount = (Integer) result.get(0).get(0);
} else { // stop
totalItemCount = getItemCountByPid();
}
if (isLogData) {
queriedLogData = getLogDataFromDB(itemCount);
} else {
- queriedStringData = getStringDataFromDB(itemCount);
+ queriedObjectData = getObjectDataFromDB(itemCount);
}
}
if ((isLogData && queriedLogData == null)
- || (!isLogData && queriedStringData == null)) {
+ || (!isLogData && queriedObjectData == null)) {
return null;
}
return makeTableInput();
}
- private List<List<String>> getStringDataFromDB(int itemCount) {
+ private List<List<Object>> getObjectDataFromDB(int itemCount) {
int scrollSelection = vScrollbar.getSelection();
if (scrollSelection > itemCount) { // change PID
scrollSelection = 0;
if (itemCount <= selectedEndIndex) {
selectedEndIndex = itemCount;
}
- List<List<String>> outputList = SqlManager.getInstance().selectQuery3(
- null, getDBTableColumnNames(), getDBTableName(),
- scrollSelection, selectedEndIndex + 1, getSelectQueryOption());
- return outputList;
+
+ StringBuffer columnString = new StringBuffer();
+ List<String> columnNames = getDBTableColumnNames();
+ int columnsize = columnNames.size();
+ for (int i = 0; i < columnsize; i++) {
+ columnString.append(columnNames.get(i));
+ if (i < columnsize - 1)
+ columnString.append(", ");
+ }
+
+ String query = String.format(queryto_GetLimitedItem, scrollSelection,
+ selectedEndIndex + 1, columnString.toString(),
+ getDBTableName(), getSelectQueryOption());
+
+ return SqlConnectionManager.executeQuery(query);
}
private List<LogData> getLogDataFromDB(int itemCount) {
selectionStartTime = -1;
selectionEndTime = -1;
queriedLogData = null;
- queriedStringData = null;
+ queriedObjectData = null;
totalItemCount = 0;
}
.getLogData();
inputTime = data.getTime();
} else {
- String timestring = ((DATableDataFormat) item.getData())
+ inputTime = (Long) ((DATableDataFormat) item.getData())
.getData().get(timeColumnIndex);
- inputTime = Long.parseLong(timestring);
}
if (type == START_TIME) {
return queriedLogData;
}
- protected List<List<String>> getQueriedStringData() {
- return queriedStringData;
+ protected List<List<Object>> getQueriedObjectData() {
+ return queriedObjectData;
}
public void setSelectionByTime(long startTime, long endTime) {
DATableDataFormat tableData1 = (DATableDataFormat) item1.getData();
DATableDataFormat tableData2 = (DATableDataFormat) item2.getData();
- List<String> data1 = tableData1.getData();
- List<String> data2 = tableData2.getData();
+ List<Object> data1 = tableData1.getData();
+ List<Object> data2 = tableData2.getData();
- str1 = data1.get(column);
- str2 = data2.get(column);
+ str1 = data1.get(column).toString();
+ str2 = data2.get(column).toString();
} else {
List<String> text1 = item1.getText();
List<String> text2 = item2.getText();
public static String getProcessLocalBinaryPath(int pid, long time) {
ProcessInfoPackage processInfoPkg = AnalyzerManager.getProject()
- .getProcessInfo(pid);
+ .getProcessInfoPackage(pid);
ProcessInfo processInfo = processInfoPkg.getProcessInfo(time);
if (null != processInfo) {
return processInfo.getMainTargetBinaryPath();
public static BinaryInfo getBinaryInfo(int pid, long time) {
ProcessInfoPackage processInfoPkg = AnalyzerManager.getProject()
- .getProcessInfo(pid);
+ .getProcessInfoPackage(pid);
ProcessInfo processInfo = processInfoPkg.getProcessInfo(time);
if (null == processInfo) {
return null;
// for tizen 2.2
public static boolean isPieBuild(int pid, long time) {
ProcessInfoPackage processInfoPkg = AnalyzerManager.getProject()
- .getProcessInfo(pid);
+ .getProcessInfoPackage(pid);
ProcessInfo processInfo = processInfoPkg.getProcessInfo(time);
if (null == processInfo) {
return false;
projects / sdk / tools / dynamic-analyzer.git / commitdiff