Summary : implement save / load feature and remove previous DB about summary (leak...

Change-Id: I1b84db69d055a27bea68b4933eeaf403ad58dcbd
Signed-off-by: seokgil.kang <seokgil.kang@samsung.com>

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 c7e9366..cfb4196 100755 (executable)
--- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/AnalyzerManager.java
+++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/AnalyzerManager.java
@@ -48,17 +48,15 @@ import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackManager;
 import org.tizen.dynamicanalyzer.ui.info.screenshot.ScreenshotTimerTask;
 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.NewLeakDetector;
 import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler;
 import org.tizen.dynamicanalyzer.ui.summary.warning.WarningChecker;
 import org.tizen.dynamicanalyzer.ui.toolbar.ConfigureManager;
 import org.tizen.dynamicanalyzer.ui.toolbar.StopProcessManager;
 import org.tizen.dynamicanalyzer.ui.toolbar.configuration.ConfigurationDialogDataManager;
+import org.tizen.dynamicanalyzer.util.DALogger;
 import org.tizen.dynamicanalyzer.util.WorkbenchUtil;
 import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
-import org.tizen.dynamicanalyzer.util.DALogger;
 import org.tizen.dynamicanalyzer.utils.ImageListSortComparator;
 import org.tizen.dynamicanalyzer.widgets.da.view.DAPageComposite;
 
@@ -75,10 +73,7 @@ public class AnalyzerManager {
 
        private static HashMap<Integer, HashMap<Long, String>> funcNameMapByPid = null;
 
-       private static LeakDetector leakDetector = new LeakDetector();
        private static NewLeakDetector newLeakDetector = new NewLeakDetector();
-       private static FailedChecker failedChecker = new FailedChecker();
-       private static FailedChecker calledChecker = new FailedChecker();
        private static WarningChecker warningChecker = new WarningChecker();
        private static CallStackManager callstackManager = new CallStackManager();
        private static SWAPCallStackManager swapCallstackManager = new SWAPCallStackManager(
@@ -160,11 +155,8 @@ public class AnalyzerManager {
                imageList = null;
                imageListSize = 0;
 
-               leakDetector.clear();
                newLeakDetector.clear();
-               failedChecker.clear();
                warningChecker.clear();
-               calledChecker.clear();
                callstackManager.clear();
                swapCallstackManager.clear();
                isHaveSampleThread = false;
@@ -266,18 +258,10 @@ public class AnalyzerManager {
                return project;
        }
 
-       public static LeakDetector getLeakDetector() {
-               return leakDetector;
-       }
-
        public static NewLeakDetector getNewLeakDetector() {
                return newLeakDetector;
        }
 
-       public static FailedChecker getFailedChecker() {
-               return failedChecker;
-       }
-
        public static WarningChecker getWarningChecker() {
                return warningChecker;
        }
@@ -301,10 +285,6 @@ public class AnalyzerManager {
                }
        }
 
-       public static FailedChecker getCalledFunctionChecker() {
-               return calledChecker;
-       }
-
        public static void initTraceStart() {
                AnalyzerUtil.executeCommand(ClearHandler.ID);
                if (!AnalyzerManager.isExit()) {

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 dec25c8..16c33e0 100644 (file)
--- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/OpenTraceHandler.java
+++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/OpenTraceHandler.java
@@ -55,10 +55,6 @@ import org.tizen.dynamicanalyzer.ui.network.data.NetworkDataManager;
 import org.tizen.dynamicanalyzer.ui.opengl.data.GLDataManager;
 import org.tizen.dynamicanalyzer.ui.range.RangeDataManager;
 import org.tizen.dynamicanalyzer.ui.range.RangePage;
-import org.tizen.dynamicanalyzer.ui.summary.failed.FailedChecker;
-import org.tizen.dynamicanalyzer.ui.summary.failed.FailedData;
-import org.tizen.dynamicanalyzer.ui.summary.leaks.LeakData;
-import org.tizen.dynamicanalyzer.ui.summary.leaks.LeakDetector;
 import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler;
 import org.tizen.dynamicanalyzer.ui.summary.profiling.ProfileDataMaker;
 import org.tizen.dynamicanalyzer.ui.summary.profiling.ProfilingChildData;
@@ -122,8 +118,6 @@ public class OpenTraceHandler extends AbstractHandler {
                int percent = OpenTraceProgressManager.getInstance().getPercent();
                if (loadCallStackApis() && loadProfilingData() && loadProfilingChildData() &&
                // loadCallStackData() &&
-               // loadLeakData() &&
-               // loadFailedData() &&
                                loadImageSet()) {
                        OpenTraceProgressManager.getInstance().setProgressPercent(
                                        AnalyzerLabels.OPEN_TRACE_PROGRESS_LOADING, percent += 60);
@@ -221,60 +215,6 @@ public class OpenTraceHandler extends AbstractHandler {
                return true;
        }
 
-       private boolean loadLeakData() {
-               boolean isSuccess = true;
-               List<List<String>> dbInfo = SqlManager.getInstance().setloadLeakData();
-               if (null == dbInfo) {
-                       DA_LOG.debug("leak data loading failed..");
-                       isSuccess = false;
-               } else {
-                       LeakDetector leakDectector = AnalyzerManager.getLeakDetector();
-                       for (int i = 0; i < dbInfo.size(); i++) {
-                               List<String> info = dbInfo.get(i);
-                               LeakData leakData = new LeakData(info);
-                               if (-1 != leakData.getParentKey()) {
-                                       LeakData parent = leakDectector.getLeakHash().get(
-                                                       leakData.getParentKey());
-                                       if (null == parent) {
-                                               continue;
-                                       } else {
-                                               parent.getChildren().add(leakData);
-                                       }
-                               } else {
-                                       leakDectector.getLeakHash().put((long) leakData.getKey(), leakData);
-                               }
-                       }
-               }
-               return isSuccess;
-       }
-
-       private boolean loadFailedData() {
-               boolean isSuccess = true;
-               List<List<String>> dbInfo = SqlManager.getInstance().setloadFailedData();
-               if (null == dbInfo) {
-                       DA_LOG.debug("failed - loadFailedData");
-                       isSuccess = false;
-               } else {
-                       FailedChecker failedChecker = AnalyzerManager.getFailedChecker();
-                       for (int i = 0; i < dbInfo.size(); i++) {
-                               List<String> pInfo = dbInfo.get(i);
-                               // possibility of extensions - network, efl, db, etc...
-                               int id = Integer.parseInt(pInfo.get(LogCenterConstants.ID_INDEX));
-                               if (id == DataChannelConstants.MSG_PROBE_FILE) {
-                                       // if file failed api data is skip - file chart make it!
-                                       int type = Integer.parseInt(pInfo
-                                                       .get(LogCenterConstants.RESOURCE_FDTYPE_INDEX));
-                                       if (type == LogCenterConstants.FD_TYPE_FILE) {
-                                               continue;
-                                       }
-                               }
-                               FailedData failedData = new FailedData(pInfo);
-                               failedChecker.getFailedList().add(failedData);
-                       }
-               }
-               return isSuccess;
-       }
-
        private boolean loadProfilingData() {
                boolean isSuccess = true;
                List<List<Object>> profilingDatas = FunctionUsageProfiler.getInstance()

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 2d4986e..c11f0f5 100755 (executable)
--- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/sql/DBTableManager.java
+++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/sql/DBTableManager.java
@@ -35,12 +35,12 @@ public class DBTableManager {
 
        public static DBTableManager instance = null;
 
-       private static final String TABLE_NAME_FAILED_DATA = "FailedData";//$NON-NLS-1$
-       private static final String TABLE_NAME_LEAK_DATA = "LeakData";//$NON-NLS-1$
+//     private static final String TABLE_NAME_FAILED_DATA = "FailedData";//$NON-NLS-1$
+//     private static final String TABLE_NAME_LEAK_DATA = "LeakData";//$NON-NLS-1$
        private static List<DBTableInfo> tableInfos;
 
-       public static final int TABLE_INDEX_FAILED_DATA = 0;
-       public static final int TABLE_INDEX_LEAK_DATA = 1;
+//     public static final int TABLE_INDEX_FAILED_DATA = 0;
+//     public static final int TABLE_INDEX_LEAK_DATA = 1;
 
        public static final String EMPTY = CommonConstants.EMPTY;
        public static final String TEXT = "VARCHAR(256)";//$NON-NLS-1$
@@ -148,33 +148,33 @@ public class DBTableManager {
                getTableInfos();
 
                // "failed data" table info block
-               {
-                       String[] names = { "Rid", "MsgId", "SeqNumber", "Time", "ApiName",
-                                       "Parameter", "Return", "ErrorCode", "CallerPc", "Pid",
-                                       "LibName" };
-                       String[] options = { EMPTY, EMPTY, NOT_NULL, EMPTY, EMPTY, EMPTY,
-                                       EMPTY, EMPTY, EMPTY, EMPTY, EMPTY };
-                       String[] types = { TEXT, TEXT, TEXT, TEXT, TEXT, TEXT, TEXT, TEXT,
-                                       TEXT, TEXT, TEXT };
-                       DBTableInfo failedDataTableInfo = new DBTableInfo(
-                                       TABLE_NAME_FAILED_DATA, names, options, types);
-                       tableInfos.add(failedDataTableInfo);
-               }
+//             {
+//                     String[] names = { "Rid", "MsgId", "SeqNumber", "Time", "ApiName",
+//                                     "Parameter", "Return", "ErrorCode", "CallerPc", "Pid",
+//                                     "LibName" };
+//                     String[] options = { EMPTY, EMPTY, NOT_NULL, EMPTY, EMPTY, EMPTY,
+//                                     EMPTY, EMPTY, EMPTY, EMPTY, EMPTY };
+//                     String[] types = { TEXT, TEXT, TEXT, TEXT, TEXT, TEXT, TEXT, TEXT,
+//                                     TEXT, TEXT, TEXT };
+//                     DBTableInfo failedDataTableInfo = new DBTableInfo(
+//                                     TABLE_NAME_FAILED_DATA, names, options, types);
+//                     tableInfos.add(failedDataTableInfo);
+//             }
 
                // "leak data" table info block
-               {
-                       String[] names = { "Rid", "LeakSeq", "MsgId", "SeqNumber", "Time",
-                                       "ApiName", "Pid", "Address", "CallerPc", "Parameter",
-                                       "Return", "LibName", "Key", "ParentKey" };
-                       // commonColumns;
-                       String[] options = { EMPTY, EMPTY, EMPTY, NOT_NULL, EMPTY, EMPTY,
-                                       EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY };
-                       String[] types = { TEXT, TEXT, TEXT, TEXT, TEXT, TEXT, TEXT, TEXT,
-                                       TEXT, TEXT, TEXT, TEXT, TEXT, TEXT };
-                       DBTableInfo leakDataTableInfo = new DBTableInfo(
-                                       TABLE_NAME_LEAK_DATA, names, options, types);
-                       tableInfos.add(leakDataTableInfo);
-               }
+//             {
+//                     String[] names = { "Rid", "LeakSeq", "MsgId", "SeqNumber", "Time",
+//                                     "ApiName", "Pid", "Address", "CallerPc", "Parameter",
+//                                     "Return", "LibName", "Key", "ParentKey" };
+//                     // commonColumns;
+//                     String[] options = { EMPTY, EMPTY, EMPTY, NOT_NULL, EMPTY, EMPTY,
+//                                     EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY };
+//                     String[] types = { TEXT, TEXT, TEXT, TEXT, TEXT, TEXT, TEXT, TEXT,
+//                                     TEXT, TEXT, TEXT, TEXT, TEXT, TEXT };
+//                     DBTableInfo leakDataTableInfo = new DBTableInfo(
+//                                     TABLE_NAME_LEAK_DATA, names, options, types);
+//                     tableInfos.add(leakDataTableInfo);
+//             }
        }
 
        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 7409d91..e1c07ed 100755 (executable)
--- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/sql/SqlManager.java
+++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/sql/SqlManager.java
@@ -47,10 +47,6 @@ import org.tizen.dynamicanalyzer.project.Project;
 import org.tizen.dynamicanalyzer.swap.model.data.LogData;
 import org.tizen.dynamicanalyzer.swap.model.data.LogDataFactory;
 import org.tizen.dynamicanalyzer.swap.model.format.LogFormat;
-import org.tizen.dynamicanalyzer.ui.summary.failed.FailedChecker;
-import org.tizen.dynamicanalyzer.ui.summary.failed.FailedData;
-import org.tizen.dynamicanalyzer.ui.summary.leaks.LeakData;
-import org.tizen.dynamicanalyzer.ui.summary.leaks.LeakDetector;
 import org.tizen.dynamicanalyzer.util.CommonUtil;
 import org.tizen.dynamicanalyzer.util.DALogger;
 
@@ -329,130 +325,6 @@ public class SqlManager {
                return true;
        }
 
-       public void saveLeakData() {
-               LeakDetector leakDectector = AnalyzerManager.getLeakDetector();
-               DBTableInfo leakTableInfo = DBTableManager.getInstance().getTableInfo(
-                               DBTableManager.TABLE_INDEX_LEAK_DATA);
-               String insertQuery = leakTableInfo.insertQuery();
-               List<LeakData> leakList = leakDectector.getLeakDataList();
-               List<LeakData> insertData = new ArrayList<LeakData>();
-               for (LeakData leakData : leakList) {
-                       insertData.add(leakData);
-                       if (!leakData.getChildren().isEmpty()) {
-                               List<LeakData> children = leakData.getChildren();
-                               for (LeakData child : children) {
-                                       insertData.add(child);
-                               }
-                       }
-               }
-               insertLeakQuery(insertQuery, insertData);
-       }
-
-       private boolean insertLeakQuery(String query, List<LeakData> input) {
-               PreparedStatement prep = null;
-               try {
-                       Connection conn = getConnection();
-                       if (null == conn || null == query || null == input) {
-                               DA_LOG.debug("insert leak data failed.. : " + input);
-                               return false;
-                       }
-                       semaphoreAcquire();
-                       prep = conn.prepareStatement(query);
-                       int dataRowSize = input.size();
-                       for (int i = 0; i < dataRowSize; i++) {
-                               LeakData data = input.get(i);
-                               prep.setInt(1, LeakData.getLogNum());
-                               prep.setInt(2, data.getLeakSeq());
-                               prep.setInt(3, data.getId());
-                               prep.setInt(4, data.getSeq());
-                               prep.setLong(5, data.getTime());
-                               prep.setString(6, data.getName());
-                               prep.setInt(7, data.getPid());
-                               prep.setLong(8, data.getAddr());
-                               prep.setLong(9, data.getCallerPc());
-                               prep.setString(10, data.getParam());
-                               prep.setString(11, data.getRet());
-                               prep.setString(12, data.getLibName());
-                               prep.setInt(13, data.getKey());
-                               prep.setInt(14, data.getParentKey());
-                               prep.addBatch();
-                       }
-                       if (dataRowSize > 0) {
-                               conn.setAutoCommit(false);
-                               prep.executeBatch();
-                               conn.setAutoCommit(true);
-                       }
-               } catch (SQLException e) {
-                       e.printStackTrace();
-               } finally {
-                       if (null != prep) {
-                               try {
-                                       prep.close();
-                               } catch (SQLException e) {
-                                       e.printStackTrace();
-                               }
-                       }
-                       semaphoreRelease();
-               }
-               return true;
-       }
-
-       public void saveFailedData() {
-               FailedChecker failedChecker = AnalyzerManager.getFailedChecker();
-
-               List<FailedData> failedList = failedChecker.getFailedList();
-               DBTableInfo failedTableInfo = DBTableManager.getInstance().getTableInfo(
-                               DBTableManager.TABLE_INDEX_FAILED_DATA);
-               String insertQuery = failedTableInfo.insertQuery();
-               insertFailedQuery(insertQuery, failedList);
-       }
-
-       private boolean insertFailedQuery(String query, List<FailedData> input) {
-               PreparedStatement prep = null;
-               try {
-                       Connection conn = getConnection();
-                       if (null == conn || null == query || null == input) {
-                               DA_LOG.debug("failed sql inset : " + input);
-                               return false;
-                       }
-                       semaphoreAcquire();
-                       prep = conn.prepareStatement(query);
-                       int dataRowSize = input.size();
-                       for (int i = 0; i < dataRowSize; i++) {
-                               FailedData data = input.get(i);
-                               prep.setInt(1, FailedData.getLogNum());
-                               prep.setInt(2, data.getId());
-                               prep.setInt(3, data.getSeq());
-                               prep.setLong(4, data.getTime());
-                               prep.setString(5, data.getName());
-                               prep.setString(6, data.getArgs());
-                               prep.setString(7, data.getReturn());
-                               prep.setLong(8, data.getErrorCode());
-                               prep.setLong(9, data.getCallerPc());
-                               prep.setInt(10, data.getPid());
-                               prep.setString(11, data.getLibName());
-                               prep.addBatch();
-                       }
-                       if (dataRowSize > 0) {
-                               conn.setAutoCommit(false);
-                               prep.executeBatch();
-                               conn.setAutoCommit(true);
-                       }
-               } catch (SQLException e) {
-                       e.printStackTrace();
-               } finally {
-                       if (null != prep) {
-                               try {
-                                       prep.close();
-                               } catch (SQLException e) {
-                                       e.printStackTrace();
-                               }
-                       }
-                       semaphoreRelease();
-               }
-               return true;
-       }
-
        /**
         * select query function
         * 
@@ -798,28 +670,6 @@ public class SqlManager {
                return dbInfo;
        }
 
-       public List<List<String>> setloadLeakData() {
-               return selectQuery(
-                               null,
-                               DBTableManager.getInstance()
-                                               .getTableInfo(DBTableManager.TABLE_INDEX_LEAK_DATA)
-                                               .getColumnNames(),
-                               DBTableManager.getInstance()
-                                               .getTableInfo(DBTableManager.TABLE_INDEX_LEAK_DATA)
-                                               .getTableName(), null);
-       }
-
-       public List<List<String>> setloadFailedData() {
-               return selectQuery(
-                               null,
-                               DBTableManager.getInstance()
-                                               .getTableInfo(DBTableManager.TABLE_INDEX_FAILED_DATA)
-                                               .getColumnNames(),
-                               DBTableManager.getInstance()
-                                               .getTableInfo(DBTableManager.TABLE_INDEX_FAILED_DATA)
-                                               .getTableName(), null);
-       }
-
        public List<String> getPids() {
                List<List<String>> dbInfo = selectQuery(null, new String[] { "distinct pid" },
                                "ProcessInfo", null);

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 6b471b9..352424b 100755 (executable)
--- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/SWAPLogParser.java
+++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/SWAPLogParser.java
@@ -270,12 +270,12 @@ public class SWAPLogParser implements Runnable {
                                }
                                pushLog(log, logPack);
                                AnalyzerManager.getCallstackManager().makeCallstackWithoutBacktrace(log);
-                               if (id == DataChannelConstants.MSG_PROBE_FILE
-                                               || id == DataChannelConstants.MSG_PROBE_MEMORY) {
-                                       AnalyzerManager.getLeakDetector().runLeakDectect(log);
-                               }
-
-                               AnalyzerManager.getFailedChecker().check(log);
+//                             if (id == DataChannelConstants.MSG_PROBE_FILE
+//                                             || id == DataChannelConstants.MSG_PROBE_MEMORY) {
+//                                     AnalyzerManager.getLeakDetector().runLeakDectect(log);
+//                             }
+//
+//                             AnalyzerManager.getFailedChecker().check(log);
                        }
                }
 

diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/manager/FileChartDataMaker.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/manager/FileChartDataMaker.java
index a4f9e88..e638009 100644 (file)
--- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/manager/FileChartDataMaker.java
+++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/manager/FileChartDataMaker.java
@@ -28,7 +28,6 @@ package org.tizen.dynamicanalyzer.ui.file.manager;
 
 
 import java.util.ArrayList;
-
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -50,10 +49,7 @@ import org.tizen.dynamicanalyzer.swap.model.data.LogData;
 import org.tizen.dynamicanalyzer.ui.file.model.FileAccess;
 import org.tizen.dynamicanalyzer.ui.file.model.FileEvent;
 import org.tizen.dynamicanalyzer.ui.file.model.FileStatus;
-import org.tizen.dynamicanalyzer.ui.summary.failed.FailedChecker;
-import org.tizen.dynamicanalyzer.ui.summary.failed.FailedData;
-import org.tizen.dynamicanalyzer.ui.summary.leaks.LeakDetector;
-import org.tizen.dynamicanalyzer.ui.summary.warning.WarningChecker;
+import org.tizen.dynamicanalyzer.ui.summary.SummaryDataManager;
 import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
 import org.tizen.dynamicanalyzer.ui.toolbar.configuration.ConfigurationDialogDataManager;
 import org.tizen.dynamicanalyzer.util.DALogger;
@@ -63,9 +59,6 @@ import org.tizen.dynamicanalyzer.widgets.da.base.DADialog;
 public class FileChartDataMaker {
        private static final DALogger DA_LOG = DALogger.getInstance();
        
-       private FailedChecker failedChecker = null;
-       private WarningChecker warningChecker = null;
-       
        private List<FileStatus> fileStatusList = new ArrayList<FileStatus>();
        private List<FileAccess> fileAccessList = new ArrayList<FileAccess>();
        private Map<String, Long> fileAccessorMap = new HashMap<String, Long>();
@@ -77,10 +70,7 @@ public class FileChartDataMaker {
        // TODO: rename queue
        private Queue<List<FileEvent>> queue = new ConcurrentLinkedQueue<List<FileEvent>>();
        
-       public FileChartDataMaker(FailedChecker failedChecker,
-                       LeakDetector leakDetector, WarningChecker warningChecker) {
-               this.failedChecker = failedChecker;
-               this.warningChecker = warningChecker;
+       public FileChartDataMaker() {
        }
 
        public void clear(){
@@ -138,8 +128,7 @@ public class FileChartDataMaker {
                        
                        // check error
                        if (errNo != 0) {
-                               FailedData failedData = new FailedData(input);
-                               this.failedChecker.getFailedList().add(failedData);
+                               SummaryDataManager.getInstance().getFailedApiDataMaker().makeData(input);
                        } else if (apiName.equals("fdopen")) { //$NON-NLS-1$
                                // TODO: legacy code, need to check
                                DA_LOG.debug("fdopen");

diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/manager/FileChartManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/manager/FileChartManager.java
index c919876..00a7f47 100644 (file)
--- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/manager/FileChartManager.java
+++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/manager/FileChartManager.java
@@ -29,7 +29,6 @@ package org.tizen.dynamicanalyzer.ui.file.manager;
 import java.util.ArrayList;
 import java.util.List;
 
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
 import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants;
 import org.tizen.dynamicanalyzer.swap.logparser.LogPackage;
 import org.tizen.dynamicanalyzer.swap.logparser.Logs;
@@ -38,7 +37,6 @@ import org.tizen.dynamicanalyzer.swap.model.data.LogData;
 import org.tizen.dynamicanalyzer.ui.file.data.FileAccessDB;
 import org.tizen.dynamicanalyzer.ui.file.data.FileApiDB;
 import org.tizen.dynamicanalyzer.ui.file.data.FileStatusDB;
-import org.tizen.dynamicanalyzer.ui.file.manager.FileChartDataMaker;
 import org.tizen.dynamicanalyzer.ui.file.model.FileEvent;
 
 
@@ -55,10 +53,7 @@ public class FileChartManager extends PageDataManager {
        private List<FileEvent> selectedTableAPIList = new ArrayList<FileEvent>();
        
        private FileChartManager() {
-               dataMaker = new FileChartDataMaker(
-                               AnalyzerManager.getFailedChecker(),
-                               AnalyzerManager.getLeakDetector(),
-                               AnalyzerManager.getWarningChecker());
+               dataMaker = new FileChartDataMaker();
 
                initDB();
        }

diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/score/ScoreView.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/score/ScoreView.java
index d77ecb4..9bd1d76 100644 (file)
--- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/score/ScoreView.java
+++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/score/ScoreView.java
@@ -45,6 +45,7 @@ import org.tizen.dynamicanalyzer.nl.InformationViewLabels;
 import org.tizen.dynamicanalyzer.resources.ColorResources;
 import org.tizen.dynamicanalyzer.resources.FontResources;
 import org.tizen.dynamicanalyzer.resources.ImageResources;
+import org.tizen.dynamicanalyzer.ui.summary.SummaryDataManager;
 import org.tizen.dynamicanalyzer.widgets.da.view.DAViewComposite;
 
 public class ScoreView extends DAViewComposite {
@@ -111,13 +112,11 @@ public class ScoreView extends DAViewComposite {
                                e.gc.setForeground(ColorResources.TITLEBAR_TEXT_COLOR);
                                e.gc.setFont(FontResources.SCORE_TITLE_FONT);
 
-                               Point textSize = e.gc.textExtent(
-                                               InformationViewLabels.SCORE_VIEW_SCORE,
+                               Point textSize = e.gc.textExtent(InformationViewLabels.SCORE_VIEW_SCORE,
                                                SWT.DRAW_MNEMONIC);
                                x = (rect.width - textSize.x) / 2;
 
-                               e.gc.drawString(InformationViewLabels.SCORE_VIEW_SCORE, x,
-                                               y += 5);
+                               e.gc.drawString(InformationViewLabels.SCORE_VIEW_SCORE, x, y += 5);
                                e.gc.drawLine(x = 1, y += 25, rect.width - 2, y);
 
                                // draw score
@@ -142,8 +141,7 @@ public class ScoreView extends DAViewComposite {
                                        e.gc.drawRectangle(colRect);
                                        e.gc.setForeground(ColorResources.SNAPSHOT_VIEW_TABLE_TITLE_TEXT);
                                        e.gc.setFont(FontResources.TABLE_CELL_FONT);
-                                       textSize = e.gc.textExtent(columnString.get(i),
-                                                       SWT.DRAW_MNEMONIC);
+                                       textSize = e.gc.textExtent(columnString.get(i), SWT.DRAW_MNEMONIC);
                                        x = (colRect.width - textSize.x) / 2;
                                        y = colRect.y + (colRect.height - textSize.y) / 2;
                                        e.gc.drawString(columnString.get(i), x, y);
@@ -156,8 +154,7 @@ public class ScoreView extends DAViewComposite {
                                        e.gc.drawRectangle(colRect);
                                        e.gc.setForeground(ColorResources.SNAPSHOT_VIEW_TABLE_CONTENTS_TEXT);
                                        e.gc.setFont(FontResources.TABLE_CELL_FONT);
-                                       textSize = e.gc.textExtent(columnValue.get(i).toString(),
-                                                       SWT.DRAW_MNEMONIC);
+                                       textSize = e.gc.textExtent(columnValue.get(i).toString(), SWT.DRAW_MNEMONIC);
                                        x = colRect.x + (colRect.width - textSize.x) / 2;
                                        y = colRect.y + (colRect.height - textSize.y) / 2;
                                        e.gc.drawString(columnValue.get(i).toString(), x, y);
@@ -225,8 +222,9 @@ public class ScoreView extends DAViewComposite {
 
        @Override
        public void updateView() {
-               failCount = AnalyzerManager.getFailedChecker().getFailedList().size();
-               leakSize = AnalyzerManager.getLeakDetector().getLeakDataList().size();
+               failCount = SummaryDataManager.getInstance().getFailedApiDataMaker()
+                               .getFailedApiDataFromDB().size();
+               leakSize = AnalyzerManager.getNewLeakDetector().getLeakHash().size();
                warningSize = AnalyzerManager.getWarningChecker().getWarningData().size();
                columnValue.set(0, failCount);
                columnValue.set(1, leakSize);

diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/network/data/NetworkDataMaker.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/network/data/NetworkDataMaker.java
index 9a74d98..469193d 100644 (file)
--- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/network/data/NetworkDataMaker.java
+++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/network/data/NetworkDataMaker.java
@@ -39,9 +39,6 @@ import org.tizen.dynamicanalyzer.swap.model.data.LogData;
 import org.tizen.dynamicanalyzer.swap.model.data.NetworkData;
 import org.tizen.dynamicanalyzer.ui.network.data.type.NetworkAPIType;
 import org.tizen.dynamicanalyzer.ui.network.data.type.NetworkSeriesType;
-import org.tizen.dynamicanalyzer.ui.summary.failed.FailedChecker;
-import org.tizen.dynamicanalyzer.ui.summary.leaks.LeakDetector;
-import org.tizen.dynamicanalyzer.ui.summary.warning.WarningChecker;
 import org.tizen.dynamicanalyzer.ui.toolbar.configuration.ConfigurationDialogDataManager;
 import org.tizen.dynamicanalyzer.util.DALogger;
 import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
@@ -55,8 +52,7 @@ public class NetworkDataMaker {
        List<NetworkAPIType> noDestinationApiSeriesList = new ArrayList<NetworkAPIType>();
        List<NetworkAPIType> destinationApiSeriesList = new ArrayList<NetworkAPIType>();
 
-       public NetworkDataMaker(FailedChecker failedChecker,
-                       LeakDetector leakDetector, WarningChecker warningChecker) {
+       public NetworkDataMaker() {
        }
 
        public void clear() {

diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/network/data/NetworkDataManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/network/data/NetworkDataManager.java
index b3011d8..f0ea6cc 100644 (file)
--- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/network/data/NetworkDataManager.java
+++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/network/data/NetworkDataManager.java
@@ -35,7 +35,6 @@ import java.util.Map;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.widgets.Display;
 import org.eclipse.swt.widgets.Shell;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
 import org.tizen.dynamicanalyzer.common.path.PathManager;
 import org.tizen.dynamicanalyzer.nl.AnalyzerLabels;
 import org.tizen.dynamicanalyzer.resources.ImageResources;
@@ -80,10 +79,7 @@ public class NetworkDataManager extends PageDataManager {
        private boolean isStopTrace = false;
 
        public NetworkDataManager() {
-               networkDataMaker = new NetworkDataMaker(
-                               AnalyzerManager.getFailedChecker(),
-                               AnalyzerManager.getLeakDetector(),
-                               AnalyzerManager.getWarningChecker());
+               networkDataMaker = new NetworkDataMaker();
 
                apiDBManager = new NetworkAPIDBManager();
                seriesDBManager = new NetworkSeriesDBManager();

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
index b74360b..d65b199 100644 (file)
--- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/SummaryDataManager.java
+++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/SummaryDataManager.java
@@ -1,7 +1,9 @@
 package org.tizen.dynamicanalyzer.ui.summary;
 
 import java.util.List;
+import java.util.Map;
 
+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;
@@ -10,9 +12,12 @@ 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.CurrentLeakData;
 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.leaks.LeakDataDBTable;
+import org.tizen.dynamicanalyzer.ui.summary.leaks.NewLeakDetector;
 import org.tizen.dynamicanalyzer.ui.summary.warning.WarningDataDBTable;
 import org.tizen.dynamicanalyzer.ui.summary.warning.WarningDataMaker;
 import org.tizen.dynamicanalyzer.util.DALogger;
@@ -27,6 +32,7 @@ public class SummaryDataManager extends PageDataManager {
        
        private MemoryAllocationDataDBTable memoryAllocationDataTable = null;
        private FreeDataDBTable freeDataTable = null;
+       private LeakDataDBTable leakDataTable = null;
        private FailedApiDataDBTable failedApiDataTable = null;
        private WarningDataDBTable warningDataDBTable = null;
        
@@ -36,6 +42,7 @@ public class SummaryDataManager extends PageDataManager {
                warningDataMaker = new WarningDataMaker();
                memoryAllocationDataTable = new MemoryAllocationDataDBTable();
                freeDataTable = new FreeDataDBTable();
+               leakDataTable = new LeakDataDBTable();
                failedApiDataTable = new FailedApiDataDBTable();
                warningDataDBTable = new WarningDataDBTable();
        }
@@ -60,6 +67,10 @@ public class SummaryDataManager extends PageDataManager {
                return freeDataTable;
        }
        
+       public DBTable getLeakDataDBTable() {
+               return leakDataTable;
+       }
+       
        public DBTable getFailedApiDataDBTable() {
                return failedApiDataTable;
        }
@@ -95,4 +106,29 @@ public class SummaryDataManager extends PageDataManager {
                        leakDataMaker.makeData(inputs);
                }
        }
+       
+       @Override
+       public void saveData(Map<String, String> dataMap) {
+               leakDataMaker.makeData();
+       }
+
+       @Override
+       public void openData(Map<String, String> dataMap) {
+               List<List<Object>> leakDataList = leakDataMaker.getLeakDataFromDB();
+               if (leakDataList == null) 
+                       return;
+               
+               int size = leakDataList.size();
+               NewLeakDetector leakDetector = AnalyzerManager.getNewLeakDetector();
+               leakDetector.clear();
+               
+               for (int i = 0; i < size; i++) {
+                       List<Object> iLeakData = leakDataList.get(i);
+                       int seqNum = (Integer) iLeakData.get(LeakDataDBTable.COLUMN_INDEX_SEQUENCE_NUMBER);
+                       long allocValue = (Long) iLeakData.get(LeakDataDBTable.COLUMN_INDEX_ALLOCATED_VALUE);
+                       int pid = (Integer) iLeakData.get(LeakDataDBTable.COLUMN_INDEX_PROCESS_ID);
+                       CurrentLeakData newLeakData = new CurrentLeakData(seqNum, allocValue, pid); 
+                       leakDetector.addCurrentLeakData(newLeakData);
+               }
+       }
 }

diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakDataDBInserter.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakDataDBInserter.java
new file mode 100644 (file)
index 0000000..561990c
--- /dev/null
+++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakDataDBInserter.java
@@ -0,0 +1,60 @@
+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 LeakDataDBInserter implements Runnable {
+       private static ReadBlockingQueue<List<List<Object>>> LeakDataQueue = new ReadBlockingQueue<List<List<Object>>>();
+
+       private static volatile Thread inserterThread = null;
+
+       public static void startThread() {
+               if (inserterThread == null || !inserterThread.isAlive()) {
+                       synchronized (LeakDataDBInserter.class) {
+                               if (inserterThread == null || !inserterThread.isAlive()) {
+                                       inserterThread = new Thread(null, new LeakDataDBInserter());
+                                       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<List<Object>> data) {
+               LeakDataQueue.offer(data);
+       }
+
+       public static void clear() {
+               stopThread();
+       }
+
+       @Override
+       public void run() {
+               while (!AnalyzerManager.isExit()) {
+                       List<List<Object>> leakData = LeakDataQueue.poll();
+
+                       if (leakData != null && leakData.size() != 0) {
+                               SummaryDataManager.getInstance().getLeakDataDBTable().insertData(leakData);
+                       }
+               }
+       }
+
+       public static void sendNotify() {
+               LeakDataQueue.wake();
+       }
+
+}

diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakDataDBTable.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakDataDBTable.java
new file mode 100644 (file)
index 0000000..f05835c
--- /dev/null
+++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakDataDBTable.java
@@ -0,0 +1,54 @@
+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 LeakDataDBTable extends DBTable {
+       private static final String TABLENAME = "LeakData";
+       
+       public static final String SEQUENCE_NUMBER = DBConstants.DBCOLUMN_SEQUENCE_NUMBER; 
+       public static final String ALLOCATED_VALUE = "ALLOCATED_VALUE";
+       public static final String PROCESS_ID = DBConstants.DBCOLUMN_PROCESS_ID;
+       
+       public final static int COLUMN_INDEX_SEQUENCE_NUMBER = 0;
+       public final static int COLUMN_INDEX_ALLOCATED_VALUE = 0;
+       public final static int COLUMN_INDEX_PROCESS_ID = 0;
+       
+       public LeakDataDBTable() {
+               addColumn(new DBColumn(SEQUENCE_NUMBER, DBConstants.PRIMARY_KEY, DBConstants.DBTYPE_INT4));
+               addColumn(new DBColumn(ALLOCATED_VALUE, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));        
+               addColumn(new DBColumn(PROCESS_ID, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+       }
+
+       @Override
+       public boolean prepare(PreparedStatement prep, List<Object> rowData) {
+               boolean isPrepared = true;
+               
+               int columnsize = getColumnSize();
+               if (columnsize != rowData.size()) {
+                       isPrepared = false;
+               } else {
+                       try {
+                               prep.setInt(1, (Integer) (rowData.get(0)));
+                               prep.setLong(2, (Long) (rowData.get(1)));
+                               prep.setInt(3, (Integer) (rowData.get(2)));
+                       } catch (SQLException e) {
+                               e.printStackTrace();
+                               isPrepared = false;
+                       }
+               }
+               
+               return isPrepared;
+       }
+
+       @Override
+       public String getTableName() {
+               return TABLENAME;
+       }
+
+}

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
index be082b2..9a30abd 100644 (file)
--- 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
@@ -1,6 +1,7 @@
 package org.tizen.dynamicanalyzer.ui.summary.leaks;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
 
 import org.eclipse.swt.SWT;
@@ -34,6 +35,7 @@ public class LeakDataMaker {
 
        private ArrayList<List<Object>> memoryAllocDataList;
        private ArrayList<List<Object>> freeDataList;
+       private ArrayList<List<Object>> leakDataList;
        private List<List<Object>> rangeDataList;
        private NewLeakDetector leakDetector = AnalyzerManager.getNewLeakDetector();
 
@@ -79,6 +81,22 @@ public class LeakDataMaker {
                        FreeDataDBInserter.startThread();
                }
        }
+       
+       public void makeData() {
+               HashMap<Integer, CurrentLeakData> leaks = leakDetector.getLeakHash();
+               for (Integer key : leaks.keySet()) {
+                       makeLeakData(leaks.get(key));
+               }
+               
+               if (leakDataList.size() > 0) {
+                       @SuppressWarnings("unchecked")
+                       List<List<Object>> lList = (List<List<Object>>) leakDataList.clone();
+                       leakDataList.clear();
+                       
+                       LeakDataDBInserter.pushFunctionData(lList);
+                       LeakDataDBInserter.startThread();
+               }
+       }
 
        private void checkHeapMemory() {
                if (leakDetector.getLeakHash().size() > DALimit.MAX_LEAK_CHECK_BUFFER_SIZE) {
@@ -174,6 +192,16 @@ public class LeakDataMaker {
 
                freeDataList.add(dbFreeData);
        }
+       
+       public void makeLeakData(CurrentLeakData input) {
+               ArrayList<Object> dbLeakData = new ArrayList<Object>();
+               
+               dbLeakData.add(Integer.valueOf(input.getSequenceNumber()));
+               dbLeakData.add(Long.valueOf(input.getAllocatedValue()));
+               dbLeakData.add(Integer.valueOf(input.getPid()));
+               
+               leakDataList.add(dbLeakData);
+       }
 
        public void clear() {
                memoryAllocDataList.clear();
@@ -199,6 +227,16 @@ public class LeakDataMaker {
 
                return table.selectData(columns, where);
        }
+       
+       public List<List<Object>> getLeakDataFromDB() {
+               DBTable table = SummaryDataManager.getInstance().getLeakDataDBTable();
+               List<String> columns = new ArrayList<String>();
+               columns.add(LeakDataDBTable.SEQUENCE_NUMBER);
+               columns.add(LeakDataDBTable.ALLOCATED_VALUE);
+               columns.add(LeakDataDBTable.PROCESS_ID);
+               
+               return table.selectData(columns, null);
+       }
 
        public List<List<Object>> getLeakDataWithSeq(List<Integer> leakSequenceNumbers) {
                String where = String

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
index a93f6ef..1edcd39 100644 (file)
--- 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
@@ -254,6 +254,12 @@ public class NewLeakDetector {
                leakSeq++;
        }
        
+       public void addCurrentLeakData(CurrentLeakData leakData) {
+               Integer key = leakData.getSequenceNumber();
+               getLeakHash().put(key.hashCode(), leakData);
+               leakSeq++;
+       }
+       
        private int findAllocatedKey(HashMap<Integer, CurrentLeakData> leaks, long addr, int pid) {
                for (Integer key : leaks.keySet()) {
                        CurrentLeakData iLeakData = leaks.get(key);

diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/StopLogProcessor.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/StopLogProcessor.java
index 0c9401e..acb271b 100644 (file)
--- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/StopLogProcessor.java
+++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/StopLogProcessor.java
@@ -108,8 +108,8 @@ public class StopLogProcessor implements Runnable {
                        DA_LOG.debug("project temp save is fail : project is not valid"); //$NON-NLS-1$
                } else {
                        project.setTotalStopTime(ToolbarArea.getInstance().getTime());
-                       SqlManager.getInstance().saveLeakData();
-                       SqlManager.getInstance().saveFailedData();
+//                     SqlManager.getInstance().saveLeakData();
+//                     SqlManager.getInstance().saveFailedData();
                        CallStackInserter.getInstance().stopInserterThread();
                        FunctionUsageProfiler.getInstance().saveProfilingData();
                        FunctionUsageProfiler.getInstance().saveProfilingChildData();