From 6f4d1bc408cf29287233f20f8ffadf5b117ff60c Mon Sep 17 00:00:00 2001 From: "seokgil.kang" Date: Mon, 2 Jun 2014 22:23:04 +0900 Subject: [PATCH] Summary : add missing files (save Failed API / Warning / Leak information to DB in runtime) and remove some comments Change-Id: Ieda6092cfaf128ce2e954d7879f85c446da5446b Signed-off-by: seokgil.kang --- .../dynamicanalyzer/common/AnalyzerManager.java | 10 +- .../dynamicanalyzer/ui/file/FileDataMaker.java | 14 +- .../ui/opengl/data/GLDataManager.java | 1 - .../ui/summary/SummaryDataManager.java | 103 ++++++++ .../ui/summary/failed/FailedApiDataDBInserter.java | 64 +++++ .../ui/summary/failed/FailedApiDataDBTable.java | 85 ++++++ .../ui/summary/failed/FailedApiDataMaker.java | 118 +++++++++ .../ui/summary/failed/FailedApiTable.java | 4 +- .../ui/summary/leaks/CurrentLeakData.java | 39 +++ .../ui/summary/leaks/FreeDataDBInserter.java | 64 +++++ .../ui/summary/leaks/FreeDataDBTable.java | 61 +++++ .../ui/summary/leaks/LeakDataMaker.java | 170 ++++++++++++ .../ui/summary/leaks/LeakTable.java | 30 +-- .../leaks/MemoryAllocationDataDBInserter.java | 64 +++++ .../summary/leaks/MemoryAllocationDataDBTable.java | 104 ++++++++ .../ui/summary/leaks/NewLeakDetector.java | 284 +++++++++++++++++++++ .../ui/summary/warning/WarningCase.java | 22 ++ .../ui/summary/warning/WarningDataDBInserter.java | 64 +++++ .../ui/summary/warning/WarningDataDBTable.java | 77 ++++++ .../ui/summary/warning/WarningDataMaker.java | 181 +++++++++++++ .../ui/summary/warning/WarningDetailView.java | 2 +- .../ui/summary/warning/WarningTable.java | 15 +- .../dynamicanalyzer/ui/thread/ThreadPageData.java | 1 - .../thread/thread/ThreadPageThreadDataManager.java | 2 - 24 files changed, 1533 insertions(+), 46 deletions(-) create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/SummaryDataManager.java create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedApiDataDBInserter.java create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedApiDataDBTable.java create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedApiDataMaker.java create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/CurrentLeakData.java create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/FreeDataDBInserter.java create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/FreeDataDBTable.java create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakDataMaker.java create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/MemoryAllocationDataDBInserter.java create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/MemoryAllocationDataDBTable.java create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/NewLeakDetector.java create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningDataDBInserter.java create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningDataDBTable.java create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningDataMaker.java diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/AnalyzerManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/AnalyzerManager.java index 53880f4..7c7fac2 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/AnalyzerManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/AnalyzerManager.java @@ -50,7 +50,7 @@ import org.tizen.dynamicanalyzer.ui.page.BaseView; import org.tizen.dynamicanalyzer.ui.range.RangeDataManager; import org.tizen.dynamicanalyzer.ui.summary.failed.FailedChecker; import org.tizen.dynamicanalyzer.ui.summary.leaks.LeakDetector; -import org.tizen.dynamicanalyzer.ui.summary.leaks.LeakDetector2; +import org.tizen.dynamicanalyzer.ui.summary.leaks.NewLeakDetector; import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler; import org.tizen.dynamicanalyzer.ui.summary.warning.WarningChecker; import org.tizen.dynamicanalyzer.ui.toolbar.ConfigureManager; @@ -76,7 +76,7 @@ public class AnalyzerManager { private static HashMap> funcNameMapByPid = null; private static LeakDetector leakDetector = new LeakDetector(); - private static LeakDetector2 leakDetector2 = new LeakDetector2(); // add 201405 + private static NewLeakDetector newLeakDetector = new NewLeakDetector(); private static FailedChecker failedChecker = new FailedChecker(); private static FailedChecker calledChecker = new FailedChecker(); private static WarningChecker warningChecker = new WarningChecker(); @@ -160,7 +160,7 @@ public class AnalyzerManager { imageListSize = 0; leakDetector.clear(); - leakDetector2.clear(); // add 201405 + newLeakDetector.clear(); failedChecker.clear(); warningChecker.clear(); calledChecker.clear(); @@ -270,8 +270,8 @@ public class AnalyzerManager { return leakDetector; } - public static LeakDetector2 getLeakDetector2() { // add 201405 - return leakDetector2; + public static NewLeakDetector getNewLeakDetector() { + return newLeakDetector; } public static FailedChecker getFailedChecker() { diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/FileDataMaker.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/FileDataMaker.java index e161209..a770b9e 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/FileDataMaker.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/FileDataMaker.java @@ -226,16 +226,15 @@ public class FileDataMaker { FileChartDataEvent event = fileEventWarningQueue.get(i); if ((event.getFilePath().equals(data.getFilePath())) && (event.getApiType() == LogCenterConstants.FD_API_TYPE_OPEN)) { - if (!warningChecker.isChecked(data.getFilePath(), - WarningCase.DUPLICATE_OPEN.getType())) { +// if (!warningChecker.isChecked(data.getFilePath(), +// WarningCase.DUPLICATE_OPEN.getType())) { // WarningData wData = new WarningData( // WarningCase.DUPLICATE_OPEN.getType(), // data.getContents(), data.getFilePath()); // warningChecker.getWarningData().add(wData); - // add 201405 SummaryDataManager.getInstance().getWarningDataMaker().makeData( data.getContents(), data.getFilePath(), WarningCase.DUPLICATE_OPEN.getType()); - } +// } } } } @@ -255,16 +254,15 @@ public class FileDataMaker { if ((nAPICount < 3) && (data.getFilePath().equals(AnalyzerLabels.EMPTY_STRING) == false)) { // open-close - if (!warningChecker.isChecked(data.getFilePath(), - WarningCase.WITHOUT_USING.getType())) { +// if (!warningChecker.isChecked(data.getFilePath(), +// WarningCase.WITHOUT_USING.getType())) { // WarningData wData = new WarningData( // WarningCase.WITHOUT_USING.getType(), // data.getContents(), data.getFilePath()); // warningChecker.getWarningData().add(wData); - // add 201405 SummaryDataManager.getInstance().getWarningDataMaker().makeData( data.getContents(), data.getFilePath(), WarningCase.WITHOUT_USING.getType()); - } +// } } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/opengl/data/GLDataManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/opengl/data/GLDataManager.java index b840561..ad0d7de 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/opengl/data/GLDataManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/opengl/data/GLDataManager.java @@ -163,7 +163,6 @@ public class GLDataManager extends PageDataManager { && logData.getErrno() != GLES20ErrorDefine.GL_SUCCESS) { // FailedData ffd = new FailedData(logData); // AnalyzerManager.getFailedChecker().getFailedList().add(ffd); - // add 201405 SummaryDataManager.getInstance().getFailedApiDataMaker().makeData(logData); } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/SummaryDataManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/SummaryDataManager.java new file mode 100644 index 0000000..5fad3c0 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/SummaryDataManager.java @@ -0,0 +1,103 @@ +package org.tizen.dynamicanalyzer.ui.summary; + +import java.util.List; + +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; +import org.tizen.dynamicanalyzer.swap.logparser.PageDataManager; +import org.tizen.dynamicanalyzer.swap.model.data.LogData; +import org.tizen.dynamicanalyzer.ui.summary.failed.FailedApiDataDBTable; +import org.tizen.dynamicanalyzer.ui.summary.failed.FailedApiDataMaker; +import org.tizen.dynamicanalyzer.ui.summary.leaks.FreeDataDBTable; +import org.tizen.dynamicanalyzer.ui.summary.leaks.LeakDataMaker; +import org.tizen.dynamicanalyzer.ui.summary.leaks.MemoryAllocationDataDBTable; +import org.tizen.dynamicanalyzer.ui.summary.warning.WarningDataDBTable; +import org.tizen.dynamicanalyzer.ui.summary.warning.WarningDataMaker; +import org.tizen.dynamicanalyzer.util.DALogger; + +public class SummaryDataManager extends PageDataManager { + private static final DALogger DA_LOG = DALogger.getInstance(); + + private static SummaryDataManager instance = null; + private LeakDataMaker leakDataMaker = null; + private FailedApiDataMaker failedApiDataMaker = null; + private WarningDataMaker warningDataMaker = null; + + private MemoryAllocationDataDBTable memoryAllocationDataTable = null; + private FreeDataDBTable freeDataTable = null; + private FailedApiDataDBTable failedApiDataTable = null; + private WarningDataDBTable warningDataDBTable = null; + + private SummaryDataManager() { + leakDataMaker = new LeakDataMaker(); + failedApiDataMaker = new FailedApiDataMaker(); + warningDataMaker = new WarningDataMaker(); + memoryAllocationDataTable = new MemoryAllocationDataDBTable(); + addDBTable(memoryAllocationDataTable); + freeDataTable = new FreeDataDBTable(); + addDBTable(freeDataTable); + failedApiDataTable = new FailedApiDataDBTable(); + addDBTable(failedApiDataTable); + warningDataDBTable = new WarningDataDBTable(); + addDBTable(warningDataDBTable); + } + + public LeakDataMaker getLeakDataMaker() { + return leakDataMaker; + } + + public FailedApiDataMaker getFailedApiDataMaker() { + return failedApiDataMaker; + } + + public WarningDataMaker getWarningDataMaker() { + return warningDataMaker; + } + + public DBTable getMemoryAllocationDataDBTable() { + return memoryAllocationDataTable; + } + + public DBTable getFreeDataDBTable() { + return freeDataTable; + } + + public DBTable getFailedApiDataDBTable() { + return failedApiDataTable; + } + + public DBTable getWarningDataDBTable() { + return warningDataDBTable; + } + + public synchronized static SummaryDataManager getInstance() { + if (null == instance) { + instance = new SummaryDataManager(); + } + return instance; + } + + public void clear() { + leakDataMaker.clear(); + } + + @Override + protected void makeData(LogPackage pack) { + Logs memoryLogs = pack.getLogs(DataChannelConstants.MSG_PROBE_MEMORY); + if (null != memoryLogs && memoryLogs.getRawLogs().size() != 0) { + List inputs = memoryLogs.getLogs(); + + leakDataMaker.makeData(inputs); + } + + Logs fileLogs = pack.getLogs(DataChannelConstants.MSG_PROBE_FILE); + if (null != fileLogs && fileLogs.getRawLogs().size() != 0) { + List inputs = fileLogs.getLogs(); + + leakDataMaker.makeData(inputs); + } + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedApiDataDBInserter.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedApiDataDBInserter.java new file mode 100644 index 0000000..7ab6f4e --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedApiDataDBInserter.java @@ -0,0 +1,64 @@ +package org.tizen.dynamicanalyzer.ui.summary.failed; + +import java.util.List; + +import org.tizen.dynamicanalyzer.common.AnalyzerConstants; +import org.tizen.dynamicanalyzer.common.AnalyzerManager; +import org.tizen.dynamicanalyzer.swap.logparser.ReadBlockingQueue; +import org.tizen.dynamicanalyzer.ui.summary.SummaryDataManager; + +public class FailedApiDataDBInserter implements Runnable { + private static ReadBlockingQueue>> FailedApiDataQueue = new ReadBlockingQueue>>(); + + private static volatile Thread inserterThread = null; + + public static void startThread() { + if (inserterThread == null || !inserterThread.isAlive()) { + synchronized (FailedApiDataDBInserter.class) { + if (inserterThread == null || !inserterThread.isAlive()) { + inserterThread = new Thread(null, + new FailedApiDataDBInserter()); + inserterThread.start(); + } + } + } + } + + public static void stopThread() { + if (inserterThread != null && inserterThread.isAlive()) { + try { + sendNotify(); + inserterThread.join(AnalyzerConstants.THREAD_JOIN_WAIT_TIME); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + } + + public static void pushFunctionData(List> data) { + FailedApiDataQueue.offer(data); + } + + public static void clear() { + stopThread(); + } + + @Override + public void run() { + while (!AnalyzerManager.isExit()) { + List> failedApiData = FailedApiDataQueue.poll(); + + if (failedApiData != null && failedApiData.size() != 0) { + SummaryDataManager.getInstance().getFailedApiDataDBTable() + .insertData(failedApiData); + } + } + } + + public static void sendNotify() { +// synchronized (FailedApiDataQueue) { +// FailedApiDataQueue.notifyAll(); +// } + FailedApiDataQueue.wake(); + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedApiDataDBTable.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedApiDataDBTable.java new file mode 100644 index 0000000..63d480c --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedApiDataDBTable.java @@ -0,0 +1,85 @@ +package org.tizen.dynamicanalyzer.ui.summary.failed; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.util.List; + +import org.tizen.dynamicanalyzer.database.DBColumn; +import org.tizen.dynamicanalyzer.database.DBConstants; +import org.tizen.dynamicanalyzer.database.DBTable; + +public class FailedApiDataDBTable extends DBTable { + private static final String TABLENAME = "FailedAPIData"; + + public static final String SEQ = DBConstants.COMMON_COLUMN_SEQ; +// public static final String API_ID = "ApiID"; + public static final String API_NAME = "ApiName"; + public static final String PID = DBConstants.COMMON_COLUMN_PID; + public static final String START_TIME = "StartTime"; + public static final String ARGUMENT = "Parameter"; + public static final String RETURN = "Return"; + public static final String ERROR_CODE = "ErrorCode"; + public static final String CALLER_PC_ADDRESS = "CallerPcAddress"; + public static final String LIBRARY_NAME = "LibraryName"; + public static final String MESSAGE_ID = "MessageID"; + + public final static int COLUMN_INDEX_SEQ = 0; +// public final static int COLUMN_INDEX_API_ID = 1; + public final static int COLUMN_INDEX_API_NAME = 1; + public final static int COLUMN_INDEX_PID = 2; + public final static int COLUMN_INDEX_START_TIME = 3; + public final static int COLUMN_INDEX_ARGUMENT = 4; + public final static int COLUMN_INDEX_RETURN = 5; + public final static int COLUMN_INDEX_ERROR_CODE = 6; + public final static int COLUMN_INDEX_CALLER_PC_ADDRESS = 7; + public final static int COLUMN_INDEX_LIBRARY_NAME = 8; + public final static int COLUMN_INDEX_MESSAGE_ID = 9; + + @Override + public String getTableName() { + return TABLENAME; + } + + public FailedApiDataDBTable() { + addColumn(new DBColumn(SEQ, DBConstants.PRIMARY_KEY, DBConstants.INTEGER)); +// addColumn(new DBColumn(API_ID, DBConstants.NOT_NULL, DBConstants.INTEGER)); + addColumn(new DBColumn(API_NAME, DBConstants.NOT_NULL, DBConstants.TEXT)); + addColumn(new DBColumn(PID, DBConstants.NOT_NULL, DBConstants.INTEGER)); + addColumn(new DBColumn(START_TIME, DBConstants.NOT_NULL, DBConstants.LONG)); + addColumn(new DBColumn(ARGUMENT, DBConstants.EMPTY, DBConstants.TEXT)); + addColumn(new DBColumn(RETURN, DBConstants.NOT_NULL, DBConstants.TEXT)); + addColumn(new DBColumn(ERROR_CODE, DBConstants.NOT_NULL, DBConstants.LONG)); + addColumn(new DBColumn(CALLER_PC_ADDRESS, DBConstants.NOT_NULL, DBConstants.LONG)); + addColumn(new DBColumn(LIBRARY_NAME, DBConstants.NOT_NULL, DBConstants.TEXT)); + addColumn(new DBColumn(MESSAGE_ID, DBConstants.NOT_NULL, DBConstants.INTEGER)); + } + + @Override + public boolean prepare(PreparedStatement prep, List rowData) { + boolean isPrepared = true; + + int columnsize = getColumnSize(); + if (columnsize != rowData.size()) { + isPrepared = false; + } else { + try { + prep.setInt(1, (Integer) (rowData.get(0))); +// prep.setInt(2, (Integer) (rowData.get(1))); + prep.setString(2, (String) (rowData.get(1))); + prep.setInt(3, (Integer) (rowData.get(2))); + prep.setLong(4, (Long) (rowData.get(3))); + prep.setString(5, (String) (rowData.get(4))); + prep.setString(6, (String) (rowData.get(5))); + prep.setLong(7, (Long) (rowData.get(6))); + prep.setLong(8, (Long) (rowData.get(7))); + prep.setString(9, (String) (rowData.get(8))); + prep.setInt(10, (Integer) (rowData.get(9))); + } catch (SQLException e) { + e.printStackTrace(); + isPrepared = false; + } + } + + return isPrepared; + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedApiDataMaker.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedApiDataMaker.java new file mode 100644 index 0000000..485cafd --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedApiDataMaker.java @@ -0,0 +1,118 @@ +package org.tizen.dynamicanalyzer.ui.summary.failed; + +import java.util.ArrayList; +import java.util.List; + +import org.tizen.dynamicanalyzer.database.DBTable; +import org.tizen.dynamicanalyzer.swap.channel.data.ApiNameManager; +import org.tizen.dynamicanalyzer.swap.model.data.LogData; +import org.tizen.dynamicanalyzer.swap.model.data.ProbeCommonData; +import org.tizen.dynamicanalyzer.ui.summary.SummaryDataManager; +import org.tizen.dynamicanalyzer.util.DALogger; + +public class FailedApiDataMaker { + private static final DALogger DA_LOG = DALogger.getInstance(); + +// private static final String queryto_withTime = "where %s < %s and %s > %s order by %s"; +// private static final String queryto_withTidAndTime = "where %s = %s and %s < %s and %s > %s order by %s"; +// private static final String queryto_withTid = "where %s = %s group by %s"; + +// private static final String query_withId = "where %s = %s"; + + private ArrayList> failedApiDataList; + + public FailedApiDataMaker() { + failedApiDataList = new ArrayList>(); + } + + public void makeData(List inputs) { + int size = inputs.size(); + for (int i = 0; i < size; i++) { + LogData input = (LogData) inputs.get(i); + ProbeCommonData pData = (ProbeCommonData) input; + + if (failChecker(pData)) { + ArrayList dbFailedData = new ArrayList(); + + dbFailedData.add(Integer.valueOf(pData.getSeq())); + dbFailedData.add(String.valueOf(ApiNameManager.getApiName(pData.getApiId()))); + dbFailedData.add(Integer.valueOf(pData.getPid())); + dbFailedData.add(Long.valueOf(pData.getTime())); + dbFailedData.add(String.valueOf(pData.getArgs())); + dbFailedData.add(String.valueOf(pData.getReturn())); + dbFailedData.add(Long.valueOf(pData.getErrno())); + dbFailedData.add(Long.valueOf(pData.getCallerPcAddr())); + dbFailedData.add(String.valueOf(pData.getLibName())); + dbFailedData.add(Integer.valueOf(pData.getId())); + + failedApiDataList.add(dbFailedData); + } + } + + if (failedApiDataList.size() > 0) { + @SuppressWarnings("unchecked") + List> fList = (List>) failedApiDataList.clone(); + failedApiDataList.clear(); + + FailedApiDataDBInserter.pushFunctionData(fList); + FailedApiDataDBInserter.startThread(); + } + } + + public void makeData(LogData input) { + ProbeCommonData pData = (ProbeCommonData) input; + + if (failChecker(pData)) { + ArrayList dbFailedData = new ArrayList(); + + dbFailedData.add(Integer.valueOf(pData.getSeq())); + dbFailedData.add(String.valueOf(ApiNameManager.getApiName(pData.getApiId()))); + dbFailedData.add(Integer.valueOf(pData.getPid())); + dbFailedData.add(Long.valueOf(pData.getTime())); + dbFailedData.add(String.valueOf(pData.getArgs())); + dbFailedData.add(String.valueOf(pData.getReturn())); + dbFailedData.add(Long.valueOf(pData.getErrno())); + dbFailedData.add(Long.valueOf(pData.getCallerPcAddr())); + dbFailedData.add(String.valueOf(pData.getLibName())); + dbFailedData.add(Integer.valueOf(pData.getId())); + + failedApiDataList.add(dbFailedData); + + @SuppressWarnings("unchecked") + List> mList = (List>) failedApiDataList.clone(); + failedApiDataList.clear(); + + FailedApiDataDBInserter.pushFunctionData(mList); + FailedApiDataDBInserter.startThread(); + } + } + + private boolean failChecker(ProbeCommonData log) { + if (log.isInternal()) { + return false; + } else { + return true; + } + } + + public void clear() { + failedApiDataList.clear(); + } + + public List> getFailedApiDataFromDB() { + DBTable table = SummaryDataManager.getInstance().getFailedApiDataDBTable(); + List columns = new ArrayList(); + columns.add(FailedApiDataDBTable.SEQ); + columns.add(FailedApiDataDBTable.API_NAME); + columns.add(FailedApiDataDBTable.PID); + columns.add(FailedApiDataDBTable.START_TIME); + columns.add(FailedApiDataDBTable.ARGUMENT); + columns.add(FailedApiDataDBTable.RETURN); + columns.add(FailedApiDataDBTable.ERROR_CODE); + columns.add(FailedApiDataDBTable.CALLER_PC_ADDRESS); + columns.add(FailedApiDataDBTable.LIBRARY_NAME); + columns.add(FailedApiDataDBTable.MESSAGE_ID); + + return table.selectData(columns, null); + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedApiTable.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedApiTable.java index 8c91497..37afefa 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedApiTable.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedApiTable.java @@ -55,7 +55,6 @@ public class FailedApiTable extends DATableComposite { private boolean isRange = false; - // add 201405 private final FailedApiDataMaker failedApiDataMaker = SummaryDataManager.getInstance().getFailedApiDataMaker(); @@ -188,7 +187,6 @@ public class FailedApiTable extends DATableComposite { // return input; // } - // add 201405 protected List makeTableInput() { // List failedList = null; // if (isRange) { @@ -227,7 +225,7 @@ public class FailedApiTable extends DATableComposite { String apiName = (String)idata.get(FailedApiDataDBTable.COLUMN_INDEX_API_NAME); text.add(apiName); data.add(apiName); - // 3 : argurments + // 3 : arguments String args = (String)idata.get(FailedApiDataDBTable.COLUMN_INDEX_ARGUMENT); text.add(args); data.add(args); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/CurrentLeakData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/CurrentLeakData.java new file mode 100644 index 0000000..4ec85e0 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/CurrentLeakData.java @@ -0,0 +1,39 @@ +package org.tizen.dynamicanalyzer.ui.summary.leaks; + +import org.tizen.dynamicanalyzer.swap.model.data.FileData; +import org.tizen.dynamicanalyzer.swap.model.data.LogData; +import org.tizen.dynamicanalyzer.swap.model.data.MemoryData; + +public class CurrentLeakData { + private int seqNum = -1; + private long allocValue = -1; + private int pid = -1; + + public CurrentLeakData(LogData log) { + this.seqNum = log.getSeq(); + if (log instanceof MemoryData) { + this.allocValue = ((MemoryData) log).getAddress(); + } else if (log instanceof FileData) { + this.allocValue = ((FileData) log).getFdValue(); + } + this.pid = log.getPid(); + } + + public CurrentLeakData(int seqNumber, long allocValue, int pid) { + this.seqNum = seqNumber; + this.allocValue = allocValue; + this.pid = pid; + } + + public int getSequenceNumber() { + return seqNum; + } + + public long getAllocatedValue() { + return allocValue; + } + + public int getPid() { + return pid; + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/FreeDataDBInserter.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/FreeDataDBInserter.java new file mode 100644 index 0000000..0a3be1e --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/FreeDataDBInserter.java @@ -0,0 +1,64 @@ +package org.tizen.dynamicanalyzer.ui.summary.leaks; + +import java.util.List; + +import org.tizen.dynamicanalyzer.common.AnalyzerConstants; +import org.tizen.dynamicanalyzer.common.AnalyzerManager; +import org.tizen.dynamicanalyzer.swap.logparser.ReadBlockingQueue; +import org.tizen.dynamicanalyzer.ui.summary.SummaryDataManager; + +public class FreeDataDBInserter implements Runnable { + private static ReadBlockingQueue>> FreeDataQueue = new ReadBlockingQueue>>(); + + private static volatile Thread inserterThread = null; + + public static void startThread() { + if (inserterThread == null || !inserterThread.isAlive()) { + synchronized (FreeDataDBInserter.class) { + if (inserterThread == null || !inserterThread.isAlive()) { + inserterThread = new Thread(null, + new FreeDataDBInserter()); + inserterThread.start(); + } + } + } + } + + public static void stopThread() { + if (inserterThread != null && inserterThread.isAlive()) { + try { + sendNotify(); + inserterThread.join(AnalyzerConstants.THREAD_JOIN_WAIT_TIME); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + } + + public static void pushFunctionData(List> data) { + FreeDataQueue.offer(data); + } + + public static void clear() { + stopThread(); + } + + @Override + public void run() { + while (!AnalyzerManager.isExit()) { + List> freeData = FreeDataQueue.poll(); + + if (freeData != null && freeData.size() != 0) { + SummaryDataManager.getInstance().getFreeDataDBTable() + .insertData(freeData); + } + } + } + + public static void sendNotify() { +// synchronized (FreeDataQueue) { +// FreeDataQueue.notifyAll(); +// } + FreeDataQueue.wake(); + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/FreeDataDBTable.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/FreeDataDBTable.java new file mode 100644 index 0000000..ef223ff --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/FreeDataDBTable.java @@ -0,0 +1,61 @@ +package org.tizen.dynamicanalyzer.ui.summary.leaks; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.util.List; + +import org.tizen.dynamicanalyzer.database.DBColumn; +import org.tizen.dynamicanalyzer.database.DBConstants; +import org.tizen.dynamicanalyzer.database.DBTable; + +public class FreeDataDBTable extends DBTable { + private static final String TABLENAME = "FreeData"; + + public static final String SEQ = DBConstants.COMMON_COLUMN_SEQ; + public static final String PID = DBConstants.COMMON_COLUMN_PID; + public static final String MESSAGE_ID = DBConstants.COMMON_COLUMN_ID; + public static final String FREE_TIME = "FreeTime"; + public static final String ALLOCATED_ADDRESS = "AllocatedAddress"; + + public final static int COLUMN_INDEX_SEQ = 0; + public final static int COLUMN_INDEX_PID = 1; + public final static int COLUMN_INDEX_FREE_TIME = 2; + public final static int COLUMN_INDEX_MESSAGE_ID = 3; + public final static int COLUMN_INDEX_ALLOCATED_ADDRESS = 4; + + @Override + public String getTableName() { + return TABLENAME; + } + + public FreeDataDBTable() { + addColumn(new DBColumn(SEQ, DBConstants.PRIMARY_KEY, DBConstants.INTEGER)); + addColumn(new DBColumn(PID, DBConstants.NOT_NULL, DBConstants.INTEGER)); + addColumn(new DBColumn(MESSAGE_ID, DBConstants.NOT_NULL, DBConstants.INTEGER)); + addColumn(new DBColumn(FREE_TIME, DBConstants.NOT_NULL, DBConstants.LONG)); // default : 0 + addColumn(new DBColumn(ALLOCATED_ADDRESS, DBConstants.NOT_NULL, DBConstants.LONG)); + } + + @Override + public boolean prepare(PreparedStatement prep, List rowData) { + boolean isPrepared = true; + + int columnsize = getColumnSize(); + if (columnsize != rowData.size()) { + isPrepared = false; + } else { + try { + prep.setInt(1, (Integer) (rowData.get(0))); + prep.setInt(2, (Integer) (rowData.get(1))); + prep.setInt(3, (Integer) (rowData.get(2))); + prep.setLong(4, (Long) (rowData.get(3))); + prep.setLong(5, (Long) (rowData.get(4))); + } catch (SQLException e) { + e.printStackTrace(); + isPrepared = false; + } + } + + return isPrepared; + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakDataMaker.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakDataMaker.java new file mode 100644 index 0000000..d85c889 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakDataMaker.java @@ -0,0 +1,170 @@ +package org.tizen.dynamicanalyzer.ui.summary.leaks; + +import java.util.ArrayList; +import java.util.List; + +import org.tizen.dynamicanalyzer.common.AnalyzerManager; +import org.tizen.dynamicanalyzer.database.DBConstants; +import org.tizen.dynamicanalyzer.database.DBTable; +import org.tizen.dynamicanalyzer.logparser.LogCenterConstants; +import org.tizen.dynamicanalyzer.swap.channel.data.ApiNameManager; +import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants; +import org.tizen.dynamicanalyzer.swap.model.data.FileData; +import org.tizen.dynamicanalyzer.swap.model.data.LogData; +import org.tizen.dynamicanalyzer.swap.model.data.MemoryData; +import org.tizen.dynamicanalyzer.ui.summary.SummaryDataManager; +import org.tizen.dynamicanalyzer.util.DALogger; + +public class LeakDataMaker { + private static final DALogger DA_LOG = DALogger.getInstance(); + + private static final String query_withSeq = "where %s = %s"; + + private ArrayList> memoryAllocDataList; + private ArrayList> freeDataList; + private NewLeakDetector leakDetector = AnalyzerManager.getNewLeakDetector(); + + public LeakDataMaker() { + memoryAllocDataList = new ArrayList>(); + freeDataList = new ArrayList>(); + } + + public void makeData(List inputs) { + int size = inputs.size(); + for (int i = 0; i < size; i++) { + LogData input = (LogData) inputs.get(i); + + switch (leakDetector.runLeakDetect(input)) { + case LogCenterConstants.MEMORY_API_ALLOC: // alloc, realloc + makeAllocData(input); + break; + case LogCenterConstants.MEMORY_API_FREE: // free + makeFreeData(input); + break; + case -1: + default: + break; + } + } + + if (memoryAllocDataList.size() > 0) { + @SuppressWarnings("unchecked") + List> mList = (List>) memoryAllocDataList.clone(); + memoryAllocDataList.clear(); + + MemoryAllocationDataDBInserter.pushFunctionData(mList); + MemoryAllocationDataDBInserter.startThread(); + } + + if (freeDataList.size() > 0) { + @SuppressWarnings("unchecked") + List> fList = (List>) freeDataList.clone(); + freeDataList.clear(); + + FreeDataDBInserter.pushFunctionData(fList); + FreeDataDBInserter.startThread(); + } + } + + public void makeAllocData(LogData log) { + ArrayList dbAllocData = new ArrayList(); + + switch (log.getId()) { + case DataChannelConstants.MSG_PROBE_MEMORY: { + MemoryData mData = (MemoryData) log; + + dbAllocData.add(Integer.valueOf(mData.getSeq())); + dbAllocData.add(Integer.valueOf(mData.getPid())); + dbAllocData.add(String.valueOf(ApiNameManager.getApiName(mData.getApiId()))); + dbAllocData.add(Integer.valueOf(mData.getMemoryApiType())); + dbAllocData.add(Long.valueOf(mData.getAddress())); + dbAllocData.add(Long.valueOf(mData.getTime())); + dbAllocData.add(Long.valueOf(mData.getCallerPcAddr())); + dbAllocData.add(String.valueOf(mData.getArgs())); + dbAllocData.add(String.valueOf(mData.getReturn())); + dbAllocData.add(String.valueOf(mData.getLibName())); + dbAllocData.add(Integer.valueOf(mData.getId())); + dbAllocData.add(Integer.valueOf(mData.getTid())); + dbAllocData.add(Long.valueOf(mData.getSize())); + break; + } + case DataChannelConstants.MSG_PROBE_FILE: { + FileData fData = (FileData) log; + + dbAllocData.add(Integer.valueOf(fData.getSeq())); + dbAllocData.add(Integer.valueOf(fData.getPid())); + dbAllocData.add(String.valueOf(ApiNameManager.getApiName(fData.getApiId()))); + dbAllocData.add(Integer.valueOf(fData.getFdApiType())); + dbAllocData.add(Long.valueOf(-1)); // default value + dbAllocData.add(Long.valueOf(fData.getTime())); + dbAllocData.add(Long.valueOf(fData.getCallerPcAddr())); + dbAllocData.add(String.valueOf(fData.getArgs())); + dbAllocData.add(String.valueOf(fData.getReturn())); + dbAllocData.add(String.valueOf(fData.getLibName())); + dbAllocData.add(Integer.valueOf(fData.getId())); + dbAllocData.add(Integer.valueOf(fData.getTid())); + dbAllocData.add(Long.valueOf(fData.getSize())); + break; + } + default: + break; + } + + memoryAllocDataList.add(dbAllocData); + } + + public void makeFreeData(LogData log) { + ArrayList dbFreeData = new ArrayList(); + + switch (log.getId()) { + case DataChannelConstants.MSG_PROBE_MEMORY: { + MemoryData mData = (MemoryData) log; + + dbFreeData.add(Integer.valueOf(mData.getSeq())); + dbFreeData.add(Integer.valueOf(mData.getPid())); + dbFreeData.add(Integer.valueOf(mData.getId())); + dbFreeData.add(Long.valueOf(mData.getTime())); + dbFreeData.add(Long.valueOf(mData.getAddress())); + break; + } + case DataChannelConstants.MSG_PROBE_FILE: { + FileData fData = (FileData) log; + + dbFreeData.add(Integer.valueOf(fData.getSeq())); + dbFreeData.add(Integer.valueOf(fData.getPid())); + dbFreeData.add(Integer.valueOf(fData.getId())); + dbFreeData.add(Long.valueOf(fData.getTime())); + dbFreeData.add(Long.valueOf(-1)); + break; + } + default: + break; + } + + freeDataList.add(dbFreeData); + } + + public void clear() { + memoryAllocDataList.clear(); + freeDataList.clear(); + } + + public List> getAllocationDataFromDB(int seq) { + String where = String.format(query_withSeq, MemoryAllocationDataDBTable.SEQ, seq); + DBTable table = SummaryDataManager.getInstance().getMemoryAllocationDataDBTable(); + List columns = new ArrayList(); + columns.add(MemoryAllocationDataDBTable.SEQ); + columns.add(MemoryAllocationDataDBTable.PID); + columns.add(MemoryAllocationDataDBTable.API_NAME); + columns.add(MemoryAllocationDataDBTable.API_TYPE); + columns.add(MemoryAllocationDataDBTable.ALLOCATED_ADDRESS); + columns.add(MemoryAllocationDataDBTable.ALLOCATED_TIME); + columns.add(MemoryAllocationDataDBTable.CALLER_PC_ADDRESS); + columns.add(MemoryAllocationDataDBTable.ARGUMENT); + columns.add(MemoryAllocationDataDBTable.RETURN); + columns.add(MemoryAllocationDataDBTable.LIBRARY_NAME); + columns.add(MemoryAllocationDataDBTable.MESSAGE_ID); + + return table.selectData(columns, where); + } +} 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 9622b23..e8ad623 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 @@ -61,7 +61,6 @@ public class LeakTable extends DATreeComposite { private boolean isRange = false; - // add 201405 private final LeakDataMaker leakDataMaker = SummaryDataManager.getInstance().getLeakDataMaker(); @@ -161,7 +160,6 @@ public class LeakTable extends DATreeComposite { // return output; // } - // add 201405 @Override public List makeTreeInput() { List output = new ArrayList(); @@ -172,7 +170,7 @@ public class LeakTable extends DATreeComposite { // leaks = RangeDataManager.getInstance().getLeakDetector2() // .getLeakHash(); } else { - leaks = AnalyzerManager.getLeakDetector2().getLeakHash(); + leaks = AnalyzerManager.getNewLeakDetector().getLeakHash(); } ArrayList leakList = new ArrayList(); @@ -260,7 +258,6 @@ public class LeakTable extends DATreeComposite { // return output; // } - // add 201405 private TreeInput makeTreeInputForLeaks(CurrentLeakData leakInfo, int index) { // TODO : need understand for the DATableDataFormat class DATableDataFormat tableData = new DATableDataFormat(index); @@ -269,32 +266,31 @@ public class LeakTable extends DATreeComposite { List data = new ArrayList(); TreeInput output = null; - int seq = leakInfo.getSequenceNumber(); - // TODO : rename getLeakDataFromDB() --> getAllocationDataFromDB() - List> leakData = leakDataMaker.getLeakDataFromDB(seq); + int seq = leakInfo.getSequenceNumber(); + List> leakData = leakDataMaker.getAllocationDataFromDB(seq); if (leakData == null) { DA_LOG.error("very strange case !!"); return null;} if (leakData.size() != 1) { // size of leakData must be 1 DA_LOG.error("size of leakDataMaker.getLeakDataFromDB() is not '1'"); return output; } List idata = leakData.get(0); - // 0 column empty value for tree + // 0 : column empty value for tree String apiName = (String)idata.get(MemoryAllocationDataDBTable.COLUMN_INDEX_API_NAME); text.add(apiName); data.add(apiName); - // 1 + // 1 : pid int pid = (Integer)idata.get(MemoryAllocationDataDBTable.COLUMN_INDEX_PID); text.add(Integer.toString(pid)); data.add(pid); - // 2 + // 2 : sequence number text.add(Integer.toString(seq)); data.add(seq); - // 3 + // 3 : message id int id = (Integer)idata.get(MemoryAllocationDataDBTable.COLUMN_INDEX_MESSAGE_ID); String type = LogDataFactory.getLogFormatById(id).getName(); text.add(type); data.add(type); - // 4 + // 4 : allocated time long time = (Long)idata.get(MemoryAllocationDataDBTable.COLUMN_INDEX_ALLOCATED_TIME); data.add(Long.valueOf(time)); try { @@ -305,15 +301,15 @@ public class LeakTable extends DATreeComposite { } tableData.setObject(apiName); - // 5 + // 5 : arguments String args = (String)idata.get(MemoryAllocationDataDBTable.COLUMN_INDEX_ARGUMENT); text.add(args); data.add(args); - // 6 + // 6 : return value String retValue = (String)idata.get(MemoryAllocationDataDBTable.COLUMN_INDEX_RETURN); text.add(retValue); data.add(retValue); - // 7 + // 7 : library name String libName = (String)idata.get(MemoryAllocationDataDBTable.COLUMN_INDEX_LIBRARY_NAME); if (libName == null || libName.isEmpty()) { // TODO : replace another one ?? @@ -321,9 +317,9 @@ public class LeakTable extends DATreeComposite { } text.add(libName); data.add(libName); - // 8 - for ToolTip Listener + // 8 : for ToolTip Listener data.add((Long)idata.get(MemoryAllocationDataDBTable.COLUMN_INDEX_ALLOCATED_ADDRESS)); - // 9 + // 9 : caller pc address long callerPcAddr = (Long)idata.get(MemoryAllocationDataDBTable.COLUMN_INDEX_CALLER_PC_ADDRESS); data.add(callerPcAddr); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/MemoryAllocationDataDBInserter.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/MemoryAllocationDataDBInserter.java new file mode 100644 index 0000000..a0ea3bc --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/MemoryAllocationDataDBInserter.java @@ -0,0 +1,64 @@ +package org.tizen.dynamicanalyzer.ui.summary.leaks; + +import java.util.List; + +import org.tizen.dynamicanalyzer.common.AnalyzerConstants; +import org.tizen.dynamicanalyzer.common.AnalyzerManager; +import org.tizen.dynamicanalyzer.swap.logparser.ReadBlockingQueue; +import org.tizen.dynamicanalyzer.ui.summary.SummaryDataManager; + +public class MemoryAllocationDataDBInserter implements Runnable { + private static ReadBlockingQueue>> MemAllocDataQueue = new ReadBlockingQueue>>(); + + private static volatile Thread inserterThread = null; + + public static void startThread() { + if (inserterThread == null || !inserterThread.isAlive()) { + synchronized (MemoryAllocationDataDBInserter.class) { + if (inserterThread == null || !inserterThread.isAlive()) { + inserterThread = new Thread(null, + new MemoryAllocationDataDBInserter()); + inserterThread.start(); + } + } + } + } + + public static void stopThread() { + if (inserterThread != null && inserterThread.isAlive()) { + try { + sendNotify(); + inserterThread.join(AnalyzerConstants.THREAD_JOIN_WAIT_TIME); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + } + + public static void pushFunctionData(List> data) { + MemAllocDataQueue.offer(data); + } + + public static void clear() { + stopThread(); + } + + @Override + public void run() { + while (!AnalyzerManager.isExit()) { + List> memAllocData = MemAllocDataQueue.poll(); + + if (memAllocData != null && memAllocData.size() != 0) { + SummaryDataManager.getInstance().getMemoryAllocationDataDBTable() + .insertData(memAllocData); + } + } + } + + public static void sendNotify() { +// synchronized (MemAllocDataQueue) { +// MemAllocDataQueue.notifyAll(); +// } + MemAllocDataQueue.wake(); + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/MemoryAllocationDataDBTable.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/MemoryAllocationDataDBTable.java new file mode 100644 index 0000000..19bc2b7 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/MemoryAllocationDataDBTable.java @@ -0,0 +1,104 @@ +package org.tizen.dynamicanalyzer.ui.summary.leaks; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.util.List; + +import org.tizen.dynamicanalyzer.database.DBColumn; +import org.tizen.dynamicanalyzer.database.DBConstants; +import org.tizen.dynamicanalyzer.database.DBTable; + +public class MemoryAllocationDataDBTable extends DBTable { + private static final String TABLENAME = "MemoryAllocationData"; + + public static final String SEQ = DBConstants.COMMON_COLUMN_SEQ; + public static final String PID = DBConstants.COMMON_COLUMN_PID; +// public static final String API_ID = "ApiID"; + public static final String API_NAME = "ApiName"; + public static final String API_TYPE = "ApiType"; + public static final String ALLOCATED_ADDRESS = "AllocatedAddress"; + public static final String ALLOCATED_TIME = "AllocatedTime"; + public static final String CALLER_PC_ADDRESS = DBConstants.COMMON_COLUMN_CALLER_PC_ADDRESS; + public static final String ARGUMENT = DBConstants.COMMON_COLUMN_ARG; + public static final String RETURN = "Return"; + public static final String LIBRARY_NAME = DBConstants.COMMON_COLUMN_CALLER_LIB_NAME; + public static final String MESSAGE_ID = DBConstants.COMMON_COLUMN_ID; + public static final String TID = DBConstants.COMMON_COLUMN_TID; + public static final String SIZE = "size"; +// public static final String MEMORY_ALLOCATION_KEY = "Key"; +// public static final String MEMORY_ALLOCATION_PARENT_KEY = "parentKey"; + + public final static int COLUMN_INDEX_SEQ = 0; + public final static int COLUMN_INDEX_PID = 1; +// public final static int COLUMN_INDEX_API_ID = 2; + public final static int COLUMN_INDEX_API_NAME = 2; + public final static int COLUMN_INDEX_API_TYPE = 3; + public final static int COLUMN_INDEX_ALLOCATED_ADDRESS = 4; + public final static int COLUMN_INDEX_ALLOCATED_TIME = 5; + public final static int COLUMN_INDEX_CALLER_PC_ADDRESS = 6; + public final static int COLUMN_INDEX_ARGUMENT = 7; + public final static int COLUMN_INDEX_RETURN = 8; + public final static int COLUMN_INDEX_LIBRARY_NAME = 9; + public final static int COLUMN_INDEX_MESSAGE_ID = 10; + public final static int COLUMN_INDEX_TID = 11; + public final static int COLUMN_INDEX_SIZE = 12; +// public final static int COLUMN_INDEX_MEMORY_ALLOCATION_KEY = 13; +// public final static int COLUMN_INDEX_MEMORY_ALLOCATION_PARENT_KEY = 14; + + @Override + public String getTableName() { + return TABLENAME; + } + + public MemoryAllocationDataDBTable() { + addColumn(new DBColumn(SEQ, DBConstants.PRIMARY_KEY, DBConstants.INTEGER)); + addColumn(new DBColumn(PID, DBConstants.NOT_NULL, DBConstants.INTEGER)); +// addColumn(new DBColumn(API_ID, DBConstants.NOT_NULL, DBConstants.INTEGER)); + addColumn(new DBColumn(API_NAME, DBConstants.NOT_NULL, DBConstants.TEXT)); + addColumn(new DBColumn(API_TYPE, DBConstants.NOT_NULL, DBConstants.INTEGER)); + addColumn(new DBColumn(ALLOCATED_ADDRESS, DBConstants.NOT_NULL, DBConstants.LONG)); // default : -1 + addColumn(new DBColumn(ALLOCATED_TIME, DBConstants.NOT_NULL, DBConstants.LONG)); + addColumn(new DBColumn(CALLER_PC_ADDRESS, DBConstants.EMPTY, DBConstants.LONG)); + addColumn(new DBColumn(ARGUMENT, DBConstants.EMPTY, DBConstants.TEXT)); + addColumn(new DBColumn(RETURN, DBConstants.NOT_NULL, DBConstants.TEXT)); + addColumn(new DBColumn(LIBRARY_NAME, DBConstants.NOT_NULL, DBConstants.TEXT)); + addColumn(new DBColumn(MESSAGE_ID, DBConstants.NOT_NULL, DBConstants.INTEGER)); + addColumn(new DBColumn(TID, DBConstants.NOT_NULL, DBConstants.INTEGER)); + addColumn(new DBColumn(SIZE, DBConstants.NOT_NULL, DBConstants.LONG)); +// addColumn(new DBColumn(MEMORY_ALLOCATION_KEY, DBConstants.NOT_NULL, DBConstants.INTEGER)); +// addColumn(new DBColumn(MEMORY_ALLOCATION_PARENT_KEY, DBConstants.NOT_NULL, DBConstants.INTEGER)); + } + + @Override + public boolean prepare(PreparedStatement prep, List rowData) { + boolean isPrepared = true; + + int columnsize = getColumnSize(); + if (columnsize != rowData.size()) { + isPrepared = false; + } else { + try { + prep.setInt(1, (Integer) (rowData.get(0))); + prep.setInt(2, (Integer) (rowData.get(1))); + prep.setString(3, (String) (rowData.get(2))); + prep.setInt(4, (Integer) (rowData.get(3))); + prep.setLong(5, (Long) (rowData.get(4))); + prep.setLong(6, (Long) (rowData.get(5))); + prep.setLong(7, (Long) (rowData.get(6))); + prep.setString(8, (String) (rowData.get(7))); + prep.setString(9, (String) (rowData.get(8))); + prep.setString(10, (String) (rowData.get(9))); + prep.setInt(11, (Integer) (rowData.get(10))); + prep.setInt(12, (Integer) (rowData.get(11))); + prep.setLong(13, (Long) (rowData.get(12))); +// prep.setInt(13, (Integer) (rowData.get(13))); +// prep.setInt(14, (Integer) (rowData.get(14))); + } catch (SQLException e) { + e.printStackTrace(); + isPrepared = false; + } + } + + return isPrepared; + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/NewLeakDetector.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/NewLeakDetector.java new file mode 100644 index 0000000..30edd26 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/NewLeakDetector.java @@ -0,0 +1,284 @@ +/* + * Dynamic Analyzer + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * Jooyoul Lee + * Juyoung Kim + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * Contributors: + * - S-Core Co., Ltd + * + */ + +package org.tizen.dynamicanalyzer.ui.summary.leaks; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +import org.tizen.dynamicanalyzer.common.AnalyzerConstants; +import org.tizen.dynamicanalyzer.logparser.LogCenterConstants; +import org.tizen.dynamicanalyzer.nl.ConfigureLabels; +import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants; +import org.tizen.dynamicanalyzer.swap.model.data.FileData; +import org.tizen.dynamicanalyzer.swap.model.data.LogData; +import org.tizen.dynamicanalyzer.swap.model.data.MemoryData; +import org.tizen.dynamicanalyzer.swap.model.data.ProbeCommonData; +import org.tizen.dynamicanalyzer.ui.toolbar.ConfigureManager; +import org.tizen.dynamicanalyzer.ui.toolbar.configuration.ConfigurationDialogDataManager; +import org.tizen.dynamicanalyzer.util.DALogger; +import org.tizen.dynamicanalyzer.utils.AnalyzerUtil; + +public class NewLeakDetector { + // TODO : understand and refactoring +// HashMap leakHash; +// HashMap childHash; + HashMap leakHash; + private int leakSeq = 0; + + public NewLeakDetector() { + } + + public List getLeakDataList() { + List leakList = new ArrayList(); + leakList.addAll(getLeakHash().values()); + return leakList; + } + + public HashMap getLeakHash() { + if (null == leakHash) { + leakHash = new HashMap(); + } + return leakHash; + } + +// public HashMap getChildHash() { +// if (null == childHash) { +// childHash = new HashMap(); +// } +// return childHash; +// } + + // public HashMap getLeakCheckHash() { + // if (null == leakCheckHash) { + // leakCheckHash = new HashMap(); + // LeakCheckList leakCheckList = AnalyzerManager.getLeakCheckList(); + // if (null != leakCheckList) { + // List checks = leakCheckList.getChecks(); + // if (null != checks) { + // int size = checks.size(); + // for (int i = 0; i < size; i++) { + // leakCheckHash.put(checks.get(i).getName(), + // checks.get(i)); + // } + // } + // } + // } + // return leakCheckHash; + // } + + private boolean isDropLog(LogData logData) { + ConfigureManager configureManager = ConfigurationDialogDataManager + .getInstance().getConfigureManager(); + int id = logData.getId(); + String statStr = null; + switch (id) { + case DataChannelConstants.MSG_PROBE_FILE: + statStr = configureManager + .getValue(ConfigureLabels.INCLUDE_INSIDE_CALL_FILE); + break; + case DataChannelConstants.MSG_PROBE_MEMORY: + statStr = configureManager + .getValue(ConfigureLabels.INCLUDE_INSIDE_CALL_MEMORY); + break; + case DataChannelConstants.MSG_PROBE_THREAD: + statStr = configureManager + .getValue(ConfigureLabels.INCLUDE_INSIDE_CALL_THREAD); + break; + default: + break; + } + + long state = AnalyzerUtil.addrToLong(statStr); + if (state != AnalyzerConstants.FEATURE_OFF) { + // feature on + return false; + } + return true; + // feature on : false + // feature off : true + } + +// public int runLeakDetect(LogData logData) { +// ProbeCommonData log = (ProbeCommonData) logData; +// String apiName = log.getApiName(); +// long errno = log.getErrno(); +// if (0 != errno) { +//// return; +// return -1; +// } +// +// if (isDropLog(logData) && log.isInternal()) { +//// return; +// return -1; +// } +// +// LeakInfo chk = null; +// if (null == LeakCheckList.getLeakCheckList().get(apiName)) { +//// return; +// return -1; +// } else { +// chk = LeakCheckList.getLeakCheckList().get(apiName); +// } +// +// HashMap leaks = getLeakHash(); +// if (chk.getApiType() == API_TYPE_OPEN) { +// CurrentLeakData newLeak = new CurrentLeakData(logData); +//// leaks.put((long)logData.getKey(), newLeak); +// leaks.put((long)log.getKey(), newLeak); +// } else if (chk.getApiType() == API_TYPE_CLOSE) { +// leaks.remove((long)log.getKey()); +//// int key = log.getKey(); +//// CurrentLeakData freeData = getChildHash().get(key); +//// if (null != freeData) { +//// LeakData parent = leaks.get((long)freeData.getParentKey()); +//// parent.removeChild(key); +//// getChildHash().remove(key); +//// if (parent.getChildren().isEmpty()) { +//// leaks.remove(parent.getKey()); +//// } +//// } else { +//// leaks.remove(key); +//// } +// +// } else if (chk.getApiType() == API_TYPE_REALLOC) { +// String inputParam = ((ProbeCommonData) log).getArgs(); +// String[] splitInputParam = inputParam.split("\\,"); //$NON-NLS-1$ +// String param = String.valueOf(splitInputParam[0]); +// long rmKey = -1; +// try { +// if (param.contains("0x")) { +// rmKey = Long.decode(param); +// } else { +// rmKey = Integer.parseInt(splitInputParam[0]); +// } +// leaks.remove(rmKey); +// } catch (NumberFormatException e) { +// e.printStackTrace(); +// } +// +// leaks.put((long)log.getKey(), new CurrentLeakData(log)); +// } +// +// return chk.getApiType(); +// } + + public int runLeakDetect(LogData logData) { + ProbeCommonData log = (ProbeCommonData) logData; + int result = -1; +// long errno = log.getErrno(); +// if (0 != errno) { // for OSP app +// return result; +// } + + if (isDropLog(logData) && log.isInternal()) { + return result; + } + + HashMap leaks = getLeakHash(); + if (logData instanceof MemoryData) { + MemoryData mlog = (MemoryData) logData; + if (mlog.getMemoryApiType() == LogCenterConstants.MEMORY_API_ALLOC) { + if (log.getApiName().contains("realloc")) { + String inputParam = log.getArgs(); + String[] splitInputParam = inputParam.split("\\,"); //$NON-NLS-1$ + String param = String.valueOf(splitInputParam[0]); + long rmKey = -1; + try { + if (param.contains("0x")) { + rmKey = Long.decode(param); + } else { + rmKey = Integer.parseInt(splitInputParam[0]); + } + leaks.remove(rmKey); + } catch (NumberFormatException e) { + e.printStackTrace(); + } + } + + addCurrentLeakData(leaks, logData); + } else if (mlog.getMemoryApiType() == LogCenterConstants.MEMORY_API_FREE) { + int key = findAllocatedKey(leaks, mlog.getAddress(), log.getPid()); + if (key != -1) { + leaks.remove(key); + } +// leaks.remove((long)log.getKey()); + } + + result = mlog.getMemoryApiType(); + } else if (logData instanceof FileData) { + FileData flog = (FileData) logData; + if (flog.getFdApiType() == LogCenterConstants.FD_API_TYPE_OPEN) { + addCurrentLeakData(leaks, logData); + } else if (flog.getFdApiType() == LogCenterConstants.FD_API_TYPE_CLOSE) { + int key = findAllocatedKey(leaks, flog.getFdValue(), log.getPid()); + if (key != -1) { + leaks.remove(key); + } +// leaks.remove((long)log.getKey()); + } + + result = flog.getFdApiType(); + } + + return result; + } + + private void addCurrentLeakData(HashMap leaks, LogData log) { + CurrentLeakData newLeak = new CurrentLeakData(log); + leaks.put((Integer)leakSeq++, newLeak); + } + + private int findAllocatedKey(HashMap leaks, long addr, int pid) { + for (Integer key : leaks.keySet()) { + CurrentLeakData iLeakData = leaks.get(key); + if (iLeakData.getAllocatedValue() == addr && iLeakData.getPid() == pid) { + return key; + } + } + + return -1; + } + + public int getLeakSeq() { + return leakSeq; + } + + public void increaseLeakSeq() { + leakSeq++; + } + + public void resetLeakSeq() { + leakSeq = 0; + } + + public void clear() { + getLeakHash().clear(); +// getChildHash().clear(); + leakSeq = 0; + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningCase.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningCase.java index bbc4203..e6f1342 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningCase.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningCase.java @@ -26,9 +26,11 @@ package org.tizen.dynamicanalyzer.ui.summary.warning; +import org.tizen.dynamicanalyzer.constant.CommonConstants; import org.tizen.dynamicanalyzer.nl.SummaryLabels; public enum WarningCase { + // TODO : need refactoring (change enum class.. etc.) DUPLICATE_OPEN(1, SummaryLabels.WARNING_CASE_PRE_FIX, SummaryLabels.WARNING_CASE_POST_FIX_DUPLICATE, SummaryLabels.WARNING_CASE_BRIEF_DUPLICATE), @@ -69,4 +71,24 @@ public enum WarningCase { public String getShortMessage() { return shortMsg; } + + public static String getShortWarningMessage(int type) { + WarningCase[] warnings = values(); + for (int i = 0; i < warnings.length; i++) { + if (warnings[i].getType() == type) { + return warnings[i].getShortMessage(); + } + } + return CommonConstants.EMPTY; + } + + public static String getFullWarningMessage(String key, int type) { + WarningCase[] warnings = values(); + for (int i = 0; i < warnings.length; i++) { + if (warnings[i].getType() == type) { + return warnings[i].getMessage(key); + } + } + return CommonConstants.EMPTY; + } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningDataDBInserter.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningDataDBInserter.java new file mode 100644 index 0000000..7b84606 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningDataDBInserter.java @@ -0,0 +1,64 @@ +package org.tizen.dynamicanalyzer.ui.summary.warning; + +import java.util.List; + +import org.tizen.dynamicanalyzer.common.AnalyzerConstants; +import org.tizen.dynamicanalyzer.common.AnalyzerManager; +import org.tizen.dynamicanalyzer.swap.logparser.ReadBlockingQueue; +import org.tizen.dynamicanalyzer.ui.summary.SummaryDataManager; + +public class WarningDataDBInserter implements Runnable { + private static ReadBlockingQueue>> WarningDataQueue = new ReadBlockingQueue>>(); + + private static volatile Thread inserterThread = null; + + public static void startThread() { + if (inserterThread == null || !inserterThread.isAlive()) { + synchronized (WarningDataDBInserter.class) { + if (inserterThread == null || !inserterThread.isAlive()) { + inserterThread = new Thread(null, + new WarningDataDBInserter()); + inserterThread.start(); + } + } + } + } + + public static void stopThread() { + if (inserterThread != null && inserterThread.isAlive()) { + try { + sendNotify(); + inserterThread.join(AnalyzerConstants.THREAD_JOIN_WAIT_TIME); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + } + + public static void pushFunctionData(List> data) { + WarningDataQueue.offer(data); + } + + public static void clear() { + stopThread(); + } + + @Override + public void run() { + while (!AnalyzerManager.isExit()) { + List> warningData = WarningDataQueue.poll(); + + if (warningData != null && warningData.size() != 0) { + SummaryDataManager.getInstance().getWarningDataDBTable() + .insertData(warningData); + } + } + } + + public static void sendNotify() { +// synchronized (WarningDataQueue) { +// WarningDataQueue.notifyAll(); +// } + WarningDataQueue.wake(); + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningDataDBTable.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningDataDBTable.java new file mode 100644 index 0000000..40af27f --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningDataDBTable.java @@ -0,0 +1,77 @@ +package org.tizen.dynamicanalyzer.ui.summary.warning; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.util.List; + +import org.tizen.dynamicanalyzer.database.DBColumn; +import org.tizen.dynamicanalyzer.database.DBConstants; +import org.tizen.dynamicanalyzer.database.DBTable; + +public class WarningDataDBTable extends DBTable { + private static final String TABLENAME = "WarningData"; + + public static final String RID = DBConstants.COMMON_COLUMN_RID; + public static final String SEQ = DBConstants.COMMON_COLUMN_SEQ; + public static final String MESSAGE_ID = "MessageID"; + public static final String PID = DBConstants.COMMON_COLUMN_PID; + public static final String START_TIME = "StartTime"; + public static final String WARNING_CASE = "WarningCase"; + public static final String WARNING_KEY = "Key"; + public static final String CALLER_PC_ADDRESS = "CallerPcAddress"; + public static final String LIBRARY_NAME = "LibraryName"; + + public final static int COLUMN_INDEX_RID = 0; + public final static int COLUMN_INDEX_SEQ = 1; + public final static int COLUMN_INDEX_MESSAGE_ID = 2; + public final static int COLUMN_INDEX_PID = 3; + public final static int COLUMN_INDEX_START_TIME = 4; + public final static int COLUMN_INDEX_WARNING_CASE = 5; + public final static int COLUMN_INDEX_WARNING_KEY = 6; + public final static int COLUMN_INDEX_CALLER_PC_ADDRESS = 7; + public final static int COLUMN_INDEX_LIBRARY_NAME = 8; + + @Override + public String getTableName() { + return TABLENAME; + } + + public WarningDataDBTable() { + addColumn(new DBColumn(RID, DBConstants.PRIMARY_KEY, DBConstants.INTEGER)); + addColumn(new DBColumn(SEQ, DBConstants.NOT_NULL, DBConstants.INTEGER)); + addColumn(new DBColumn(MESSAGE_ID, DBConstants.NOT_NULL, DBConstants.INTEGER)); + addColumn(new DBColumn(PID, DBConstants.NOT_NULL, DBConstants.INTEGER)); + addColumn(new DBColumn(START_TIME, DBConstants.NOT_NULL, DBConstants.LONG)); + addColumn(new DBColumn(WARNING_CASE, DBConstants.NOT_NULL, DBConstants.INTEGER)); + addColumn(new DBColumn(WARNING_KEY, DBConstants.NOT_NULL, DBConstants.TEXT)); + addColumn(new DBColumn(CALLER_PC_ADDRESS, DBConstants.NOT_NULL, DBConstants.LONG)); + addColumn(new DBColumn(LIBRARY_NAME, DBConstants.NOT_NULL, DBConstants.TEXT)); + } + + @Override + public boolean prepare(PreparedStatement prep, List rowData) { + boolean isPrepared = true; + + int columnsize = getColumnSize(); + if (columnsize != rowData.size()) { + isPrepared = false; + } else { + try { + prep.setInt(1, (Integer) (rowData.get(0))); + prep.setInt(2, (Integer) (rowData.get(1))); + prep.setInt(3, (Integer) (rowData.get(2))); + prep.setInt(4, (Integer) (rowData.get(3))); + prep.setLong(5, (Long) (rowData.get(4))); + prep.setInt(6, (Integer) (rowData.get(5))); + prep.setString(7, (String) (rowData.get(6))); + prep.setLong(8, (Long) (rowData.get(7))); + prep.setString(9, (String) (rowData.get(8))); + } catch (SQLException e) { + e.printStackTrace(); + isPrepared = false; + } + } + + return isPrepared; + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningDataMaker.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningDataMaker.java new file mode 100644 index 0000000..07e071e --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningDataMaker.java @@ -0,0 +1,181 @@ +package org.tizen.dynamicanalyzer.ui.summary.warning; + +import java.util.ArrayList; +import java.util.List; + +import org.tizen.dynamicanalyzer.constant.CommonConstants; +import org.tizen.dynamicanalyzer.database.DBTable; +import org.tizen.dynamicanalyzer.swap.channel.data.ApiNameManager; +import org.tizen.dynamicanalyzer.swap.model.data.LogData; +import org.tizen.dynamicanalyzer.swap.model.data.ProbeCommonData; +import org.tizen.dynamicanalyzer.ui.summary.SummaryDataManager; +import org.tizen.dynamicanalyzer.ui.summary.warning.WarningDataDBInserter; +import org.tizen.dynamicanalyzer.ui.summary.warning.WarningDataDBTable; +import org.tizen.dynamicanalyzer.util.DALogger; + +public class WarningDataMaker { + private static final DALogger DA_LOG = DALogger.getInstance(); + + private static int warningSeq = 1; + + private static final String query_withKeyAndCase_1 = "where %s = \'"; + private static final String query_withKeyAndCase_2 = "\' and %s = %s"; + private static final String query_withSeq = "where %s = %s"; + + private ArrayList> warningDataList; + + public WarningDataMaker() { + warningDataList = new ArrayList>(); + } + + public void makeData(List inputs, String key, int warningCase) { + int size = inputs.size(); + for (int i = 0; i < size; i++) { + LogData input = (LogData) inputs.get(i); + ProbeCommonData pData = (ProbeCommonData) input; + + if (!sameWarningDataChecker(key, warningCase)) { + ArrayList dbWarningData = new ArrayList(); + + dbWarningData.add(Integer.valueOf(warningSeq++)); + dbWarningData.add(Integer.valueOf(pData.getSeq())); + dbWarningData.add(Integer.valueOf(pData.getId())); + dbWarningData.add(Integer.valueOf(pData.getPid())); + dbWarningData.add(Long.valueOf(pData.getTime())); + dbWarningData.add(Integer.valueOf(warningCase)); + dbWarningData.add(String.valueOf(key)); + dbWarningData.add(Long.valueOf(pData.getCallerPcAddr())); + dbWarningData.add(String.valueOf(pData.getLibName())); + + warningDataList.add(dbWarningData); + } + } + + if (warningDataList.size() > 0) { + @SuppressWarnings("unchecked") + List> wList = (List>) warningDataList.clone(); + warningDataList.clear(); + + WarningDataDBInserter.pushFunctionData(wList); + WarningDataDBInserter.startThread(); + } + } + + public void makeData(LogData input, String key, int warningCase) { + ProbeCommonData pData = (ProbeCommonData) input; + + if (!sameWarningDataChecker(key, warningCase)) { + ArrayList dbWarningData = new ArrayList(); + + dbWarningData.add(Integer.valueOf(warningSeq++)); + dbWarningData.add(Integer.valueOf(pData.getSeq())); + dbWarningData.add(Integer.valueOf(pData.getId())); + dbWarningData.add(Integer.valueOf(pData.getPid())); + dbWarningData.add(Long.valueOf(pData.getTime())); + dbWarningData.add(Integer.valueOf(warningCase)); + dbWarningData.add(String.valueOf(key)); + dbWarningData.add(Long.valueOf(pData.getCallerPcAddr())); + dbWarningData.add(String.valueOf(pData.getLibName())); + + warningDataList.add(dbWarningData); + + @SuppressWarnings("unchecked") + List> wList = (List>) warningDataList.clone(); + warningDataList.clear(); + + WarningDataDBInserter.pushFunctionData(wList); + WarningDataDBInserter.startThread(); + } + } + + // function for providing filtering the same warning message + private boolean sameWarningDataChecker(String key, int warningCase) { + String where = String.format(query_withKeyAndCase_1, WarningDataDBTable.WARNING_KEY); + where += key; + where += String.format(query_withKeyAndCase_2, WarningDataDBTable.WARNING_CASE, warningCase); + List columns = new ArrayList(); + columns.add(WarningDataDBTable.WARNING_KEY); + columns.add(WarningDataDBTable.WARNING_CASE); + + DBTable table = SummaryDataManager.getInstance().getWarningDataDBTable(); + + List> warningList = table.selectData(columns, where); + if (warningList != null) { + if (warningList.size() > 0) { // same warning data is existed + return true; + } else { + return false; + } + } else { // warningList == null + return false; + } + } + + public void clear() { + warningDataList.clear(); + warningSeq = 1; + } + +// public String warningMessageMaker(String key, int warningCase, boolean isShort) { +// if (warningCase == WarningCase.DUPLICATE_OPEN.getType()) { +// if (isShort) { +// return WarningCase.DUPLICATE_OPEN.getShortMessage(); +// } +// return WarningCase.DUPLICATE_OPEN.getMessage(key); +// } else if (warningCase == WarningCase.WITHOUT_USING.getType()) { +// if (isShort) { +// return WarningCase.WITHOUT_USING.getShortMessage(); +// } +// return WarningCase.WITHOUT_USING.getMessage(key); +// } else if (warningCase == WarningCase.JOINABLE_LEAK.getType()) { +// if (isShort) { +// return WarningCase.JOINABLE_LEAK.getShortMessage(); +// } +// return WarningCase.JOINABLE_LEAK.getMessage(key); +// } else if (warningCase == WarningCase.CLOSED_NETWORK_FD.getType()) { +// if (isShort) { +// return WarningCase.CLOSED_NETWORK_FD.getShortMessage(); +// } +// return WarningCase.CLOSED_NETWORK_FD.getMessage(key); +// } else { +// return CommonConstants.EMPTY; +// } +// } + + public List> getWarningDataFromDB() { + DBTable table = SummaryDataManager.getInstance().getWarningDataDBTable(); + List columns = new ArrayList(); + columns.add(WarningDataDBTable.RID); + columns.add(WarningDataDBTable.SEQ); + columns.add(WarningDataDBTable.MESSAGE_ID); + columns.add(WarningDataDBTable.PID); + columns.add(WarningDataDBTable.START_TIME); + columns.add(WarningDataDBTable.WARNING_CASE); + columns.add(WarningDataDBTable.WARNING_KEY); + columns.add(WarningDataDBTable.CALLER_PC_ADDRESS); + columns.add(WarningDataDBTable.LIBRARY_NAME); + + return table.selectData(columns, null); + } + + public String getFullWarningMessageByLogSeq(int seq) { + String where = String.format(query_withSeq, WarningDataDBTable.SEQ, seq); + List columns = new ArrayList(); + columns.add(WarningDataDBTable.WARNING_KEY); + columns.add(WarningDataDBTable.WARNING_CASE); + + DBTable table = SummaryDataManager.getInstance().getWarningDataDBTable(); + List> result = table.selectData(columns, where); + + String message = null; + if (result != null) { + List data = result.get(0); + String key = (String)data.get(0); + int warningCase = (Integer)data.get(1); +// message = warningMessageMaker(key, warningCase, false); + message = WarningCase.getFullWarningMessage(key, warningCase); + } + + return message; + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningDetailView.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningDetailView.java index b6af345..f22cb71 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningDetailView.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningDetailView.java @@ -124,7 +124,7 @@ public class WarningDetailView extends DAViewComposite { // warningMessage = WarningChecker // .messageMaker(warning, false); // } - String msg = SummaryDataManager.getInstance().getWarningDataMaker().getWarningMessage(seq); + String msg = SummaryDataManager.getInstance().getWarningDataMaker().getFullWarningMessageByLogSeq(seq); if (msg == null) { warningMessage = CommonConstants.EMPTY; } else { diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningTable.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningTable.java index f4be638..85359bb 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningTable.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningTable.java @@ -50,7 +50,6 @@ import org.tizen.dynamicanalyzer.ui.widgets.table.DATableDataFormat; public class WarningTable extends DATableComposite { private boolean isRange = false; - // add 201405 private final WarningDataMaker warningDataMaker = SummaryDataManager.getInstance().getWarningDataMaker(); @@ -132,7 +131,6 @@ public class WarningTable extends DATableComposite { // return input; // } - // add 201405 protected List makeTableInput() { // List warningList = null; // if (isRange) { @@ -152,23 +150,24 @@ public class WarningTable extends DATableComposite { List text = new ArrayList(); List data = new ArrayList(); - // 0 + // 0 : rid int rid = (Integer)idata.get(WarningDataDBTable.COLUMN_INDEX_RID); text.add(Integer.toString(rid)); data.add(Integer.toString(rid)); - // 1 + // 1 : message id int msgID = (Integer)idata.get(WarningDataDBTable.COLUMN_INDEX_MESSAGE_ID); String category = LogDataFactory.getLogFormatById(msgID).getName(); text.add(category); data.add(category); - // 2 + // 2 : pid int pid = (Integer)idata.get(WarningDataDBTable.COLUMN_INDEX_PID); text.add(Integer.toString(pid)); data.add(Integer.toString(pid)); - // 3 + // 3 : short warning message int warningCase = (Integer)idata.get(WarningDataDBTable.COLUMN_INDEX_WARNING_CASE); - String key = (String)idata.get(WarningDataDBTable.COLUMN_INDEX_WARNING_KEY); - String message = warningDataMaker.messageMaker(key, warningCase, true); +// String key = (String)idata.get(WarningDataDBTable.COLUMN_INDEX_WARNING_KEY); +// String message = warningDataMaker.warningMessageMaker(key, warningCase, true); + String message = WarningCase.getShortWarningMessage(warningCase); text.add(message); data.add(message); // create images diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/ThreadPageData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/ThreadPageData.java index 99d3487..c039e7b 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/ThreadPageData.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/ThreadPageData.java @@ -134,7 +134,6 @@ public abstract class ThreadPageData { if (0 != errno) { // FailedData ffd = new FailedData(event.getContents()); // AnalyzerManager.getFailedChecker().getFailedList().add(ffd); - // add 201405 SummaryDataManager.getInstance().getFailedApiDataMaker(). makeData(event.getContents()); apiItem = new DAChartSeriesItem(event.getTime(), diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/thread/ThreadPageThreadDataManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/thread/ThreadPageThreadDataManager.java index 1348586..dc4e122 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/thread/ThreadPageThreadDataManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/thread/ThreadPageThreadDataManager.java @@ -496,7 +496,6 @@ public class ThreadPageThreadDataManager { // WarningCase.JOINABLE_LEAK.getType(), input, // ThreadPageLabels.THREAD_CHART_NAME_TID + tid); // AnalyzerManager.getWarningChecker().getWarningData().add(wData); - // add 201405 SummaryDataManager.getInstance().getWarningDataMaker().makeData( input, ThreadPageLabels.THREAD_CHART_NAME_TID + tid, WarningCase.JOINABLE_LEAK.getType()); @@ -596,7 +595,6 @@ public class ThreadPageThreadDataManager { // event.getContents(), // ThreadPageLabels.THREAD_CHART_NAME_TID + tid); // AnalyzerManager.getWarningChecker().getWarningData().add(wData); - // 201405 SummaryDataManager.getInstance().getWarningDataMaker().makeData( event.getContents(), ThreadPageLabels.THREAD_CHART_NAME_TID + tid, WarningCase.JOINABLE_LEAK.getType()); -- 2.7.4