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;
private static HashMap<Integer, HashMap<Long, String>> 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();
imageListSize = 0;
leakDetector.clear();
- leakDetector2.clear(); // add 201405
+ newLeakDetector.clear();
failedChecker.clear();
warningChecker.clear();
calledChecker.clear();
return leakDetector;
}
- public static LeakDetector2 getLeakDetector2() { // add 201405
- return leakDetector2;
+ public static NewLeakDetector getNewLeakDetector() {
+ return newLeakDetector;
}
public static FailedChecker getFailedChecker() {
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());
- }
+// }
}
}
}
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());
- }
+// }
}
}
&& logData.getErrno() != GLES20ErrorDefine.GL_SUCCESS) {
// FailedData ffd = new FailedData(logData);
// AnalyzerManager.getFailedChecker().getFailedList().add(ffd);
- // add 201405
SummaryDataManager.getInstance().getFailedApiDataMaker().makeData(logData);
}
}
--- /dev/null
+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<LogData> inputs = memoryLogs.getLogs();
+
+ leakDataMaker.makeData(inputs);
+ }
+
+ Logs fileLogs = pack.getLogs(DataChannelConstants.MSG_PROBE_FILE);
+ if (null != fileLogs && fileLogs.getRawLogs().size() != 0) {
+ List<LogData> inputs = fileLogs.getLogs();
+
+ leakDataMaker.makeData(inputs);
+ }
+ }
+}
--- /dev/null
+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<List<List<Object>>> FailedApiDataQueue = new ReadBlockingQueue<List<List<Object>>>();
+
+ 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<List<Object>> data) {
+ FailedApiDataQueue.offer(data);
+ }
+
+ public static void clear() {
+ stopThread();
+ }
+
+ @Override
+ public void run() {
+ while (!AnalyzerManager.isExit()) {
+ List<List<Object>> failedApiData = FailedApiDataQueue.poll();
+
+ if (failedApiData != null && failedApiData.size() != 0) {
+ SummaryDataManager.getInstance().getFailedApiDataDBTable()
+ .insertData(failedApiData);
+ }
+ }
+ }
+
+ public static void sendNotify() {
+// synchronized (FailedApiDataQueue) {
+// FailedApiDataQueue.notifyAll();
+// }
+ FailedApiDataQueue.wake();
+ }
+}
--- /dev/null
+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<Object> 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;
+ }
+}
--- /dev/null
+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<List<Object>> failedApiDataList;
+
+ public FailedApiDataMaker() {
+ failedApiDataList = new ArrayList<List<Object>>();
+ }
+
+ public void makeData(List<LogData> 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<Object> dbFailedData = new ArrayList<Object>();
+
+ 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<List<Object>> fList = (List<List<Object>>) failedApiDataList.clone();
+ failedApiDataList.clear();
+
+ FailedApiDataDBInserter.pushFunctionData(fList);
+ FailedApiDataDBInserter.startThread();
+ }
+ }
+
+ public void makeData(LogData input) {
+ ProbeCommonData pData = (ProbeCommonData) input;
+
+ if (failChecker(pData)) {
+ ArrayList<Object> dbFailedData = new ArrayList<Object>();
+
+ 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<List<Object>> mList = (List<List<Object>>) 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<List<Object>> getFailedApiDataFromDB() {
+ DBTable table = SummaryDataManager.getInstance().getFailedApiDataDBTable();
+ List<String> columns = new ArrayList<String>();
+ 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);
+ }
+}
private boolean isRange = false;
- // add 201405
private final FailedApiDataMaker failedApiDataMaker =
SummaryDataManager.getInstance().getFailedApiDataMaker();
// return input;
// }
- // add 201405
protected List<TableInput> makeTableInput() {
// List<FailedData> failedList = null;
// if (isRange) {
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);
--- /dev/null
+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;
+ }
+}
--- /dev/null
+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<List<List<Object>>> FreeDataQueue = new ReadBlockingQueue<List<List<Object>>>();
+
+ 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<List<Object>> data) {
+ FreeDataQueue.offer(data);
+ }
+
+ public static void clear() {
+ stopThread();
+ }
+
+ @Override
+ public void run() {
+ while (!AnalyzerManager.isExit()) {
+ List<List<Object>> freeData = FreeDataQueue.poll();
+
+ if (freeData != null && freeData.size() != 0) {
+ SummaryDataManager.getInstance().getFreeDataDBTable()
+ .insertData(freeData);
+ }
+ }
+ }
+
+ public static void sendNotify() {
+// synchronized (FreeDataQueue) {
+// FreeDataQueue.notifyAll();
+// }
+ FreeDataQueue.wake();
+ }
+}
--- /dev/null
+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<Object> 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;
+ }
+}
--- /dev/null
+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<List<Object>> memoryAllocDataList;
+ private ArrayList<List<Object>> freeDataList;
+ private NewLeakDetector leakDetector = AnalyzerManager.getNewLeakDetector();
+
+ public LeakDataMaker() {
+ memoryAllocDataList = new ArrayList<List<Object>>();
+ freeDataList = new ArrayList<List<Object>>();
+ }
+
+ public void makeData(List<LogData> 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<List<Object>> mList = (List<List<Object>>) memoryAllocDataList.clone();
+ memoryAllocDataList.clear();
+
+ MemoryAllocationDataDBInserter.pushFunctionData(mList);
+ MemoryAllocationDataDBInserter.startThread();
+ }
+
+ if (freeDataList.size() > 0) {
+ @SuppressWarnings("unchecked")
+ List<List<Object>> fList = (List<List<Object>>) freeDataList.clone();
+ freeDataList.clear();
+
+ FreeDataDBInserter.pushFunctionData(fList);
+ FreeDataDBInserter.startThread();
+ }
+ }
+
+ public void makeAllocData(LogData log) {
+ ArrayList<Object> dbAllocData = new ArrayList<Object>();
+
+ 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<Object> dbFreeData = new ArrayList<Object>();
+
+ 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<List<Object>> getAllocationDataFromDB(int seq) {
+ String where = String.format(query_withSeq, MemoryAllocationDataDBTable.SEQ, seq);
+ DBTable table = SummaryDataManager.getInstance().getMemoryAllocationDataDBTable();
+ List<String> columns = new ArrayList<String>();
+ 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);
+ }
+}
private boolean isRange = false;
- // add 201405
private final LeakDataMaker leakDataMaker =
SummaryDataManager.getInstance().getLeakDataMaker();
// return output;
// }
- // add 201405
@Override
public List<TreeInput> makeTreeInput() {
List<TreeInput> output = new ArrayList<TreeInput>();
// leaks = RangeDataManager.getInstance().getLeakDetector2()
// .getLeakHash();
} else {
- leaks = AnalyzerManager.getLeakDetector2().getLeakHash();
+ leaks = AnalyzerManager.getNewLeakDetector().getLeakHash();
}
ArrayList<CurrentLeakData> leakList = new ArrayList<CurrentLeakData>();
// return output;
// }
- // add 201405
private TreeInput makeTreeInputForLeaks(CurrentLeakData leakInfo, int index) {
// TODO : need understand for the DATableDataFormat class
DATableDataFormat tableData = new DATableDataFormat(index);
List<Object> data = new ArrayList<Object>();
TreeInput output = null;
- int seq = leakInfo.getSequenceNumber();
- // TODO : rename getLeakDataFromDB() --> getAllocationDataFromDB()
- List<List<Object>> leakData = leakDataMaker.getLeakDataFromDB(seq);
+ int seq = leakInfo.getSequenceNumber();
+ List<List<Object>> 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<Object> 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 {
}
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 ??
}
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);
--- /dev/null
+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<List<List<Object>>> MemAllocDataQueue = new ReadBlockingQueue<List<List<Object>>>();
+
+ 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<List<Object>> data) {
+ MemAllocDataQueue.offer(data);
+ }
+
+ public static void clear() {
+ stopThread();
+ }
+
+ @Override
+ public void run() {
+ while (!AnalyzerManager.isExit()) {
+ List<List<Object>> memAllocData = MemAllocDataQueue.poll();
+
+ if (memAllocData != null && memAllocData.size() != 0) {
+ SummaryDataManager.getInstance().getMemoryAllocationDataDBTable()
+ .insertData(memAllocData);
+ }
+ }
+ }
+
+ public static void sendNotify() {
+// synchronized (MemAllocDataQueue) {
+// MemAllocDataQueue.notifyAll();
+// }
+ MemAllocDataQueue.wake();
+ }
+}
--- /dev/null
+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<Object> 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;
+ }
+}
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Jooyoul Lee <jy.exe.lee@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+
+package org.tizen.dynamicanalyzer.ui.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<Long, CurrentLeakData> leakHash;
+// HashMap<Long, CurrentLeakData> childHash;
+ HashMap<Integer, CurrentLeakData> leakHash;
+ private int leakSeq = 0;
+
+ public NewLeakDetector() {
+ }
+
+ public List<CurrentLeakData> getLeakDataList() {
+ List<CurrentLeakData> leakList = new ArrayList<CurrentLeakData>();
+ leakList.addAll(getLeakHash().values());
+ return leakList;
+ }
+
+ public HashMap<Integer, CurrentLeakData> getLeakHash() {
+ if (null == leakHash) {
+ leakHash = new HashMap<Integer, CurrentLeakData>();
+ }
+ return leakHash;
+ }
+
+// public HashMap<Long, CurrentLeakData> getChildHash() {
+// if (null == childHash) {
+// childHash = new HashMap<Long, CurrentLeakData>();
+// }
+// return childHash;
+// }
+
+ // public HashMap<String, Check> getLeakCheckHash() {
+ // if (null == leakCheckHash) {
+ // leakCheckHash = new HashMap<String, Check>();
+ // LeakCheckList leakCheckList = AnalyzerManager.getLeakCheckList();
+ // if (null != leakCheckList) {
+ // List<Check> 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<Long, CurrentLeakData> 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<Integer, CurrentLeakData> 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<Integer, CurrentLeakData> leaks, LogData log) {
+ CurrentLeakData newLeak = new CurrentLeakData(log);
+ leaks.put((Integer)leakSeq++, newLeak);
+ }
+
+ private int findAllocatedKey(HashMap<Integer, CurrentLeakData> 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;
+ }
+}
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),
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;
+ }
}
--- /dev/null
+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<List<List<Object>>> WarningDataQueue = new ReadBlockingQueue<List<List<Object>>>();
+
+ 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<List<Object>> data) {
+ WarningDataQueue.offer(data);
+ }
+
+ public static void clear() {
+ stopThread();
+ }
+
+ @Override
+ public void run() {
+ while (!AnalyzerManager.isExit()) {
+ List<List<Object>> warningData = WarningDataQueue.poll();
+
+ if (warningData != null && warningData.size() != 0) {
+ SummaryDataManager.getInstance().getWarningDataDBTable()
+ .insertData(warningData);
+ }
+ }
+ }
+
+ public static void sendNotify() {
+// synchronized (WarningDataQueue) {
+// WarningDataQueue.notifyAll();
+// }
+ WarningDataQueue.wake();
+ }
+}
--- /dev/null
+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<Object> 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;
+ }
+}
--- /dev/null
+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<List<Object>> warningDataList;
+
+ public WarningDataMaker() {
+ warningDataList = new ArrayList<List<Object>>();
+ }
+
+ public void makeData(List<LogData> 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<Object> dbWarningData = new ArrayList<Object>();
+
+ 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<List<Object>> wList = (List<List<Object>>) 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<Object> dbWarningData = new ArrayList<Object>();
+
+ 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<List<Object>> wList = (List<List<Object>>) 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<String> columns = new ArrayList<String>();
+ columns.add(WarningDataDBTable.WARNING_KEY);
+ columns.add(WarningDataDBTable.WARNING_CASE);
+
+ DBTable table = SummaryDataManager.getInstance().getWarningDataDBTable();
+
+ List<List<Object>> 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<List<Object>> getWarningDataFromDB() {
+ DBTable table = SummaryDataManager.getInstance().getWarningDataDBTable();
+ List<String> columns = new ArrayList<String>();
+ 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<String> columns = new ArrayList<String>();
+ columns.add(WarningDataDBTable.WARNING_KEY);
+ columns.add(WarningDataDBTable.WARNING_CASE);
+
+ DBTable table = SummaryDataManager.getInstance().getWarningDataDBTable();
+ List<List<Object>> result = table.selectData(columns, where);
+
+ String message = null;
+ if (result != null) {
+ List<Object> 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;
+ }
+}
// 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 {
public class WarningTable extends DATableComposite {
private boolean isRange = false;
- // add 201405
private final WarningDataMaker warningDataMaker =
SummaryDataManager.getInstance().getWarningDataMaker();
// return input;
// }
- // add 201405
protected List<TableInput> makeTableInput() {
// List<WarningData> warningList = null;
// if (isRange) {
List<String> text = new ArrayList<String>();
List<String> data = new ArrayList<String>();
- // 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
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(),
// 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());
// 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());
projects / sdk / tools / dynamic-analyzer.git / commitdiff