From c2e09b41520a5fc1c64309c5c23831b237d41df0 Mon Sep 17 00:00:00 2001 From: greatim Date: Tue, 8 Apr 2014 14:54:56 +0900 Subject: [PATCH] [Title] refactor database [Desc.] [Issue] --- .../dynamicanalyzer/common/GlobalInformation.java | 27 ++ .../tizen/dynamicanalyzer/database/DBColumn.java | 33 +++ .../dynamicanalyzer/database/DBConstants.java | 25 ++ .../tizen/dynamicanalyzer/database/DBTable.java | 103 +++++++ .../database/SqlConnectionManager.java | 243 ++++++++++++++++ .../dynamicanalyzer/handlers/OpenTraceHandler.java | 4 +- .../listeners/TableTooltipListener.java | 323 +++++++++++---------- .../org/tizen/dynamicanalyzer/project/Project.java | 218 +++++++------- .../org/tizen/dynamicanalyzer/sql/DBTableInfo.java | 36 ++- .../tizen/dynamicanalyzer/sql/DBTableManager.java | 3 +- .../org/tizen/dynamicanalyzer/sql/SqlManager.java | 149 +++++----- .../swap/callstack/BaseCallstackManager.java | 2 +- .../swap/callstack/SWAPCallStackManager.java | 6 +- .../swap/channel/data/ProcessInfo.java | 4 +- .../swap/logparser/DataManagerRegistry.java | 15 +- .../swap/logparser/MessageParser.java | 4 +- .../swap/logparser/PageDataManager.java | 16 +- .../swap/logparser/SWAPLogParser.java | 4 +- .../tizen/dynamicanalyzer/swap/model/DATime.java | 22 +- .../dynamicanalyzer/swap/model/data/LogData.java | 2 +- .../swap/model/data/ProbeCommonData.java | 2 +- .../swap/model/data/ProfileData.java | 2 +- .../ui/info/callstack/CallstackTable.java | 20 +- .../ui/info/callstack/CallstackView.java | 16 +- .../dynamicanalyzer/ui/kernel/CallFlowChart.java | 39 +-- .../ui/kernel/ContextSwitchingChart.java | 60 ++-- .../dynamicanalyzer/ui/kernel/KernelListTable.java | 131 +++++---- .../ui/kernel/data/ContextDataDBInserter.java | 17 +- .../ui/kernel/data/ContextDataDBTable.java | 44 +++ .../ui/kernel/data/FunctionDataDBInserter.java | 17 +- .../ui/kernel/data/FunctionDataDBTable.java | 53 ++++ .../ui/kernel/data/KernelDataMaker.java | 197 +++++-------- .../ui/kernel/data/KernelDataManager.java | 26 +- .../dynamicanalyzer/ui/range/RangeDataManager.java | 2 +- .../ui/summary/leaks/LeakTable.java | 4 +- .../ui/summary/profiling/ProfileDataMaker.java | 2 +- .../ui/timeline/calltrace/CallTraceTable.java | 2 +- .../profiling/UIFunctionProfilingTable.java | 2 +- .../ui/widgets/table/DATableDataFormat.java | 4 +- .../widgets/table/DAWindowingTableComposite.java | 54 ++-- .../ui/widgets/table/DefaultTableComparator.java | 8 +- .../tizen/dynamicanalyzer/utils/AnalyzerUtil.java | 6 +- 42 files changed, 1242 insertions(+), 705 deletions(-) create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/GlobalInformation.java create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/DBColumn.java create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/DBConstants.java create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/DBTable.java create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/SqlConnectionManager.java create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/ContextDataDBTable.java create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/FunctionDataDBTable.java diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/GlobalInformation.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/GlobalInformation.java new file mode 100644 index 0000000..6cd3b16 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/GlobalInformation.java @@ -0,0 +1,27 @@ +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; + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/DBColumn.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/DBColumn.java new file mode 100644 index 0000000..a515931 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/DBColumn.java @@ -0,0 +1,33 @@ +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; + } + +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/DBConstants.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/DBConstants.java new file mode 100644 index 0000000..c74d4a2 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/DBConstants.java @@ -0,0 +1,25 @@ +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$ +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/DBTable.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/DBTable.java new file mode 100644 index 0000000..bca9022 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/DBTable.java @@ -0,0 +1,103 @@ +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 columns = new ArrayList(); + + public abstract String getTableName(); + + public final List 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> data) { + List columnType = new ArrayList(); + 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> selectData(List 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); + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/SqlConnectionManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/SqlConnectionManager.java new file mode 100644 index 0000000..eb1a3b1 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/SqlConnectionManager.java @@ -0,0 +1,243 @@ +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> data, + List 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 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> executeQuery(String query) { + Statement sm = null; + ResultSet rs = null; + List> result = null; + try { + if (connection != null) { + semaphoreAcquire(); + sm = connection.createStatement(); + rs = sm.executeQuery(query); + if (rs != null) { + result = new ArrayList>(); + ResultSetMetaData rsMetaData = rs.getMetaData(); + int columnCount = rsMetaData.getColumnCount(); + while (rs.next()) { + List rowData = new ArrayList(); + // 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; + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/OpenTraceHandler.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/OpenTraceHandler.java index 0c7bff2..440f6bf 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/OpenTraceHandler.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/OpenTraceHandler.java @@ -246,7 +246,7 @@ public class OpenTraceHandler extends AbstractHandler { List info = dbInfo.get(0); TargetInfo targetInfo = new TargetInfo(); targetInfo.loadSaveFormat(info); - AnalyzerManager.getProject().setTargetInfo(targetInfo); + DACommunicator.getSelectedDevice().setTargetInfo(targetInfo); } List pids = SqlManager.getInstance().getPids(); @@ -277,7 +277,7 @@ public class OpenTraceHandler extends AbstractHandler { } String subOption = "where pid = " + process.getPid() + " and time = \'" - + process.getStartTime().getSaveFormat() + "\'"; + + process.getStartTime().toString() + "\'"; List> objInfo = SqlManager.getInstance() .loadLibObj(subOption); if (null == objInfo) { diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/listeners/TableTooltipListener.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/listeners/TableTooltipListener.java index 7a4bb28..9bc388b 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/listeners/TableTooltipListener.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/listeners/TableTooltipListener.java @@ -75,10 +75,9 @@ public class TableTooltipListener implements Listener { 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; @@ -119,53 +118,53 @@ public class TableTooltipListener implements Listener { 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: @@ -176,109 +175,110 @@ public class TableTooltipListener implements Listener { 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 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 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 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 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 @@ -291,18 +291,18 @@ public class TableTooltipListener implements Listener { 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); @@ -401,27 +401,27 @@ public class TableTooltipListener implements Listener { 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); } @@ -485,7 +485,7 @@ public class TableTooltipListener implements Listener { 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); @@ -507,7 +507,7 @@ public class TableTooltipListener implements Listener { onViewSourceFromContext = false; } } - + private String getLibPath(GridItem item) { DATableDataFormat tableData = (DATableDataFormat) item.getData(); String libName = null; @@ -517,12 +517,12 @@ public class TableTooltipListener implements Listener { libName = item.getText(2); break; case AnalyzerConstants.TYPE_TABLE_FAILED: - List failedData = tableData.getData(); - libName = failedData.get(9); + List failedData = tableData.getData(); + libName = (String) failedData.get(9); break; case AnalyzerConstants.TYPE_TABLE_LEAK: - List leakData = tableData.getData(); - libName = leakData.get(7); + List leakData = tableData.getData(); + libName = (String) leakData.get(7); break; case AnalyzerConstants.TYPE_TABLE_WARNING: ProbeCommonData pData = (ProbeCommonData) tableData.getLogData(); @@ -549,10 +549,11 @@ public class TableTooltipListener implements Listener { } 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) { diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/project/Project.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/project/Project.java index 8412df4..4c56651 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/project/Project.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/project/Project.java @@ -46,13 +46,14 @@ import org.tizen.dynamicanalyzer.common.path.PathConstants; 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; @@ -62,6 +63,7 @@ public class Project { // 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"; @@ -76,182 +78,176 @@ public class Project { 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 projextInfoFileHashMap = new HashMap(); - - private HashMap processInfoPackHash = new HashMap(); + private HashMap projectInfoMap = new HashMap(); - public TargetInfo getTargetInfo() { - TargetInfo targetInfo = DACommunicator.getSelectedDevice() - .getTargetInfo(); - return targetInfo; - } + private HashMap processInfoPackageMap = new HashMap(); - 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 @@ -317,7 +313,13 @@ public class Project { 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(); @@ -338,13 +340,13 @@ public class Project { } 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(); } @@ -363,7 +365,7 @@ public class Project { } public HashMap getProcessInfoPackHash() { - return processInfoPackHash; + return processInfoPackageMap; } public void loadSaveFormat(List data) { @@ -377,15 +379,16 @@ public class Project { 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))); } @@ -399,29 +402,17 @@ public class Project { 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; } @@ -431,7 +422,8 @@ public class Project { 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); @@ -443,10 +435,10 @@ public class Project { buffWriter = new BufferedWriter(fileWriter); printWriter = new PrintWriter(buffWriter); - Iterator iter = projextInfoFileHashMap.keySet().iterator(); + Iterator 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(); } @@ -508,14 +500,14 @@ public class Project { 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)) { diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/sql/DBTableInfo.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/sql/DBTableInfo.java index 79a7416..968eddf 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/sql/DBTableInfo.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/sql/DBTableInfo.java @@ -45,9 +45,11 @@ public class DBTableInfo { 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() { @@ -63,16 +65,18 @@ public class DBTableInfo { 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() { @@ -81,16 +85,18 @@ public class DBTableInfo { 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() { @@ -102,16 +108,18 @@ public class DBTableInfo { 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() { @@ -135,6 +143,7 @@ public class DBTableInfo { || columnNames.length != columnTypes.length) { return false; } + return true; } @@ -161,15 +170,4 @@ public class DBTableInfo { 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(); - } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/sql/DBTableManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/sql/DBTableManager.java index 1a6cc41..5ece27e 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/sql/DBTableManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/sql/DBTableManager.java @@ -373,7 +373,7 @@ public class DBTableManager { // tableInfos.set(TABLE_INDEX_GLES20_CHANGE_INFO, // Gles20ChangeInfoTableInfo); } - +/* // context switch data { String[] names = { COMMON_COLUMN_SEQ_NUMBER, COMMON_COLUMN_PID, @@ -402,6 +402,7 @@ public class DBTableManager { TABLE_NAME_FUNCTION_CALL_DATA, names, options, types); tableInfos.set(TABLE_INDEX_FUNCTION_CALL_DATA, funcCallInfo); } +*/ } public DBTableInfo getTableInfo(int tableInfoIndex) { diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/sql/SqlManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/sql/SqlManager.java index 37c680c..de24b70 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/sql/SqlManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/sql/SqlManager.java @@ -43,6 +43,7 @@ import java.util.List; 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; @@ -281,7 +282,7 @@ public class SqlManager { } } - System.out.println("dddd : "+ query.toString()); + System.out.println("dddd : " + query.toString()); return query.toString(); } @@ -372,7 +373,8 @@ public class SqlManager { logData.makePreparedStatement(prep); if (logData.getId() == DataChannelConstants.MSG_FUNCTION_ENTRY) { ProcessInfoPackage processInfoPkg = AnalyzerManager - .getProject().getProcessInfo(logData.getPid()); + .getProject().getProcessInfoPackage( + logData.getPid()); processInfoPkg.addFunctionEntryInsertLogCount(); } @@ -413,43 +415,50 @@ public class SqlManager { 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 insetRowData = project.makeSaveProjectInfo(); - ; - List> insetData = new ArrayList>(); - insetData.add(insetRowData); + List insetRowData = project.makeSaveProjectInfo(); + List> insetData = new ArrayList>(); + 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 insetRowData = new ArrayList(); + String insertQuery = info.insertQuery(); + if (insertQuery != null) { + TargetInfo targetInfo = DACommunicator.getSelectedDevice() + .getTargetInfo(); + List insetRowData = new ArrayList(); - 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> insetData = new ArrayList>(); - insetData.add(insetRowData); + List> insetData = new ArrayList>(); + insetData.add(insetRowData); - insertQuery(insertQuery, insetData); + insertQuery(insertQuery, insetData); + } else { + System.out.println("[ERR] insert target info failed!!"); + } } public void insertProcessInfo() { @@ -459,21 +468,25 @@ public class SqlManager { pInfoPackList.addAll(AnalyzerManager.getProject() .getProcessInfoPackHash().values()); - for (ProcessInfoPackage pip : pInfoPackList) { - List 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 insertRowData = new ArrayList(); - insertRowData.add(Integer.toString(pInfo.getPid())); - insertRowData.add(pInfo.getSaveFormat()); - List> insetData = new ArrayList>(); - insetData.add(insertRowData); - - insertQuery(insertQuery, insetData); - insertLibObj(pInfo); + String insertQuery = info.insertQuery(); + if (insertQuery != null) { + for (ProcessInfoPackage pip : pInfoPackList) { + List processInfoList = pip.getProcessSnapshots(); + + for (int i = 0; i < processInfoList.size(); i++) { + ProcessInfo pInfo = processInfoList.get(i); + List insertRowData = new ArrayList(); + insertRowData.add(Integer.toString(pInfo.getPid())); + insertRowData.add(pInfo.getSaveFormat()); + List> insetData = new ArrayList>(); + insetData.add(insertRowData); + + insertQuery(insertQuery, insetData); + insertLibObj(pInfo); + } } + } else { + System.out.println("[ERR] insert process info failed!!"); } } @@ -481,21 +494,25 @@ public class SqlManager { List 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> insetData = new ArrayList>(); - for (LibraryObject lib : libs) { - List insertRowData = new ArrayList(); - 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> insetData = new ArrayList>(); + for (LibraryObject lib : libs) { + List insertRowData = new ArrayList(); + 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> input) { @@ -516,7 +533,7 @@ public class SqlManager { prep.setString(j + 1, rowData.get(j)); } prep.addBatch(); - + } if (dataRowSize > 0) { conn.setAutoCommit(false); @@ -1767,15 +1784,15 @@ public class SqlManager { 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()); } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/callstack/BaseCallstackManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/callstack/BaseCallstackManager.java index 54852d8..04c2d51 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/callstack/BaseCallstackManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/callstack/BaseCallstackManager.java @@ -144,7 +144,7 @@ public abstract class BaseCallstackManager { public String getUserFunctionPosition(int pid, long time) { ProcessInfoPackage processInfoPkg = AnalyzerManager - .getProject().getProcessInfo(pid); + .getProject().getProcessInfoPackage(pid); ProcessInfo processInfo = processInfoPkg.getProcessInfo(time); return processInfo.getMainTargetBinaryPath(); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/callstack/SWAPCallStackManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/callstack/SWAPCallStackManager.java index 170083b..eb1057b 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/callstack/SWAPCallStackManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/callstack/SWAPCallStackManager.java @@ -238,7 +238,7 @@ public class SWAPCallStackManager extends BaseCallstackManager { 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); } @@ -456,7 +456,7 @@ public class SWAPCallStackManager extends BaseCallstackManager { 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; @@ -472,7 +472,7 @@ public class SWAPCallStackManager extends BaseCallstackManager { 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; diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/channel/data/ProcessInfo.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/channel/data/ProcessInfo.java index 33d6bcf..de41f1e 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/channel/data/ProcessInfo.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/channel/data/ProcessInfo.java @@ -167,7 +167,7 @@ public class ProcessInfo { 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); @@ -181,7 +181,7 @@ public class ProcessInfo { 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]); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/DataManagerRegistry.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/DataManagerRegistry.java index bd143a0..910e24c 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/DataManagerRegistry.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/DataManagerRegistry.java @@ -1,10 +1,13 @@ 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 dataManagers = null; @@ -42,7 +45,7 @@ public class DataManagerRegistry { if (ret) break; } - + return ret; } @@ -51,4 +54,14 @@ public class DataManagerRegistry { entry.getValue().updateLog(pack); } } + + public static void createDBTables() { + for (Map.Entry entry : dataManagers.entrySet()) { + List tables = entry.getValue().getDBTableList(); + int size = tables.size(); + for (int i = 0; i < size; i++) { + tables.get(i).createTable(); + } + } + } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/MessageParser.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/MessageParser.java index 3f648f1..ba13c8e 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/MessageParser.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/MessageParser.java @@ -344,14 +344,14 @@ public class MessageParser { + 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(); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/PageDataManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/PageDataManager.java index aeb2064..e759e3d 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/PageDataManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/PageDataManager.java @@ -1,11 +1,16 @@ 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 logPackQueue = new ReadBlockingQueue(); + private List dbTableList = new ArrayList(); public final String getName() { if (name == null) { @@ -21,7 +26,15 @@ public abstract class PageDataManager implements Runnable { protected final LogPackage pollPack() { return logPackQueue.poll(); } - + + protected final void addDBTable(DBTable table) { + dbTableList.add(table); + } + + public final List getDBTableList() { + return dbTableList; + } + public final void startThread() { if (thread == null || !thread.isAlive()) { thread = new Thread(null, this, getName()); @@ -52,4 +65,5 @@ public abstract class PageDataManager implements Runnable { protected void sendNotify() { logPackQueue.wake(); } + } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/SWAPLogParser.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/SWAPLogParser.java index 859fa1c..685a435 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/SWAPLogParser.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/SWAPLogParser.java @@ -154,7 +154,7 @@ public class SWAPLogParser implements Runnable { long pcAddr = pData.getPcAddr(); ProcessInfoPackage processInfoPkg = AnalyzerManager - .getProject().getProcessInfo(pData.getPid()); + .getProject().getProcessInfoPackage(pData.getPid()); String apiName = pData.getApiName(); if (null == apiName || apiName.isEmpty() @@ -432,7 +432,7 @@ public class SWAPLogParser implements Runnable { // String functionName = null; ProcessInfoPackage processInfoPkg = AnalyzerManager.getProject() - .getProcessInfo(input.getPid()); + .getProcessInfoPackage(input.getPid()); ProcessInfo processInfo = processInfoPkg .getProcessInfo(input.getTime()); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/DATime.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/DATime.java index be40297..959dad6 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/DATime.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/DATime.java @@ -28,8 +28,17 @@ package org.tizen.dynamicanalyzer.swap.model; 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; @@ -51,12 +60,13 @@ public class DATime { 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]); @@ -64,8 +74,8 @@ public class DATime { 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; } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LogData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LogData.java index 55b6b91..f10a226 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LogData.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LogData.java @@ -88,7 +88,7 @@ public abstract class LogData implements Cloneable { System.out.println("id : " + AnalyzerUtil.toHexdecimal(id) + " time : " + time); System.out.println("profile start time : " - + startTime.getSaveFormat() + " time : " + sec + "," + + startTime.toString() + " time : " + sec + "," + nano); } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ProbeCommonData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ProbeCommonData.java index 89d2f40..b1478d5 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ProbeCommonData.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ProbeCommonData.java @@ -117,7 +117,7 @@ public class ProbeCommonData extends LogData { index += INT_SIZE; ProcessInfoPackage processInfoPkg = AnalyzerManager.getProject() - .getProcessInfo(pid); + .getProcessInfoPackage(pid); if (time > 0) { ProcessInfo processInfo = processInfoPkg.getProcessInfo(time); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ProfileData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ProfileData.java index da2a3c7..5a7ba01 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ProfileData.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ProfileData.java @@ -157,7 +157,7 @@ public class ProfileData extends LogData { } ProcessInfoPackage processInfoPkg = AnalyzerManager.getProject() - .getProcessInfo(pid); + .getProcessInfoPackage(pid); if (time > 0) { ProcessInfo processInfo = processInfoPkg.getProcessInfo(time); BinaryInfo binInfo = processInfo.getTargetBinary(pcAddr); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/callstack/CallstackTable.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/callstack/CallstackTable.java index 3eb4311..1d791d2 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/callstack/CallstackTable.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/callstack/CallstackTable.java @@ -105,19 +105,19 @@ public class CallstackTable extends DATableComposite { long time = -1; String libName = null; if (tableData.getType() == AnalyzerConstants.TYPE_TABLE_FAILED) { - List failedData = tableData.getData(); - seqNum = Integer.parseInt(failedData.get(0)); + List 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 leakData = tableData.getData(); - seqNum = Integer.parseInt(leakData.get(2)); + List 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(); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/callstack/CallstackView.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/callstack/CallstackView.java index 43bc451..bbcc807 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/callstack/CallstackView.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/callstack/CallstackView.java @@ -114,11 +114,11 @@ public class CallstackView extends DAViewComposite { DATableDataFormat tableData = (DATableDataFormat) selection[0] .getData(); if (tableData.getType() == AnalyzerConstants.TYPE_TABLE_FAILED) { - List failedData = tableData.getData(); - startTime = Long.parseLong(failedData.get(1)); + List failedData = tableData.getData(); + startTime = (Long) failedData.get(1); } else if (tableData.getType() == AnalyzerConstants.TYPE_TABLE_LEAK) { - List leakData = tableData.getData(); - startTime = Long.parseLong(leakData.get(4)); + List leakData = tableData.getData(); + startTime = (Long) leakData.get(4); } else { LogData startData = ((DATableDataFormat) selection[0] .getData()).getLogData(); @@ -129,11 +129,11 @@ public class CallstackView extends DAViewComposite { DATableDataFormat lastTableData = (DATableDataFormat) selection[0] .getData(); if (lastTableData.getType() == AnalyzerConstants.TYPE_TABLE_FAILED) { - List failedData = tableData.getData(); - endTime = Long.parseLong(failedData.get(1)); + List failedData = tableData.getData(); + endTime = (Long) failedData.get(1); } else if (lastTableData.getType() == AnalyzerConstants.TYPE_TABLE_LEAK) { - List leakData = tableData.getData(); - endTime = Long.parseLong(leakData.get(4)); + List leakData = tableData.getData(); + endTime = (Long) leakData.get(4); } else { LogData endData = ((DATableDataFormat) selection[selection.length - 1] .getData()).getLogData(); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/CallFlowChart.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/CallFlowChart.java index dad5c26..6edb26d 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/CallFlowChart.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/CallFlowChart.java @@ -42,7 +42,9 @@ import org.tizen.dynamicanalyzer.ui.common.PopupFromSelectionMenuItemClickListen 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; @@ -59,7 +61,8 @@ import org.tizen.dynamicanalyzer.widgets.popupMenu.DAPopupMenuItem; 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 seriesMap = null; public CallFlowChart(Composite parent, String title) { @@ -110,7 +113,7 @@ public class CallFlowChart extends DAChartBoard { public void updateChart() { // remove all previous items - if(dirty) { + if (dirty) { itemListClear(); if (seriesMap != null) { seriesMap.clear(); @@ -123,30 +126,30 @@ public class CallFlowChart extends DAChartBoard { update(); return; } - - if(dirty) { + + if (dirty) { // get data from db - List> funcnames = dataMaker.getFuncnameFromDB(selectedData - .getTid()); + List> 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(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; } @@ -162,7 +165,7 @@ public class CallFlowChart extends DAChartBoard { long starttime = (long) (getVisibleStartTime() * TimelineConstants.MEGA_DOUBLE); long endtime = (long) (getVisibleEndTime() * TimelineConstants.MEGA_DOUBLE); - List> functionData = dataMaker.getFunctionDataFromDB( + List> functionData = dataMaker.getFunctionDataFromDB( starttime, endtime, selectedData.getTid()); if (functionData == null || functionData.isEmpty()) { return; @@ -173,14 +176,14 @@ public class CallFlowChart extends DAChartBoard { int prevSeriesNum = -1; for (int i = 0; i < fsize; i++) { - List 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 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); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/ContextSwitchingChart.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/ContextSwitchingChart.java index 965e43f..6e37375 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/ContextSwitchingChart.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/ContextSwitchingChart.java @@ -44,7 +44,10 @@ import org.tizen.dynamicanalyzer.ui.common.PopupFromSelectionMenuItemClickListen 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; @@ -65,7 +68,8 @@ import org.tizen.dynamicanalyzer.widgets.popupMenu.DAPopupMenuItem; 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; @@ -184,25 +188,23 @@ public class ContextSwitchingChart extends DAChartBoard { long starttime = (long) (getVisibleStartTime() * TimelineConstants.MEGA_DOUBLE); long endtime = (long) (getVisibleEndTime() * TimelineConstants.MEGA_DOUBLE); - List> contextData = dataMaker.getContextDataFromDB( + List> contextData = dataMaker.getContextDataFromDB( starttime, endtime); - List> functionData = dataMaker.getFunctionDataFromDB( + List> functionData = dataMaker.getFunctionDataFromDB( starttime, endtime, -1); if (contextData != null) { int csize = contextData.size(); for (int i = 0; i < csize; i++) { - List 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 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); @@ -222,25 +224,21 @@ public class ContextSwitchingChart extends DAChartBoard { if (functionData != null) { int fsize = functionData.size(); for (int i = 0; i < fsize; i++) { - List 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 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); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/KernelListTable.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/KernelListTable.java index 5af41fd..ce1b3b3 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/KernelListTable.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/KernelListTable.java @@ -37,9 +37,11 @@ import org.eclipse.swt.widgets.Composite; 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; @@ -53,7 +55,7 @@ public class KernelListTable extends DAWindowingTableComposite { 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() { @@ -65,15 +67,15 @@ public class KernelListTable extends DAWindowingTableComposite { return; } int size = ti.length; - List startData = ((DATableDataFormat) ti[0].getData()) + List startData = ((DATableDataFormat) ti[0].getData()) .getData(); - List endData = ((DATableDataFormat) ti[size - 1] + List 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); } @@ -86,66 +88,65 @@ public class KernelListTable extends DAWindowingTableComposite { @Override protected List makeTableInput() { List input = new ArrayList(); - List> queriedData = getQueriedStringData(); + List> queriedData = getQueriedObjectData(); if (queriedData == null) { return null; } int size = queriedData.size(); for (int i = 0; i < size; i++) { - List row = queriedData.get(i); + List row = queriedData.get(i); List text = new ArrayList(); 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 @@ -212,15 +213,10 @@ public class KernelListTable extends DAWindowingTableComposite { 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(); } @@ -229,7 +225,7 @@ public class KernelListTable extends DAWindowingTableComposite { @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; @@ -237,9 +233,13 @@ public class KernelListTable extends DAWindowingTableComposite { 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 { @@ -249,7 +249,7 @@ public class KernelListTable extends DAWindowingTableComposite { @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; @@ -257,7 +257,7 @@ public class KernelListTable extends DAWindowingTableComposite { 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; @@ -273,7 +273,12 @@ public class KernelListTable extends DAWindowingTableComposite { @Override protected String getTimeColumnName() { - String timestr = DBTableManager.CUSTOM_COLUMN_START_TIME; + String timestr; + if (isCoreSelected) + timestr = ContextDataDBTable.STARTTIME; + else + timestr = FunctionDataDBTable.STARTTIME; + return timestr; } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/ContextDataDBInserter.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/ContextDataDBInserter.java index ab2af9f..c21fb03 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/ContextDataDBInserter.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/ContextDataDBInserter.java @@ -29,12 +29,10 @@ package org.tizen.dynamicanalyzer.ui.kernel.data; import java.util.List; import org.tizen.dynamicanalyzer.common.AnalyzerManager; -import org.tizen.dynamicanalyzer.sql.DBTableManager; -import org.tizen.dynamicanalyzer.sql.SqlManager; import org.tizen.dynamicanalyzer.swap.logparser.ReadBlockingQueue; public class ContextDataDBInserter implements Runnable { - private static ReadBlockingQueue>> contextDataQueue = new ReadBlockingQueue>>(); + private static ReadBlockingQueue>> contextDataQueue = new ReadBlockingQueue>>(); private static volatile Thread inserterThread = null; @@ -61,7 +59,7 @@ public class ContextDataDBInserter implements Runnable { } } - public static void pushContextData(List> data) { + public static void pushContextData(List> data) { contextDataQueue.offer(data); } @@ -72,17 +70,10 @@ public class ContextDataDBInserter implements Runnable { @Override public void run() { while (!AnalyzerManager.isExit()) { - List> contextData = contextDataQueue.poll(); + List> contextData = contextDataQueue.poll(); if (contextData != null) { - SqlManager - .getInstance() - .insertQuery( - DBTableManager - .getInstance() - .getTableInfo( - DBTableManager.TABLE_INDEX_CONTEXT_SWITCH_DATA) - .insertQuery(), contextData); + KernelDataManager.getInstance().getContextDataTable().insertData(contextData); } } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/ContextDataDBTable.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/ContextDataDBTable.java new file mode 100644 index 0000000..c902b4c --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/ContextDataDBTable.java @@ -0,0 +1,44 @@ +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)); + } + +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/FunctionDataDBInserter.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/FunctionDataDBInserter.java index a97f5b7..f15611e 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/FunctionDataDBInserter.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/FunctionDataDBInserter.java @@ -29,12 +29,10 @@ package org.tizen.dynamicanalyzer.ui.kernel.data; import java.util.List; import org.tizen.dynamicanalyzer.common.AnalyzerManager; -import org.tizen.dynamicanalyzer.sql.DBTableManager; -import org.tizen.dynamicanalyzer.sql.SqlManager; import org.tizen.dynamicanalyzer.swap.logparser.ReadBlockingQueue; public class FunctionDataDBInserter implements Runnable { - private static ReadBlockingQueue>> functionDataQueue = new ReadBlockingQueue>>(); + private static ReadBlockingQueue>> functionDataQueue = new ReadBlockingQueue>>(); private static volatile Thread inserterThread = null; @@ -61,7 +59,7 @@ public class FunctionDataDBInserter implements Runnable { } } - public static void pushFunctionData(List> data) { + public static void pushFunctionData(List> data) { functionDataQueue.offer(data); } @@ -72,17 +70,10 @@ public class FunctionDataDBInserter implements Runnable { @Override public void run() { while (!AnalyzerManager.isExit()) { - List> functionData = functionDataQueue.poll(); + List> functionData = functionDataQueue.poll(); if (functionData != null) { - SqlManager - .getInstance() - .insertQuery( - DBTableManager - .getInstance() - .getTableInfo( - DBTableManager.TABLE_INDEX_FUNCTION_CALL_DATA) - .insertQuery(), functionData); + KernelDataManager.getInstance().getFunctionDataTable().insertData(functionData); } } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/FunctionDataDBTable.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/FunctionDataDBTable.java new file mode 100644 index 0000000..e535565 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/FunctionDataDBTable.java @@ -0,0 +1,53 @@ +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)); + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataMaker.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataMaker.java index b4c9e4b..0ccf02e 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataMaker.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataMaker.java @@ -30,9 +30,7 @@ import java.util.ArrayList; 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; @@ -46,49 +44,18 @@ public class KernelDataMaker { 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 threads; - private ArrayList> contextDataList; - private ArrayList> functionDataList; + private ArrayList> contextDataList; + private ArrayList> functionDataList; public KernelDataMaker() { threads = new ArrayList(); - contextDataList = new ArrayList>(); - functionDataList = new ArrayList>(); - } - - public synchronized static KernelDataMaker getInstance() { - if (instance == null) { - instance = new KernelDataMaker(); - } - - return instance; + contextDataList = new ArrayList>(); + functionDataList = new ArrayList>(); } private KernelDataPerThread findKernelData(int tid) { @@ -167,15 +134,15 @@ public class KernelDataMaker { } else { kdata.setCorelog(null); - ArrayList dbdata = new ArrayList(); - 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 dbdata = new ArrayList(); + 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(); @@ -189,18 +156,17 @@ public class KernelDataMaker { ProfileData lastfunc = prefunc.peek(); int lastfunc_type = prefunc_type.peek(); - ArrayList dbfuncdata = new ArrayList(); - 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 dbfuncdata = new ArrayList(); + 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(); @@ -243,17 +209,17 @@ public class KernelDataMaker { ProfileData lastfunc = prefunc.peek(); int lastfunc_type = prefunc_type.peek(); - ArrayList dbfuncdata = new ArrayList(); - 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 dbfuncdata = new ArrayList(); + 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(); @@ -293,17 +259,17 @@ public class KernelDataMaker { assert (lastfunc.getApiName() == fndata.getApiName()); - ArrayList dbfuncdata = new ArrayList(); - 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 dbfuncdata = new ArrayList(); + 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(); @@ -324,11 +290,11 @@ public class KernelDataMaker { } @SuppressWarnings("unchecked") - List> clist = (List>) contextDataList.clone(); + List> clist = (List>) contextDataList.clone(); contextDataList.clear(); @SuppressWarnings("unchecked") - List> flist = (List>) functionDataList + List> flist = (List>) functionDataList .clone(); functionDataList.clear(); @@ -344,66 +310,41 @@ public class KernelDataMaker { functionDataList.clear(); } - public List> 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> 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> queriedContextData = sql.selectQuery(null, - csColumns, csTable.getTableName(), where); - - return queriedContextData; + return table.selectData(null, where); } - public List> getFunctionDataFromDB(long start, long end, + public List> 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> queriedFunctionData = sql.selectQuery(null, - fnColumns, fnTable.getTableName(), where); - - return queriedFunctionData; + return table.selectData(null, where); } - public List> 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> 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 selectColumn = new ArrayList(); + selectColumn.add(FunctionDataDBTable.FUNCNAME); - List> queriedFunctionName = sql.selectQuery(null, - qColumns, fnTable.getTableName(), where); + DBTable table = KernelDataManager.getInstance().getFunctionDataTable(); - return queriedFunctionName; + return table.selectData(selectColumn, where); } public List getThreadData() { diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataManager.java index 7ddca0a..1661c86 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataManager.java @@ -31,6 +31,7 @@ import java.util.Iterator; 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; @@ -41,9 +42,28 @@ import org.tizen.dynamicanalyzer.swap.model.data.LogDataTimeComparator; 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() { @@ -52,7 +72,7 @@ public class KernelDataManager extends PageDataManager { } return instance; } - + @Override public void run() { while (!AnalyzerManager.isExit()) { diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/range/RangeDataManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/range/RangeDataManager.java index f4208da..301266c 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/range/RangeDataManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/range/RangeDataManager.java @@ -439,7 +439,7 @@ public class RangeDataManager implements Runnable { .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(); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakTable.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakTable.java index c4d0fcd..c6ec289 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakTable.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakTable.java @@ -82,8 +82,8 @@ public class LeakTable extends DATreeComposite { 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) { diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/profiling/ProfileDataMaker.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/profiling/ProfileDataMaker.java index f35a1b6..f25d562 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/profiling/ProfileDataMaker.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/profiling/ProfileDataMaker.java @@ -275,7 +275,7 @@ public class ProfileDataMaker { String symbol = null; long pcAddr = sampleLog.getPcAddr(); ProcessInfoPackage processInfoPkg = AnalyzerManager - .getProject().getProcessInfo(sampleLog.getPid()); + .getProject().getProcessInfoPackage(sampleLog.getPid()); ProcessInfo processInfo = processInfoPkg.getProcessInfo(sampleLog .getTime()); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/calltrace/CallTraceTable.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/calltrace/CallTraceTable.java index 24f90e4..b0be205 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/calltrace/CallTraceTable.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/calltrace/CallTraceTable.java @@ -168,7 +168,7 @@ public class CallTraceTable extends DAWindowingTableComposite { int selectedPid = ToolbarArea.getInstance().getSelectedPid(); if (selectedPid != 0) { ProcessInfoPackage processInfoPkg = AnalyzerManager.getProject() - .getProcessInfo(selectedPid); + .getProcessInfoPackage(selectedPid); itemCount = processInfoPkg.getFunctionEntryInsertLogCount(); } else { Set> set = AnalyzerManager diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/userinterface/profiling/UIFunctionProfilingTable.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/userinterface/profiling/UIFunctionProfilingTable.java index 2dd0eba..fa87af9 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/userinterface/profiling/UIFunctionProfilingTable.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/userinterface/profiling/UIFunctionProfilingTable.java @@ -96,7 +96,7 @@ public class UIFunctionProfilingTable extends DATreeComposite { } 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); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/widgets/table/DATableDataFormat.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/widgets/table/DATableDataFormat.java index fe5a905..b5ce487 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/widgets/table/DATableDataFormat.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/widgets/table/DATableDataFormat.java @@ -36,7 +36,7 @@ public class DATableDataFormat { protected Object obj = null; protected long selectionKey = -1; protected int type = 0; - protected List data = new ArrayList(); + protected List data = new ArrayList(); public DATableDataFormat(long selectionKey) { this.selectionKey = selectionKey; @@ -70,7 +70,7 @@ public class DATableDataFormat { return type; } - public List getData() { + public List getData() { return data; } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/widgets/table/DAWindowingTableComposite.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/widgets/table/DAWindowingTableComposite.java index 9a3f3db..73eca33 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/widgets/table/DAWindowingTableComposite.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/widgets/table/DAWindowingTableComposite.java @@ -45,6 +45,7 @@ import org.eclipse.swt.widgets.Composite; 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; @@ -56,6 +57,8 @@ import org.tizen.dynamicanalyzer.util.CommonUtil; 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; @@ -73,7 +76,7 @@ public abstract class DAWindowingTableComposite extends DATableComposite { private int previousTableLength = 0; private List queriedLogData = null; - private List> queriedStringData = null; + private List> queriedObjectData = null; public DAWindowingTableComposite(Composite parent, int compStyle, int tableStyle) { @@ -170,8 +173,8 @@ public abstract class DAWindowingTableComposite extends DATableComposite { selectionStartTime = td.getLogData().getTime(); selectionEndTime = td.getLogData().getTime(); } else { - selectionStartTime = Long.parseLong(td.getData().get( - timeColumnIndex)); + selectionStartTime = (Long) td.getData().get( + timeColumnIndex); selectionEndTime = selectionStartTime; } @@ -262,8 +265,7 @@ public abstract class DAWindowingTableComposite extends DATableComposite { selectionStartTime = td.getLogData().getTime(); selectionEndTime = td.getLogData().getTime(); } else { - selectionStartTime = Long.parseLong(td.getData().get( - timeColumnIndex)); + selectionStartTime = (Long) td.getData().get(timeColumnIndex); selectionEndTime = selectionStartTime; } @@ -355,8 +357,7 @@ public abstract class DAWindowingTableComposite extends DATableComposite { 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; @@ -389,8 +390,11 @@ public abstract class DAWindowingTableComposite extends DATableComposite { totalItemCount = getItemCountByPid(); } else { if (totalItemCount == 0) { // open - totalItemCount = SqlManager.getInstance().getTableItemCount( + String query = String.format(queryto_GetItemCount, getDBTableName(), getSelectQueryCountOption()); + List> result = SqlConnectionManager + .executeQuery(query); + totalItemCount = (Integer) result.get(0).get(0); } else { // stop totalItemCount = getItemCountByPid(); } @@ -422,19 +426,19 @@ public abstract class DAWindowingTableComposite extends DATableComposite { 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> getStringDataFromDB(int itemCount) { + private List> getObjectDataFromDB(int itemCount) { int scrollSelection = vScrollbar.getSelection(); if (scrollSelection > itemCount) { // change PID scrollSelection = 0; @@ -443,10 +447,21 @@ public abstract class DAWindowingTableComposite extends DATableComposite { if (itemCount <= selectedEndIndex) { selectedEndIndex = itemCount; } - List> outputList = SqlManager.getInstance().selectQuery3( - null, getDBTableColumnNames(), getDBTableName(), - scrollSelection, selectedEndIndex + 1, getSelectQueryOption()); - return outputList; + + StringBuffer columnString = new StringBuffer(); + List 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 getLogDataFromDB(int itemCount) { @@ -473,7 +488,7 @@ public abstract class DAWindowingTableComposite extends DATableComposite { selectionStartTime = -1; selectionEndTime = -1; queriedLogData = null; - queriedStringData = null; + queriedObjectData = null; totalItemCount = 0; } @@ -487,9 +502,8 @@ public abstract class DAWindowingTableComposite extends DATableComposite { .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) { @@ -504,8 +518,8 @@ public abstract class DAWindowingTableComposite extends DATableComposite { return queriedLogData; } - protected List> getQueriedStringData() { - return queriedStringData; + protected List> getQueriedObjectData() { + return queriedObjectData; } public void setSelectionByTime(long startTime, long endTime) { diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/widgets/table/DefaultTableComparator.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/widgets/table/DefaultTableComparator.java index 78544d6..3d300b5 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/widgets/table/DefaultTableComparator.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/widgets/table/DefaultTableComparator.java @@ -74,11 +74,11 @@ public class DefaultTableComparator implements Comparator, Serializable DATableDataFormat tableData1 = (DATableDataFormat) item1.getData(); DATableDataFormat tableData2 = (DATableDataFormat) item2.getData(); - List data1 = tableData1.getData(); - List data2 = tableData2.getData(); + List data1 = tableData1.getData(); + List data2 = tableData2.getData(); - str1 = data1.get(column); - str2 = data2.get(column); + str1 = data1.get(column).toString(); + str2 = data2.get(column).toString(); } else { List text1 = item1.getText(); List text2 = item2.getText(); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/utils/AnalyzerUtil.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/utils/AnalyzerUtil.java index af124f1..7a49679 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/utils/AnalyzerUtil.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/utils/AnalyzerUtil.java @@ -391,7 +391,7 @@ public class AnalyzerUtil { 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(); @@ -409,7 +409,7 @@ public class AnalyzerUtil { 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; @@ -424,7 +424,7 @@ public class AnalyzerUtil { // 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; -- 2.7.4