/* load from Database */
public ProbeCommonData(long seq, long time, int apiId, int pid, int tid, String args,
- String ret, int errno) {
+ String ret, long errno) {
this.seq = seq;
this.time = time;
this.apiId = apiId;
import org.tizen.dynamicanalyzer.swap.model.data.ProfileData;
import org.tizen.dynamicanalyzer.ui.summary.SummaryDataManager;
import org.tizen.dynamicanalyzer.ui.summary.leaks.GroupLeakData;
+import org.tizen.dynamicanalyzer.ui.summary.leaks.InternalLeakData;
+import org.tizen.dynamicanalyzer.ui.summary.leaks.InternalLeakDataBundle;
import org.tizen.dynamicanalyzer.ui.summary.leaks.LeakData;
import org.tizen.dynamicanalyzer.ui.summary.leaks.LeakDataBundle;
import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionSampleDBTable;
private HashMap<Integer, ProfileDataMaker> profileDataMakerMap = null;
private HashMap<Integer, ProfileDataMaker> swapProfileDataMakerMap = null;
private BaseCallstackManager swapCallstackManager = null;
- private HashMap<Integer, List<GroupLeakData>> rangeGroupDataHashMap;
+ private Map<Integer, List<GroupLeakData>> rangeGroupDataHashMap;
+ private Map<Integer, List<InternalLeakData>> rangeInternalDataHashMap;
private long markerStartTime = 0;
private long markerEndTime = 0;
swapProfileDataMakerMap.clear();
if (rangeGroupDataHashMap != null)
rangeGroupDataHashMap.clear();
+ if (rangeInternalDataHashMap != null)
+ rangeInternalDataHashMap.clear();
}
public void initRange() {
}
}
- public HashMap<Integer, List<GroupLeakData>> getRangeGroupDataHashMap() {
+ public Map<Integer, List<GroupLeakData>> getRangeGroupDataHashMap() {
if (rangeGroupDataHashMap == null) {
rangeGroupDataHashMap = new HashMap<Integer, List<GroupLeakData>>();
}
return rangeGroupDataHashMap;
}
- public HashMap<Integer, List<GroupLeakData>> getSelectedRangeGroupDataHashMap(List<Integer> selectedPids) {
- if (selectedPids.size() == 1 && selectedPids.get(0) == 0) // All process
+ public Map<Integer, List<InternalLeakData>> getRangeInternalDataHashMap() {
+ if (rangeInternalDataHashMap == null) {
+ rangeInternalDataHashMap = new HashMap<Integer, List<InternalLeakData>>();
+ }
+
+ return rangeInternalDataHashMap;
+ }
+
+ public Map<Integer, List<GroupLeakData>> getSelectedRangeGroupDataHashMap(
+ List<Integer> selectedPIDs) {
+ if (selectedPIDs.size() == 1 && selectedPIDs.get(0) == 0) // All process
return getRangeGroupDataHashMap();
- HashMap<Integer, List<GroupLeakData>> selectedData = new HashMap<Integer, List<GroupLeakData>>();
+ Map<Integer, List<GroupLeakData>> selectedData = new HashMap<Integer, List<GroupLeakData>>();
+ for (Integer selectedPID : selectedPIDs) {
+ selectedData.put(selectedPID, getRangeGroupDataHashMap().get(selectedPID));
+ }
+
+ return selectedData;
+ }
+
+ public Map<Integer, List<InternalLeakData>> getSelectedRangeInternalDataHashMap(
+ List<Integer> selectedPids) {
+ if (selectedPids.size() == 1 && selectedPids.get(0) == 0) // All process
+ return getRangeInternalDataHashMap();
+ Map<Integer, List<InternalLeakData>> selectedData = new HashMap<Integer, List<InternalLeakData>>();
for (Integer selectedPid : selectedPids) {
- selectedData.put(selectedPid, getRangeGroupDataHashMap().get(selectedPid));
+ selectedData.put(selectedPid, getRangeInternalDataHashMap().get(selectedPid));
}
return selectedData;
}
}
- // make range group data
+ // make range data for memory
makeRangeData();
+ makeInternalRangeData();
AnalyzerUtil.changePage(RangePage.pageID);
final DAPageComposite page = AnalyzerManager.getCurrentPage();
}
private void makeRangeData() {
- HashMap<Integer, List<GroupLeakData>> rangeDataHashMap = getRangeGroupDataHashMap();
+ Map<Integer, List<GroupLeakData>> rangeDataHashMap = getRangeGroupDataHashMap();
for (Map.Entry<Integer, LeakDataBundle> bundleEntry : AnalyzerManager.getLeakDetector()
.getLeakDataBundleHashMap().entrySet()) {
.getLeakDataMaker()
.getLeakDataForRange(bundleEntry.getKey().intValue(),
Long.valueOf(markerStartTime), Long.valueOf(markerEndTime));
- if (rangeRSFromDB == null)
- return;
+// if (rangeRSFromDB == null)
+// return;
List<GroupLeakData> groupDataList = leakBundle.makeRangeGroupData(rangeRSFromDB,
markerStartTime, markerEndTime);
rangeDataHashMap.put(bundleEntry.getKey(), groupDataList);
}
}
+
+ private void makeInternalRangeData() {
+ Map<Integer, List<InternalLeakData>> rangeInternalDataHashMap = getRangeInternalDataHashMap();
+
+ for (Map.Entry<Integer, InternalLeakDataBundle> bundleEntry : AnalyzerManager
+ .getLeakDetector().getInternalLeakDataBundleHashMap().entrySet()) {
+ InternalLeakDataBundle internalLeakBundle = bundleEntry.getValue();
+
+ ResultSet internalRangeRSFromDB = SummaryDataManager
+ .getInstance()
+ .getLeakDataMaker()
+ .getInernalLeakDataForRange(bundleEntry.getKey().intValue(),
+ Long.valueOf(markerStartTime), Long.valueOf(markerEndTime));
+
+ List<InternalLeakData> internalDataList = internalLeakBundle.makeRangeInternalData(
+ internalRangeRSFromDB, markerStartTime, markerEndTime);
+
+ if (internalDataList != null)
+ rangeInternalDataHashMap.put(bundleEntry.getKey(), internalDataList);
+ }
+ }
}
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.InternalLeakData;
+import org.tizen.dynamicanalyzer.ui.summary.leaks.InternalLeakDataBundle;
+import org.tizen.dynamicanalyzer.ui.summary.leaks.InternalMemoryAllocationDBTable;
import org.tizen.dynamicanalyzer.ui.summary.leaks.LeakDataBundle;
import org.tizen.dynamicanalyzer.ui.summary.leaks.LeakDataMaker;
import org.tizen.dynamicanalyzer.ui.summary.leaks.MemoryAllocationDBTable;
import org.tizen.dynamicanalyzer.ui.summary.leaks.MemoryAllocationDBTable.COLUMN;
import org.tizen.dynamicanalyzer.ui.summary.warning.WarningDataDBTable;
import org.tizen.dynamicanalyzer.ui.summary.warning.WarningDataMaker;
+import org.tizen.dynamicanalyzer.util.Logger;
public class SummaryDataManager extends PageDataManager {
private static SummaryDataManager instance = null;
private WarningDataMaker warningDataMaker = null;
private MemoryAllocationDBTable memoryAllocationTable = null;
+ private InternalMemoryAllocationDBTable internalMemoryAllocationTable = null;
private FailedApiDataDBTable failedApiDataTable = null;
private WarningDataDBTable warningDataDBTable = null;
private SummaryDataManager() {
memoryAllocationTable = new MemoryAllocationDBTable();
+ internalMemoryAllocationTable = new InternalMemoryAllocationDBTable();
failedApiDataTable = new FailedApiDataDBTable();
warningDataDBTable = new WarningDataDBTable();
- leakDataMaker = new LeakDataMaker(DBInsertManager.makeInserter(memoryAllocationTable));
+ leakDataMaker = new LeakDataMaker(DBInsertManager.makeInserter(memoryAllocationTable),
+ DBInsertManager.makeInserter(internalMemoryAllocationTable));
failedApiDataMaker = new FailedApiDataMaker(
DBInsertManager.makeInserter(failedApiDataTable));
warningDataMaker = new WarningDataMaker(warningDataDBTable);
public DBTable getMemoryAllocationDBTable() {
return memoryAllocationTable;
}
+
+ public DBTable getInternalMemoryAllocationDBTable() {
+ return internalMemoryAllocationTable;
+ }
public DBTable getFailedApiDataDBTable() {
return failedApiDataTable;
@Override
public void saveData(Map<String, String> dataMap) {
- // Grouping - user direct allocation
- leakDataMaker.saveLeakDataForGroup();
- warningDataMaker.insertDBWhenSave();
+ // Memory
+ leakDataMaker.saveLeakDataForGroup(); // Grouping - user direct allocation
+ leakDataMaker.saveInternalLeakData(); // Internal allocation
+
+ // Warning
+ warningDataMaker.insertDBWhenSave();
}
@Override
public void openData(Map<String, String> dataMap) {
- // Grouping - user direct allocation
- ResultSet rs = leakDataMaker.getLeakDataForGroupFromDB();
- if (rs == null)
- return;
-
LeakDetector leakDetector = AnalyzerManager.getLeakDetector();
leakDetector.clear();
- HashMap<Integer, LeakDataBundle> leakDataBundleHashMap = leakDetector
- .getLeakDataBundleHashMap();
- // TODO : optimize - get all process's range leak data
- try {
- while (rs.next()) {
- int pid = rs.getInt(MemoryAllocationDBTable.COLUMN.PROCESS_ID.index + 1);
- LeakDataBundle bundleData = leakDataBundleHashMap.get(pid);
- if (bundleData == null) {
- bundleData = new LeakDataBundle(pid);
+ // Memory (Grouping - user direct allocation)
+ ResultSet rs = leakDataMaker.getLeakDataForGroupFromDB();
+ if (rs != null) {
+ Map<Integer, LeakDataBundle> leakDataBundleHashMap = leakDetector
+ .getLeakDataBundleHashMap();
+ // TODO : optimize - get all process's range leak data
+ try {
+ while (rs.next()) {
+ int pid = rs.getInt(MemoryAllocationDBTable.COLUMN.PROCESS_ID.index + 1);
+ LeakDataBundle bundleData = leakDataBundleHashMap.get(pid);
+ if (bundleData == null) {
+ bundleData = new LeakDataBundle(pid);
+// leakDataBundleHashMap.put(Integer.valueOf(pid), bundleData);
+ }
+
+ bundleData.addLeakDataForOpen(rs);
leakDataBundleHashMap.put(Integer.valueOf(pid), bundleData);
}
-
- bundleData.addLeakDataForOpen(rs);
- leakDataBundleHashMap.put(Integer.valueOf(pid), bundleData);
- }
- } catch (SQLException e) {
- e.printStackTrace();
- } finally {
- SqlConnectionManager.releaseResultSet(rs);
+ } catch (SQLException e) {
+ Logger.exception(e);
+ } finally {
+ SqlConnectionManager.releaseResultSet(rs);
+ }
}
- // TODO : Internal allocation
+ // Memory (Internal allocation)
+ ResultSet internalRS = leakDataMaker.getInternalLeakDataFromDB();
+ if (internalRS != null) {
+ Map<Integer, InternalLeakDataBundle> internalLeakDataBundleHashMap = leakDetector
+ .getInternalLeakDataBundleHashMap();
+ try {
+ while (internalRS.next()) {
+ int pid = internalRS.getInt(InternalMemoryAllocationDBTable.COLUMN.PROCESS_ID.index + 1);
+ InternalLeakDataBundle bundleData = internalLeakDataBundleHashMap.get(pid);
+ if (bundleData == null)
+ bundleData = new InternalLeakDataBundle(pid);
+
+ bundleData.addInternalLeakData(internalRS);
+ internalLeakDataBundleHashMap.put(Integer.valueOf(pid), bundleData);
+ }
+ } catch (SQLException e) {
+ Logger.exception(e);
+ } finally {
+ SqlConnectionManager.releaseResultSet(internalRS);
+ }
+ }
+ // Warning
warningDataMaker.selectDBWhenOpen();
}
}
.get(FailedApiDataDBTable.COLUMN_INDEX_CALLER_LIBRARY_NAME);
data.add(libName);
- // create images
-
// create DATableDataFormat
DATableDataFormat tableData = new DATableDataFormat(seq);
- // tableData.setObject(failedData);
// make ProbeCommonData for table data
- ProbeCommonData probeData = new ProbeCommonData();
- probeData.setSeq(seq);
- probeData.setApiName(apiName);
- probeData.setPid(pid);
- probeData.setTime(time);
- probeData.setArgs(args);
- probeData.setReturn(retValue);
- probeData.setErrNo(errNum);
+ ProbeCommonData probeData = new ProbeCommonData(seq, time, apiId, pid, 0, args,
+ retValue, errNum);
+ probeData.setId((Integer) idata.get(FailedApiDataDBTable.COLUMN_INDEX_MESSAGE_ID));
probeData.setCallerAddress(callerPcAddr);
probeData.setLibName(libName);
- probeData.setId((Integer) idata.get(FailedApiDataDBTable.COLUMN_INDEX_MESSAGE_ID));
+
tableData.setLogData(probeData);
- // tableData.setLogData(failedData.getData());
tableData.getData().addAll(data);
tableData.setType(AnalyzerConstants.TYPE_TABLE_FAILED);
private int threadID;
private int functionID; // for api name
private int binaryID; // for caller library name
- private int apiID; // for double click action on table item
+ private int msgID; // for double click action on table item
- public CommonLeakData(int threadID, int functionID, int binaryID, int apiID) {
+ public CommonLeakData(int threadID, int functionID, int binaryID, int msgID) {
this.threadID = threadID;
this.functionID = functionID;
this.binaryID = binaryID;
- this.apiID = apiID;
+ this.msgID = msgID;
}
public int getThreadID() {
return binaryID;
}
- public int getApiID() {
- return apiID;
+ public int getMsgID() {
+ return msgID;
}
}
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Seokgil Kang <seokgil.kang@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.sql.ResultSet;
+import java.sql.SQLException;
+
+import org.tizen.dynamicanalyzer.common.Global;
+import org.tizen.dynamicanalyzer.project.LibraryObject;
+import org.tizen.dynamicanalyzer.project.ProcessInformation;
+import org.tizen.dynamicanalyzer.project.ProcessMemoryMap;
+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.util.Logger;
+
+public class InternalLeakData {
+ private long seq;
+ private int threadID;
+ private int functionID; // for api name
+ private int binaryID; // for caller library name
+ private int msgID; // for double click action on table item
+ private long callerPCAddr;
+ private long allocatedTime;
+ private long allocatedMemorySize;
+
+ public InternalLeakData(LogData log) {
+ this.seq = log.getSeq();
+ this.threadID = ((ProbeCommonData) log).getTid();
+ this.functionID = ((ProbeCommonData) log).getApiId();
+ this.binaryID = getBinaryIDFromLogData(log);
+ this.msgID = log.getId();
+ this.callerPCAddr = ((ProbeCommonData) log).getCallerPcAddr();
+ this.allocatedTime = log.getTime();
+ this.allocatedMemorySize = ((MemoryData) log).getSize();
+ }
+
+ public InternalLeakData(ResultSet rs) throws SQLException {
+ this.seq = rs.getLong(InternalMemoryAllocationDBTable.COLUMN.SEQUENCE_NUMBER.index + 1);
+ this.threadID = rs.getInt(InternalMemoryAllocationDBTable.COLUMN.THREAD_ID.index + 1);
+ this.functionID = rs.getInt(InternalMemoryAllocationDBTable.COLUMN.FUNCTION_ID.index + 1);
+ this.binaryID = rs.getInt(InternalMemoryAllocationDBTable.COLUMN.BINARY_ID.index + 1);
+ this.msgID = rs.getInt(InternalMemoryAllocationDBTable.COLUMN.MESSAGE_ID.index + 1);
+ this.callerPCAddr = rs
+ .getLong(InternalMemoryAllocationDBTable.COLUMN.CALLER_PC_ADDRESS.index + 1);
+ this.allocatedTime = rs
+ .getLong(InternalMemoryAllocationDBTable.COLUMN.ALLOCATED_TIME.index + 1);
+ this.allocatedMemorySize = rs
+ .getLong(InternalMemoryAllocationDBTable.COLUMN.ALLOCATED_MEMORY_SIZE.index);
+ }
+
+ public long getSequenceNumber() {
+ return seq;
+ }
+
+ public int getThreadID() {
+ return threadID;
+ }
+
+ public int getFunctionID() {
+ return functionID;
+ }
+
+ public int getBinaryID() {
+ return binaryID;
+ }
+
+ public int getMsgID() {
+ return msgID;
+ }
+
+ public long getCallerPCAddress() {
+ return callerPCAddr;
+ }
+
+ public long getAllocatedTime() {
+ return allocatedTime;
+ }
+
+ public long getAllocatedMemorySize() {
+ return allocatedMemorySize;
+ }
+
+ private int getBinaryIDFromLogData(LogData log) {
+ ProcessInformation process = Global.getProject().getProcessInformation(log.getPid());
+ long time = log.getTime();
+ if (time > 0) {
+ LibraryObject obj = null;
+ ProcessMemoryMap pmap = process.getProcessMemoryMap(time);
+ if (pmap == null
+ || (obj = pmap.getLibraryByAddress(((ProbeCommonData) log).getCallerPcAddr())) == null) {
+ return -1;
+ } else {
+ return obj.getBinaryID();
+ }
+ } else {
+ return -1;
+ }
+ }
+
+}
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Seokgil Kang <seokgil.kang@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.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.tizen.dynamicanalyzer.database.SqlConnectionManager;
+import org.tizen.dynamicanalyzer.swap.model.data.LogData;
+import org.tizen.dynamicanalyzer.swap.model.data.MemoryData;
+import org.tizen.dynamicanalyzer.util.Logger;
+
+public class InternalLeakDataBundle {
+ private int pid;
+ private Map<Long, InternalLeakData> internalLeakDataHashMap;
+ private Map<Long, InternalLeakData> rangeInternalLeakDataHashMap;
+
+ public InternalLeakDataBundle(int pid) {
+ this.pid = pid;
+ internalLeakDataHashMap = new ConcurrentHashMap<Long, InternalLeakData>();
+ rangeInternalLeakDataHashMap = new HashMap<Long, InternalLeakData>();
+ }
+
+ public Map<Long, InternalLeakData> getInternalLeakDataHashMap() {
+ return internalLeakDataHashMap;
+ }
+
+ public Map<Long, InternalLeakData> getRangeInternalLeakDataHashMap() {
+ return rangeInternalLeakDataHashMap;
+ }
+
+ public InternalLeakData getInternalLeakData(long allocatedAddress) {
+ return internalLeakDataHashMap.get((Long) allocatedAddress);
+ }
+
+ public void addInternalLeakData(LogData log) {
+ checkReallocApi(log);
+ InternalLeakData data = new InternalLeakData(log);
+ internalLeakDataHashMap.put(Long.valueOf(((MemoryData) log).getAddress()), data);
+ }
+
+ public void addInternalLeakData(ResultSet rs) throws SQLException {
+ InternalLeakData internalData = new InternalLeakData(rs);
+ internalLeakDataHashMap.put(Long.valueOf(rs
+ .getLong(InternalMemoryAllocationDBTable.COLUMN.ALLOCATED_ADDRESS.index + 1)),
+ internalData);
+ }
+
+ public void removeInternalLeakData(long address) {
+ InternalLeakData data = internalLeakDataHashMap.remove((Long) address);
+ if (data == null) {
+ Logger.error("Management of InternalLeakData is failed !!");
+ }
+ }
+
+ public List<InternalLeakData> makeRangeInternalData(ResultSet rangeRSFromDB, long startTime,
+ long endTime) {
+ if (rangeInternalLeakDataHashMap != null && rangeInternalLeakDataHashMap.size() > 0)
+ rangeInternalLeakDataHashMap.clear();
+
+ List<InternalLeakData> internalDataList = new ArrayList<InternalLeakData>();
+
+ // make range data - memory data
+ Iterator<Map.Entry<Long, InternalLeakData>> iter = internalLeakDataHashMap.entrySet().iterator();
+ while (iter.hasNext()) {
+ Map.Entry<Long, InternalLeakData> iterData = iter.next();
+ Long key = iterData.getKey();
+ InternalLeakData internalData = iterData.getValue();
+ if (internalData != null) {
+ if (internalData.getAllocatedTime() >= startTime && internalData.getAllocatedTime() <= endTime) {
+ rangeInternalLeakDataHashMap.put(key, internalData);
+ }
+ }
+ }
+
+ // make range data - db data
+ if (rangeRSFromDB != null)
+ addInternalDataFromDBForRange(rangeRSFromDB);
+
+ internalDataList.addAll(rangeInternalLeakDataHashMap.values());
+ return internalDataList;
+ }
+
+ private void checkReallocApi(LogData log) {
+ if (log instanceof MemoryData) {
+ MemoryData mlog = (MemoryData) log;
+ if (mlog.getApiName().contains("realloc")) {
+ String inputParam = mlog.getArgs();
+ String[] splitInputParam = inputParam.split("\\,"); //$NON-NLS-1$
+ String param = String.valueOf(splitInputParam[0]);
+ long rmKey = -1;
+ try {
+ if (param.contains("0x")) {
+ // The 'param' is a decoding value and it was a memory address assigned previously.
+ // This part is actually used.
+ rmKey = Long.decode(param);
+ } else {
+ rmKey = Long.parseLong(splitInputParam[0]);
+ }
+ internalLeakDataHashMap.remove(rmKey);
+ } catch (NumberFormatException e) {
+ Logger.exception(e);
+ }
+ }
+ }
+ }
+
+ private void addInternalDataFromDBForRange(ResultSet rs) {
+ try {
+ while (rs.next()) {
+ rangeInternalLeakDataHashMap
+ .put(rs.getLong(InternalMemoryAllocationDBTable.COLUMN.ALLOCATED_ADDRESS.index + 1),
+ new InternalLeakData(rs));
+ }
+ } catch (SQLException e) {
+ Logger.exception(e);
+ } finally {
+ SqlConnectionManager.releaseResultSet(rs);
+ }
+ }
+}
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2014 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Seokgil Kang <seokgil.kang@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.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.tizen.dynamicanalyzer.constant.CommonConstants;
+import org.tizen.dynamicanalyzer.database.DBColumn;
+import org.tizen.dynamicanalyzer.database.DBConstants;
+import org.tizen.dynamicanalyzer.database.DBTable;
+import org.tizen.dynamicanalyzer.util.Logger;
+
+public class InternalMemoryAllocationDBTable extends DBTable {
+ private static final String TABLENAME = "INTERNAL_MEMORY_ALLOCATION";
+
+ public static final String SELECT_COLUMN_FOR_RANGE =
+ COLUMN.SEQUENCE_NUMBER.name + CommonConstants.COMMA +
+ COLUMN.PROCESS_ID.name + CommonConstants.COMMA +
+ COLUMN.THREAD_ID.name + CommonConstants.COMMA +
+ COLUMN.BINARY_ID.name + CommonConstants.COMMA +
+ COLUMN.FUNCTION_ID.name + CommonConstants.COMMA +
+ COLUMN.MESSAGE_ID.name + CommonConstants.COMMA +
+ COLUMN.CALLER_PC_ADDRESS.name + CommonConstants.COMMA +
+ COLUMN.ALLOCATED_ADDRESS.name + CommonConstants.COMMA +
+ COLUMN.ALLOCATED_TIME.name + CommonConstants.COMMA +
+ COLUMN.ALLOCATED_MEMORY_SIZE.name;
+
+ public static final String INTERNAL_RANGE_SELECT_QUERY_WITH_PID =
+ "select " + InternalMemoryAllocationDBTable.SELECT_COLUMN_FOR_RANGE +
+ " from " + TABLENAME +
+ " where " + COLUMN.PROCESS_ID.name + " = %s and " +
+ COLUMN.ALLOCATED_TIME.name + " between %s and %s and (" +
+ COLUMN.FREE_TIME.name + " > %s)";
+
+ public static final String OPEN_INTERNAL_DATA_SELECT_QUERY =
+ "select " + InternalMemoryAllocationDBTable.SELECT_COLUMN_FOR_RANGE +
+ " from " + TABLENAME +
+ " where " + COLUMN.FREE_TIME.name + " = -1";
+
+ public enum COLUMN {
+ SEQUENCE_NUMBER(0, DBConstants.DBCOLUMN_SEQUENCE_NUMBER),
+ PROCESS_ID(1, DBConstants.DBCOLUMN_PROCESS_ID),
+ THREAD_ID(2, DBConstants.DBCOLUMN_THREAD_ID),
+ BINARY_ID(3, "BINARY_ID"),
+ FUNCTION_ID(4, DBConstants.DBCOLUMN_FUNCTION_ID),
+ MESSAGE_ID(5, "MESSAGE_ID"),
+ CALLER_PC_ADDRESS(6, DBConstants.DBCOLUMN_CALLER_PC_ADDRESS),
+ ALLOCATED_ADDRESS(7, "ALLOCATED_ADDRESS"),
+ ALLOCATED_TIME(8, "ALLOCATED_TIME"),
+ FREE_TIME(9, "FREE_TIME"),
+ ALLOCATED_MEMORY_SIZE(10, "ALLOCATED_MEMORY_SIZE");
+
+ public final int index;
+ public final String name;
+
+ COLUMN(int index, String name) {
+ this.index = index;
+ this.name = name;
+ }
+ }
+
+ @Override
+ public String getTableName() {
+ return TABLENAME;
+ }
+
+ public InternalMemoryAllocationDBTable() {
+ addColumn(new DBColumn(COLUMN.SEQUENCE_NUMBER.name, DBConstants.PRIMARY_KEY,
+ DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.PROCESS_ID.name, DBConstants.NOT_NULL,
+ DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.THREAD_ID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.BINARY_ID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.FUNCTION_ID.name, DBConstants.NOT_NULL,
+ DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.MESSAGE_ID.name, DBConstants.NOT_NULL,
+ DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.CALLER_PC_ADDRESS.name, DBConstants.EMPTY,
+ DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.ALLOCATED_ADDRESS.name, DBConstants.NOT_NULL,
+ DBConstants.DBTYPE_LONG)); // default:-1
+ addColumn(new DBColumn(COLUMN.ALLOCATED_TIME.name, DBConstants.NOT_NULL,
+ DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.FREE_TIME.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.ALLOCATED_MEMORY_SIZE.name, DBConstants.NOT_NULL,
+ DBConstants.DBTYPE_LONG));
+ setIndexColumn(COLUMN.ALLOCATED_TIME.index);
+ setIndexColumn(COLUMN.FREE_TIME.index);
+ }
+
+ @Override
+ public boolean prepare(PreparedStatement prep, List<Object> rowData) {
+ boolean isPrepared = true;
+
+ int columnsize = getColumnSize();
+ if (columnsize != rowData.size()) {
+ isPrepared = false;
+ } else {
+ try {
+ prep.setLong(COLUMN.SEQUENCE_NUMBER.index + 1,
+ (Long) (rowData.get(COLUMN.SEQUENCE_NUMBER.index)));
+ prep.setInt(COLUMN.PROCESS_ID.index + 1,
+ (Integer) (rowData.get(COLUMN.PROCESS_ID.index)));
+ prep.setInt(COLUMN.THREAD_ID.index + 1,
+ (Integer) (rowData.get(COLUMN.THREAD_ID.index)));
+ prep.setInt(COLUMN.BINARY_ID.index + 1,
+ (Integer) (rowData.get(COLUMN.BINARY_ID.index)));
+ prep.setInt(COLUMN.FUNCTION_ID.index + 1,
+ (Integer) (rowData.get(COLUMN.FUNCTION_ID.index)));
+ prep.setInt(COLUMN.MESSAGE_ID.index + 1,
+ (Integer) (rowData.get(COLUMN.MESSAGE_ID.index)));
+ prep.setLong(COLUMN.CALLER_PC_ADDRESS.index + 1,
+ (Long) (rowData.get(COLUMN.CALLER_PC_ADDRESS.index)));
+ prep.setLong(COLUMN.ALLOCATED_ADDRESS.index + 1,
+ (Long) (rowData.get(COLUMN.ALLOCATED_ADDRESS.index)));
+ prep.setLong(COLUMN.ALLOCATED_TIME.index + 1,
+ (Long) (rowData.get(COLUMN.ALLOCATED_TIME.index)));
+ prep.setLong(COLUMN.FREE_TIME.index + 1,
+ (Long) (rowData.get(COLUMN.FREE_TIME.index)));
+ prep.setLong(COLUMN.ALLOCATED_MEMORY_SIZE.index + 1,
+ (Long) (rowData.get(COLUMN.ALLOCATED_MEMORY_SIZE.index)));
+ } catch (SQLException e) {
+ Logger.exception(e);
+ isPrepared = false;
+ }
+ }
+
+ return isPrepared;
+ }
+
+ @Override
+ public List<Object> extractDataFromResultSet(ResultSet rs) {
+ List<Object> row = new ArrayList<Object>();
+ try {
+ row.add(Long.valueOf(rs.getLong(COLUMN.SEQUENCE_NUMBER.index + 1)));
+ row.add(Integer.valueOf(rs.getInt(COLUMN.PROCESS_ID.index + 1)));
+ row.add(Integer.valueOf(rs.getInt(COLUMN.THREAD_ID.index + 1)));
+ row.add(Integer.valueOf(rs.getInt(COLUMN.BINARY_ID.index + 1)));
+ row.add(Integer.valueOf(rs.getInt(COLUMN.FUNCTION_ID.index + 1)));
+ row.add(Integer.valueOf(rs.getInt(COLUMN.MESSAGE_ID.index + 1)));
+ row.add(Long.valueOf(rs.getLong(COLUMN.CALLER_PC_ADDRESS.index + 1)));
+ row.add(Long.valueOf(rs.getLong(COLUMN.ALLOCATED_ADDRESS.index + 1)));
+ row.add(Long.valueOf(rs.getLong(COLUMN.ALLOCATED_TIME.index + 1)));
+ row.add(Long.valueOf(rs.getLong(COLUMN.FREE_TIME.index + 1)));
+ row.add(Long.valueOf(rs.getLong(COLUMN.ALLOCATED_MEMORY_SIZE.index + 1)));
+ } catch (SQLException e) {
+ Logger.exception(e);
+ return null;
+ }
+
+ return row;
+ }
+}
public class LeakDataBundle {
private int pid;
private ArrayList<CommonLeakData> commonLeakDataList;
- private HashMap<Integer, Integer> commonLeakDataIndexHashMap;
+ private Map<Integer, Integer> commonLeakDataIndexHashMap;
private HashMap<Long, LeakData> leakDataHashMap;
- private HashMap<Integer, GroupLeakData> groupLeakDataHashMap;
- private HashMap<Integer, GroupLeakData> rangeGroupLeakDataHashMap;
+ private Map<Integer, GroupLeakData> groupLeakDataHashMap;
+ private Map<Integer, GroupLeakData> rangeGroupLeakDataHashMap;
public LeakDataBundle(int pid) {
this.pid = pid;
return commonLeakDataList;
}
- public HashMap<Integer, Integer> getCommonLeakDataIndexHashMap() {
+ public Map<Integer, Integer> getCommonLeakDataIndexHashMap() {
return commonLeakDataIndexHashMap;
}
return leakDataHashMap;
}
- public HashMap<Integer, GroupLeakData> getGroupLeakDataHashMap() {
+ public Map<Integer, GroupLeakData> getGroupLeakDataHashMap() {
return groupLeakDataHashMap;
}
- public HashMap<Integer, GroupLeakData> getRangeGroupLeakDataHashMap() {
+ public Map<Integer, GroupLeakData> getRangeGroupLeakDataHashMap() {
return rangeGroupLeakDataHashMap;
}
/* remove leak data */
LeakData data = leakDataHashMap.remove(Long.valueOf(allocatedAddress));
if (data == null) {
- // TODO : remove when support the running process
- Logger.debug("LeakData is null !!");
+ Logger.error("Management of LeakData is failed !!");
return;
}
public List<GroupLeakData> makeRangeGroupData(ResultSet rangeRSFromDB, long startTime,
long endTime) {
- if (rangeGroupLeakDataHashMap != null)
+ if (rangeGroupLeakDataHashMap != null && rangeGroupLeakDataHashMap.size() > 0)
rangeGroupLeakDataHashMap.clear();
List<GroupLeakData> groupDataList = new ArrayList<GroupLeakData>();
}
// make range group - db data
- updateGroupDataForRange(rangeRSFromDB);
+ if (rangeRSFromDB != null)
+ updateGroupDataForRange(rangeRSFromDB);
+
+ if (rangeGroupLeakDataHashMap != null)
+ groupDataList.addAll(rangeGroupLeakDataHashMap.values());
- groupDataList.addAll(rangeGroupLeakDataHashMap.values());
return groupDataList;
}
int threadID = ((ProbeCommonData) log).getTid();
int functionID = ((ProbeCommonData) log).getApiId();
int binaryID = getBinaryIDFromLogData(log);
- int apiID = log.getId();
+ int msgID = log.getId();
// TODO : validation check for binary ID
int key = makeCommonLeakDataKey(threadID, functionID, binaryID);
commonDataIndex = commonLeakDataIndexHashMap.get(Integer.valueOf(key));
if (commonDataIndex == null) {
commonDataIndex = Integer
- .valueOf(addLeakCommonData(threadID, functionID, binaryID, apiID, key));
+ .valueOf(addLeakCommonData(threadID, functionID, binaryID, msgID, key));
}
return commonDataIndex.intValue();
int threadID = rs.getInt(MemoryAllocationDBTable.COLUMN.THREAD_ID.index + 1);
int functionID = rs.getInt(MemoryAllocationDBTable.COLUMN.FUNCTION_ID.index + 1);
int binaryID = rs.getInt(MemoryAllocationDBTable.COLUMN.BINARY_ID.index + 1);
- int apiID = rs.getInt(MemoryAllocationDBTable.COLUMN.API_ID.index + 1);
+ int msgID = rs.getInt(MemoryAllocationDBTable.COLUMN.MESSAGE_ID.index + 1);
// TODO : validation check for binary ID
int key = makeCommonLeakDataKey(threadID, functionID, binaryID);
commonDataIndex = commonLeakDataIndexHashMap.get(Integer.valueOf(key));
if (commonDataIndex == null) {
commonDataIndex = Integer
- .valueOf(addLeakCommonData(threadID, functionID, binaryID, apiID, key));
+ .valueOf(addLeakCommonData(threadID, functionID, binaryID, msgID, key));
}
return commonDataIndex.intValue();
public class LeakDataMaker {
private LeakDetector leakDetector = AnalyzerManager.getLeakDetector();
private ArrayList<List<Object>> memoryDataList;
+ private ArrayList<List<Object>> internalMemoryDataList;
private DBInserter memoryDBInserter = null;
-
- public LeakDataMaker(DBInserter allocInserter) {
+ private DBInserter internalMemoryDBInserter = null;
+
+ public LeakDataMaker(DBInserter allocInserter, DBInserter internalAllocInserter) {
memoryDataList = new ArrayList<List<Object>>();
+ internalMemoryDataList = new ArrayList<List<Object>>();
memoryDBInserter = allocInserter;
+ internalMemoryDBInserter = internalAllocInserter;
}
-
+
public void makeData(CommonLeakData commonData, LeakData leakData, LogData log) {
ArrayList<Object> dbLeakData = new ArrayList<Object>();
MemoryData mData = (MemoryData) log;
-
+
dbLeakData.add(Long.valueOf(leakData.getSequenceNumber()));
dbLeakData.add(Integer.valueOf(mData.getPid()));
dbLeakData.add(Integer.valueOf(commonData.getThreadID()));
dbLeakData.add(Integer.valueOf(commonData.getBinaryID()));
dbLeakData.add(Integer.valueOf(commonData.getFunctionID()));
- dbLeakData.add(Integer.valueOf(commonData.getApiID()));
+ dbLeakData.add(Integer.valueOf(commonData.getMsgID()));
dbLeakData.add(Long.valueOf(leakData.getCallerPCAddress()));
dbLeakData.add(Long.valueOf(mData.getAddress()));
dbLeakData.add(Long.valueOf(leakData.getAllocatedTime()));
dbLeakData.add(Long.valueOf(mData.getTime()));
dbLeakData.add(Long.valueOf(leakData.getAllocatedMemorySize()));
-
+
memoryDataList.add(dbLeakData);
@SuppressWarnings("unchecked")
List<List<Object>> mList = (List<List<Object>>) memoryDataList.clone();
memoryDataList.clear();
-
- memoryDBInserter.pushData(mList);
+
+ memoryDBInserter.pushData(mList);
}
-
+
+ public void makeInternalData(InternalLeakData leakData, LogData log) {
+ ArrayList<Object> dbInternalLeakData = new ArrayList<Object>();
+ MemoryData mData = (MemoryData) log;
+
+ dbInternalLeakData.add(Long.valueOf(leakData.getSequenceNumber()));
+ dbInternalLeakData.add(Integer.valueOf(mData.getPid()));
+ dbInternalLeakData.add(Integer.valueOf(leakData.getThreadID()));
+ dbInternalLeakData.add(Integer.valueOf(leakData.getBinaryID()));
+ dbInternalLeakData.add(Integer.valueOf(leakData.getFunctionID()));
+ dbInternalLeakData.add(Integer.valueOf(leakData.getMsgID()));
+ dbInternalLeakData.add(Long.valueOf(leakData.getCallerPCAddress()));
+ dbInternalLeakData.add(Long.valueOf(mData.getAddress()));
+ dbInternalLeakData.add(Long.valueOf(leakData.getAllocatedTime()));
+ dbInternalLeakData.add(Long.valueOf(mData.getTime()));
+ dbInternalLeakData.add(Long.valueOf(leakData.getAllocatedMemorySize()));
+
+ internalMemoryDataList.add(dbInternalLeakData);
+ @SuppressWarnings("unchecked")
+ List<List<Object>> mList = (List<List<Object>>) internalMemoryDataList.clone();
+ internalMemoryDataList.clear();
+
+ internalMemoryDBInserter.pushData(mList);
+ }
+
public void saveLeakDataForGroup() {
- HashMap<Integer, LeakDataBundle> leakDataBundleHashMap = leakDetector.getLeakDataBundleHashMap();
+ Map<Integer, LeakDataBundle> leakDataBundleHashMap = leakDetector
+ .getLeakDataBundleHashMap();
for (Map.Entry<Integer, LeakDataBundle> bundleEntry : leakDataBundleHashMap.entrySet()) {
LeakDataBundle iLeakDataBundle = bundleEntry.getValue();
- makeMemoryAllocationDBRecord(bundleEntry.getKey().intValue(),
- iLeakDataBundle);
+ makeMemoryAllocationDBRecord(bundleEntry.getKey().intValue(), iLeakDataBundle);
}
-
+
@SuppressWarnings("unchecked")
List<List<Object>> mList = (List<List<Object>>) memoryDataList.clone();
memoryDataList.clear();
-
+
SummaryDataManager.getInstance().getMemoryAllocationDBTable().insertData(mList);
}
+
+ public void saveInternalLeakData() {
+ Map<Integer, InternalLeakDataBundle> internalLeakDataBundleHashMap = leakDetector
+ .getInternalLeakDataBundleHashMap();
+ for (Map.Entry<Integer, InternalLeakDataBundle> bundleEntry : internalLeakDataBundleHashMap
+ .entrySet()) {
+ InternalLeakDataBundle iInternalLeakDataBundle = bundleEntry.getValue();
+ makeInternalMemoryAllocationDBRecord(bundleEntry.getKey().intValue(), iInternalLeakDataBundle);
+ }
+
+ @SuppressWarnings("unchecked")
+ List<List<Object>> mList = (List<List<Object>>) internalMemoryDataList.clone();
+ internalMemoryDataList.clear();
+
+ SummaryDataManager.getInstance().getInternalMemoryAllocationDBTable().insertData(mList);
+ }
+
+ public void clear() {
+ memoryDataList.clear();
+ internalMemoryDataList.clear();
+ memoryDBInserter.clear();
+ internalMemoryDBInserter.clear();
+ }
+
+ public ResultSet getLeakDataForGroupFromDB() {
+ String query = String.format(MemoryAllocationDBTable.OPEN_DATA_SELECT_QUERY);
+ return SqlConnectionManager.executeQueryRS(query);
+ }
+
+ public ResultSet getInternalLeakDataFromDB() {
+ String query = String
+ .format(InternalMemoryAllocationDBTable.OPEN_INTERNAL_DATA_SELECT_QUERY);
+ return SqlConnectionManager.executeQueryRS(query);
+ }
+
+ public ResultSet getLeakDataForRange(int pid, long startTime, long endTime) {
+ String query = String.format(MemoryAllocationDBTable.RANGE_SELECT_QUERY_WITH_PID, pid, Long
+ .valueOf(startTime).toString(), Long.valueOf(endTime).toString(),
+ Long.valueOf(endTime).toString());
+ return SqlConnectionManager.executeQueryRS(query);
+ }
+
+ public ResultSet getInernalLeakDataForRange(int pid, long startTime, long endTime) {
+ String query = String.format(
+ InternalMemoryAllocationDBTable.INTERNAL_RANGE_SELECT_QUERY_WITH_PID, pid, Long
+ .valueOf(startTime).toString(), Long.valueOf(endTime).toString(), Long
+ .valueOf(endTime).toString());
+ return SqlConnectionManager.executeQueryRS(query);
+ }
private void makeMemoryAllocationDBRecord(int pid, LeakDataBundle bundleData) {
HashMap<Long, LeakData> leakDataHashMap = bundleData.getLeakDataHashMap();
for (Map.Entry<Long, LeakData> leakEntry : leakDataHashMap.entrySet()) {
List<Object> leakData = new ArrayList<Object>();
-
+
LeakData iLeakData = leakEntry.getValue();
- CommonLeakData commonData = bundleData.getCommonLeakData(leakEntry.getKey().longValue());
-
+ CommonLeakData commonData = bundleData
+ .getCommonLeakData(leakEntry.getKey().longValue());
+
leakData.add(Long.valueOf(iLeakData.getSequenceNumber()));
leakData.add(Integer.valueOf(pid));
leakData.add(Integer.valueOf(commonData.getThreadID()));
leakData.add(Integer.valueOf(commonData.getBinaryID()));
leakData.add(Integer.valueOf(commonData.getFunctionID()));
- leakData.add(Integer.valueOf(commonData.getApiID()));
+ leakData.add(Integer.valueOf(commonData.getMsgID()));
leakData.add(Long.valueOf(iLeakData.getCallerPCAddress()));
leakData.add(leakEntry.getKey());
leakData.add(Long.valueOf(iLeakData.getAllocatedTime()));
- leakData.add(Long.valueOf(-1)); // free time - default value (-1)
+ leakData.add(Long.valueOf(-1)); // free time - default value (-1)
leakData.add(Long.valueOf(iLeakData.getAllocatedMemorySize()));
-
+
memoryDataList.add(leakData);
}
}
-
- public void clear() {
- memoryDataList.clear();
- memoryDBInserter.clear();
- }
- public ResultSet getLeakDataForGroupFromDB() {
- String query = String.format(MemoryAllocationDBTable.OPEN_DATA_SELECT_QUERY);
- return SqlConnectionManager.executeQueryRS(query);
- }
-
- public ResultSet getLeakDataForRange(int pid, long startTime, long endTime) {
- String query = String.format(MemoryAllocationDBTable.RANGE_SELECT_QUERY_WITH_PID, pid,
- Long.valueOf(startTime).toString(), Long.valueOf(endTime).toString(),
- Long.valueOf(endTime).toString());
- return SqlConnectionManager.executeQueryRS(query);
+ private void makeInternalMemoryAllocationDBRecord(int pid, InternalLeakDataBundle bundleData) {
+ Map<Long, InternalLeakData> internalDataHashMap = bundleData.getInternalLeakDataHashMap();
+ for (Map.Entry<Long, InternalLeakData> leakEntry : internalDataHashMap.entrySet()) {
+ List<Object> internalData = new ArrayList<Object>();
+
+ InternalLeakData iInternalData = leakEntry.getValue();
+
+ internalData.add(Long.valueOf(iInternalData.getSequenceNumber()));
+ internalData.add(Integer.valueOf(pid));
+ internalData.add(Integer.valueOf(iInternalData.getThreadID()));
+ internalData.add(Integer.valueOf(iInternalData.getBinaryID()));
+ internalData.add(Integer.valueOf(iInternalData.getFunctionID()));
+ internalData.add(Integer.valueOf(iInternalData.getMsgID()));
+ internalData.add(Long.valueOf(iInternalData.getCallerPCAddress()));
+ internalData.add(leakEntry.getKey());
+ internalData.add(Long.valueOf(iInternalData.getAllocatedTime()));
+ internalData.add(Long.valueOf(-1)); // free time - default value (-1)
+ internalData.add(Long.valueOf(iInternalData.getAllocatedMemorySize()));
+
+ internalMemoryDataList.add(internalData);
+ }
}
}
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
import org.tizen.dynamicanalyzer.common.DALimit;
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
import org.tizen.dynamicanalyzer.ui.toolbar.setting.data.SettingConstants;
import org.tizen.dynamicanalyzer.ui.toolbar.setting.data.SettingDataManager;
import org.tizen.dynamicanalyzer.ui.toolbar.setting.data.TargetData;
+import org.tizen.dynamicanalyzer.util.Logger;
public class LeakDetector {
- HashMap<Integer, LeakDataBundle> leakDataBundleHashMap;
+ Map<Integer, LeakDataBundle> leakDataBundleHashMap;
+ Map<Integer, InternalLeakDataBundle> internalLeakDataBundleHashMap;
public LeakDetector() {
}
- public HashMap<Integer, LeakDataBundle> getLeakDataBundleHashMap() {
+ public Map<Integer, LeakDataBundle> getLeakDataBundleHashMap() {
if (leakDataBundleHashMap == null) {
- leakDataBundleHashMap = new HashMap<Integer, LeakDataBundle>();
+ leakDataBundleHashMap = new ConcurrentHashMap<Integer, LeakDataBundle>();
}
return leakDataBundleHashMap;
}
- public HashMap<Integer, LeakDataBundle> getSelectedLeakDataBundleHashMap(List<Integer> selectedPids) {
- if (selectedPids.size() == 1 && selectedPids.get(0) == 0) // All process
+ public Map<Integer, InternalLeakDataBundle> getInternalLeakDataBundleHashMap() {
+ if (internalLeakDataBundleHashMap == null) {
+ internalLeakDataBundleHashMap = new ConcurrentHashMap<Integer, InternalLeakDataBundle>();
+ }
+ return internalLeakDataBundleHashMap;
+ }
+
+ public Map<Integer, LeakDataBundle> getSelectedLeakDataBundleHashMap(List<Integer> selectedPIDs) {
+ if (selectedPIDs.size() == 1 && selectedPIDs.get(0) == 0) // All process
return getLeakDataBundleHashMap();
- HashMap<Integer, LeakDataBundle> selectedBundle = new HashMap<Integer, LeakDataBundle>();
+ Map<Integer, LeakDataBundle> selectedBundle = new HashMap<Integer, LeakDataBundle>();
+ for (Integer selectedPID : selectedPIDs) {
+ selectedBundle.put(selectedPID, getLeakDataBundleHashMap().get(selectedPID));
+ }
+
+ return selectedBundle;
+ }
+
+ public Map<Integer, InternalLeakDataBundle> getSelectedInternalLeakDataBundleHashMap(
+ List<Integer> selectedPids) {
+ if (selectedPids.size() == 1 && selectedPids.get(0) == 0) // All process
+ return getInternalLeakDataBundleHashMap();
+ Map<Integer, InternalLeakDataBundle> selectedBundle = new HashMap<Integer, InternalLeakDataBundle>();
for (Integer selectedPid : selectedPids) {
- selectedBundle.put(selectedPid, getLeakDataBundleHashMap().get(selectedPid));
+ selectedBundle.put(selectedPid, getInternalLeakDataBundleHashMap().get(selectedPid));
}
return selectedBundle;
return;
if (logData instanceof MemoryData) {
- HashMap<Integer, LeakDataBundle> leaks = getLeakDataBundleHashMap();
MemoryData mlog = (MemoryData) logData;
+ int pid = mlog.getPid();
// filtering for the failed malloc
if (mlog.getReturn().equalsIgnoreCase(String.valueOf("0x0")))
return;
if (!mlog.isInternal()) { // Grouping - user direct allocation
- int pid = mlog.getPid();
+ Map<Integer, LeakDataBundle> leaks = getLeakDataBundleHashMap();
LeakDataBundle bundleData = leaks.get(Integer.valueOf(pid));
if (mlog.getMemoryApiType() == LogCenterConstants.MEMORY_API_ALLOC) {
if (bundleData == null) {
bundleData = new LeakDataBundle(pid);
- leaks.put(Integer.valueOf(pid), bundleData);
}
bundleData.addLeakData(logData);
leaks.put(Integer.valueOf(pid), bundleData);
} else if (mlog.getMemoryApiType() == LogCenterConstants.MEMORY_API_FREE) {
- if (bundleData == null)
+ if (bundleData == null) {
+ // If the running process is analyzing, this case is not error.
+ Logger.debug("There is no LeakDataBundle for this PID : %d", pid);
return;
+ }
long allocatedAddress = mlog.getAddress();
CommonLeakData commonData = bundleData.getCommonLeakData(allocatedAddress);
LeakData leakData = bundleData.getLeakData(allocatedAddress);
+ if (commonData == null || leakData == null) {
+ // If the running process is analyzing, this case is not error.
+ Logger.debug("There is no allocated data for this free data !!");
+ return;
+ }
SummaryDataManager.getInstance().getLeakDataMaker()
.makeData(commonData, leakData, mlog);
bundleData.removeLeakData(allocatedAddress);
}
- } else {
- // TODO : Internal allocation
+ } else { // Internal allocation
+ Map<Integer, InternalLeakDataBundle> internalLeaks = getInternalLeakDataBundleHashMap();
+ InternalLeakDataBundle bundleData = internalLeaks.get(Integer.valueOf(pid));
+ if (mlog.getMemoryApiType() == LogCenterConstants.MEMORY_API_ALLOC) {
+ if (bundleData == null) {
+ bundleData = new InternalLeakDataBundle(pid);
+ }
+
+ bundleData.addInternalLeakData(logData);
+ internalLeaks.put(Integer.valueOf(pid), bundleData);
+ } else if (mlog.getMemoryApiType() == LogCenterConstants.MEMORY_API_FREE) {
+ if (bundleData == null) {
+ // If the running process is analyzing, this case is not error.
+ Logger.debug("There is no InternalLeakDataBundle for this PID : %d", pid);
+ return;
+ }
+ long allocatedAddress = mlog.getAddress();
+ InternalLeakData leakData = bundleData.getInternalLeakData(allocatedAddress);
+ if (leakData == null) {
+ // If the running process is analyzing, this case is not error.
+ Logger.debug("There is no internal allocated data for this free data !!");
+ return;
+ }
+ SummaryDataManager.getInstance().getLeakDataMaker()
+ .makeInternalData(leakData, mlog);
+ bundleData.removeInternalLeakData(allocatedAddress);
+ }
}
}
public int getLeakDataSize() {
int sum = 0;
- for (Map.Entry<Integer, LeakDataBundle> entry : getLeakDataBundleHashMap().entrySet()) {
- LeakDataBundle bundle = entry.getValue();
- sum += bundle.getLeakDataHashMap().size();
+ if (getLeakDataBundleHashMap() != null) {
+ for (Map.Entry<Integer, LeakDataBundle> entry : getLeakDataBundleHashMap().entrySet()) {
+ if (entry.getValue() != null)
+ sum += entry.getValue().getLeakDataHashMap().size();
+ }
+ }
+
+ if (getInternalLeakDataBundleHashMap() != null) {
+ for (Map.Entry<Integer, InternalLeakDataBundle> entry : getInternalLeakDataBundleHashMap()
+ .entrySet()) {
+ if (entry.getValue() != null)
+ sum += entry.getValue().getInternalLeakDataHashMap().size();
+ }
}
return sum;
public void clear() {
getLeakDataBundleHashMap().clear();
+ getInternalLeakDataBundleHashMap().clear();
}
}
import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableDataFormat;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATreeComposite;
+import org.tizen.dynamicanalyzer.util.Logger;
public class LeakTable extends DATreeComposite {
private boolean isRange = false;
+ private long tableDataIndex = 0;
public LeakTable(Composite parent, int compStyle, int tableStyle) {
super(parent, compStyle, tableStyle);
@Override
public List<TreeInput> makeTreeInput() {
+ clearTableDataIndex();
List<TreeInput> output = new ArrayList<TreeInput>();
List<Integer> selectedPids = new ArrayList<Integer>(); // for multiple processes selection
selectedPids.add(Integer.valueOf(ToolbarArea.getInstance().getSelectedPid()));
if (isRange) {
// Grouping - user direct allocation
- HashMap<Integer, List<GroupLeakData>> rangeGroupData = RangeDataManager.getInstance()
+ Map<Integer, List<GroupLeakData>> rangeGroupData = RangeDataManager.getInstance()
.getSelectedRangeGroupDataHashMap(selectedPids);
- if (rangeGroupData == null || rangeGroupData.size() < 1)
- return output;
-
- for (Map.Entry<Integer, List<GroupLeakData>> entry : rangeGroupData.entrySet()) {
- output.addAll(makeTreeInputForRangeGroupData(entry.getKey().intValue(),
- entry.getValue()));
+ if (rangeGroupData != null && rangeGroupData.size() > 0) {
+ for (Map.Entry<Integer, List<GroupLeakData>> entry : rangeGroupData.entrySet()) {
+ output.addAll(makeTreeInputListForRangeGroupData(entry.getKey().intValue(),
+ entry.getValue()));
+ }
}
- // TODO : Internal allocation
+ // Internal allocation
+ Map<Integer, List<InternalLeakData>> rangeInternalData = RangeDataManager.getInstance()
+ .getSelectedRangeInternalDataHashMap(selectedPids);
+ if (rangeInternalData != null && rangeInternalData.size() > 0) {
+ for (Map.Entry<Integer, List<InternalLeakData>> entry : rangeInternalData.entrySet()) {
+ output.addAll(makeTreeInputListForRangeInternalData(entry.getKey().intValue(),
+ entry.getValue()));
+ }
+ }
} else {
// Grouping - user direct allocation
- HashMap<Integer, LeakDataBundle> leaks = AnalyzerManager.getLeakDetector()
+ Map<Integer, LeakDataBundle> leaks = AnalyzerManager.getLeakDetector()
.getSelectedLeakDataBundleHashMap(selectedPids);
- if (leaks == null || leaks.size() < 1)
- return output;
+ if (leaks != null && leaks.size() > 0) {
+ for (Map.Entry<Integer, LeakDataBundle> entry : leaks.entrySet()) {
+ output.addAll(makeTreeInputListForGroupData(entry.getKey().intValue(),
+ entry.getValue()));
+ }
+ }
- for (Map.Entry<Integer, LeakDataBundle> entry : leaks.entrySet()) {
- output.addAll(makeTreeInputForGroupData(entry.getKey().intValue(), entry.getValue()));
+ // Internal allocation
+ Map<Integer, InternalLeakDataBundle> internalLeaks = AnalyzerManager.getLeakDetector()
+ .getSelectedInternalLeakDataBundleHashMap(selectedPids);
+ if (internalLeaks != null && internalLeaks.size() > 0) {
+ for (Map.Entry<Integer, InternalLeakDataBundle> internalEntry : internalLeaks.entrySet()) {
+ output.addAll(makeTreeInputListForInternalLeakData(internalEntry.getKey()
+ .intValue(), internalEntry.getValue()));
+ }
}
-
- // TODO : Internal allocation
}
return output;
}
- private List<TreeInput> makeTreeInputForGroupData(int pid, LeakDataBundle leakDataBundle) {
- int index = 0;
+ private List<TreeInput> makeTreeInputListForGroupData(int pid, LeakDataBundle leakDataBundle) {
List<TreeInput> output = new ArrayList<TreeInput>();
- HashMap<Integer, GroupLeakData> groupDataHashMap = leakDataBundle.getGroupLeakDataHashMap();
+ Map<Integer, GroupLeakData> groupDataHashMap = leakDataBundle.getGroupLeakDataHashMap();
for (Map.Entry<Integer, GroupLeakData> entry : groupDataHashMap.entrySet()) {
GroupLeakData iGroupData = entry.getValue();
if (iGroupData == null) continue;
CommonLeakData commonLeakData = leakDataBundle.getCommonLeakDataList().get(
iGroupData.getCommonLeakDataIndex());
- TreeInput groupInput = makeTreeInputData(commonLeakData, iGroupData,
- pid, index);
+ TreeInput groupInput = makeTreeInputData(commonLeakData, iGroupData, pid);
if (groupInput != null) {
output.add(groupInput);
- index++;
+ increaseTableDataIndex();
+ }
+ }
+
+ return output;
+ }
+
+ private List<TreeInput> makeTreeInputListForInternalLeakData(int pid,
+ InternalLeakDataBundle internalLeakDatabundle) {
+ List<TreeInput> output = new ArrayList<TreeInput>();
+ Map<Long, InternalLeakData> internalLeakDataHashMap = internalLeakDatabundle
+ .getInternalLeakDataHashMap();
+
+ for (Map.Entry<Long, InternalLeakData> entry : internalLeakDataHashMap.entrySet()) {
+ InternalLeakData iInternalData = entry.getValue();
+ if (iInternalData == null) continue;
+ TreeInput internalInput = makeTreeInputData(iInternalData, pid);
+ if (internalInput != null) {
+ output.add(internalInput);
+ increaseTableDataIndex();
}
}
return output;
}
- private List<TreeInput> makeTreeInputForRangeGroupData(int pid, List<GroupLeakData> groupDataList) {
- int index = 0;
+ private List<TreeInput> makeTreeInputListForRangeGroupData(int pid,
+ List<GroupLeakData> groupDataList) {
List<TreeInput> output = new ArrayList<TreeInput>();
ArrayList<CommonLeakData> commonLeakDataList = AnalyzerManager.getLeakDetector()
continue;
CommonLeakData commonLeakData = commonLeakDataList.get(iGroupData
.getCommonLeakDataIndex());
- TreeInput groupInput = makeTreeInputData(commonLeakData, iGroupData, pid, index);
+ TreeInput groupInput = makeTreeInputData(commonLeakData, iGroupData, pid);
if (groupInput != null) {
output.add(groupInput);
- index++;
+ increaseTableDataIndex();
}
}
return output;
}
+ private List<TreeInput> makeTreeInputListForRangeInternalData(int pid,
+ List<InternalLeakData> internalDataList) {
+ List<TreeInput> output = new ArrayList<TreeInput>();
+
+ for (InternalLeakData iInternalData : internalDataList) {
+ if (iInternalData == null)
+ continue;
+ TreeInput internalInput = makeTreeInputData(iInternalData, pid);
+ if (internalInput != null) {
+ output.add(internalInput);
+ increaseTableDataIndex();
+ }
+ }
+
+ return output;
+ }
+
private TreeInput makeTreeInputData(CommonLeakData commonData, GroupLeakData groupData,
- int pid, int index) {
- DATableDataFormat tableData = new DATableDataFormat(index);
+ int pid) {
+ DATableDataFormat tableData = new DATableDataFormat(getTableDataIndex());
List<String> text = new ArrayList<String>();
List<Object> data = new ArrayList<Object>();
}
text.add(libName);
data.add(libName);
- // TODO - for ToolTip Listener (need to check it out)
-// // 6 : caller pc address
-// long callerPCAddress = groupData.getCallerPCAddress();
-// data.add(Long.valueOf(callerPCAddress));
-// // 7 : allocated time
-// long allocatedTime = groupData.getFirstAllocatedTime();
-// text.add(Long.toString(allocatedTime));
-// data.add(Long.valueOf(allocatedTime));
-
- tableData.getData().addAll(data);
- tableData.setType(AnalyzerConstants.TYPE_TABLE_LEAK);
- ProbeCommonData probeData = new ProbeCommonData();
- probeData.setSeq(sequenceNumber);
- probeData.setApiName(apiName);
- probeData.setId(commonData.getApiID());
- probeData.setPid(pid);
- probeData.setTime(groupData.getFirstAllocatedTime());
+ ProbeCommonData probeData = new ProbeCommonData(sequenceNumber,
+ groupData.getFirstAllocatedTime(), commonData.getFunctionID(), pid,
+ commonData.getThreadID(), null, null, 0);
+ probeData.setId(commonData.getMsgID());
probeData.setCallerAddress(groupData.getCallerPCAddress());
probeData.setLibName(libName);
- tableData.setLogData(probeData);
+ tableData.getData().addAll(data);
+ tableData.setType(AnalyzerConstants.TYPE_TABLE_LEAK);
+ tableData.setLogData(probeData);
+
output = new TreeInput();
output.setText(text);
output.setData(tableData);
return output;
}
+
+ private TreeInput makeTreeInputData(InternalLeakData internalData, int pid) {
+ DATableDataFormat tableData = new DATableDataFormat(getTableDataIndex());
+
+ List<String> text = new ArrayList<String>();
+ List<Object> data = new ArrayList<Object>();
+ TreeInput output = null;
+
+ // 0 : Sequence Number - hidden column for sorting
+ long sequenceNumber = internalData.getSequenceNumber();
+ text.add(Long.toString(sequenceNumber));
+ data.add(Long.valueOf(sequenceNumber));
+ // 1 : API name
+ String apiName = Global.getFunctionName(internalData.getFunctionID());
+ text.add(apiName);
+ data.add(apiName);
+ // 2 : PID
+ text.add(Integer.toString(pid));
+ data.add(Integer.valueOf(pid));
+ // 3 : call count
+ int callCount = 1;
+ text.add(Integer.toString(callCount));
+ data.add(Integer.valueOf(callCount));
+ // 4 : leak size
+ long leakSize = internalData.getAllocatedMemorySize();
+ text.add(Long.toString(leakSize));
+ data.add(Long.valueOf(leakSize));
+ // 5 : library name
+ String libName = Global.getProject().getDeviceStatusInfo()
+ .getBinaryInfo(internalData.getBinaryID()).getTargetBinaryPath();
+ if (libName == null || libName.isEmpty()) {
+ libName = "unknown";
+ }
+ text.add(libName);
+ data.add(libName);
+
+ ProbeCommonData probeData = new ProbeCommonData(sequenceNumber,
+ internalData.getAllocatedTime(), internalData.getFunctionID(), pid,
+ internalData.getThreadID(), null, null, 0);
+ probeData.setId(internalData.getMsgID()); // set message ID
+ probeData.setCallerAddress(internalData.getCallerPCAddress());
+ probeData.setLibName(libName);
+
+ tableData.getData().addAll(data);
+ tableData.setType(AnalyzerConstants.TYPE_TABLE_LEAK);
+ tableData.setLogData(probeData);
+
+ output = new TreeInput();
+ output.setText(text);
+ output.setData(tableData);
+
+ if (RangeDataManager.getInstance().isBeingAnalyzed()) {
+ long allocatedTime = internalData.getAllocatedTime();
+ long startTime = RangeDataManager.getInstance().getAnalysisStartTime();
+ long endTime = RangeDataManager.getInstance().getAnalysisEndTime();
+ if (allocatedTime >= startTime && allocatedTime <= endTime) {
+ output.setInRange(true);
+ }
+ }
+
+ return output;
+ }
+
+ private long getTableDataIndex() {
+ return tableDataIndex;
+ }
+
+ private void increaseTableDataIndex() {
+ tableDataIndex++;
+ }
+
+ private void clearTableDataIndex() {
+ tableDataIndex = 0;
+ }
}
COLUMN.THREAD_ID.name + CommonConstants.COMMA +
COLUMN.BINARY_ID.name + CommonConstants.COMMA +
COLUMN.FUNCTION_ID.name + CommonConstants.COMMA +
- COLUMN.API_ID.name + CommonConstants.COMMA +
+ COLUMN.MESSAGE_ID.name + CommonConstants.COMMA +
COLUMN.CALLER_PC_ADDRESS.name + CommonConstants.COMMA +
COLUMN.ALLOCATED_ADDRESS.name + CommonConstants.COMMA +
COLUMN.ALLOCATED_TIME.name + CommonConstants.COMMA +
THREAD_ID(2, DBConstants.DBCOLUMN_THREAD_ID),
BINARY_ID(3, "BINARY_ID"),
FUNCTION_ID(4, DBConstants.DBCOLUMN_FUNCTION_ID),
- API_ID(5, "API_ID"),
+ MESSAGE_ID(5, "MESSAGE_ID"),
CALLER_PC_ADDRESS(6, DBConstants.DBCOLUMN_CALLER_PC_ADDRESS),
ALLOCATED_ADDRESS(7, "ALLOCATED_ADDRESS"),
ALLOCATED_TIME(8, "ALLOCATED_TIME"),
addColumn(new DBColumn(COLUMN.BINARY_ID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
addColumn(new DBColumn(COLUMN.FUNCTION_ID.name, DBConstants.NOT_NULL,
DBConstants.DBTYPE_INT4));
- addColumn(new DBColumn(COLUMN.API_ID.name, DBConstants.NOT_NULL,
+ addColumn(new DBColumn(COLUMN.MESSAGE_ID.name, DBConstants.NOT_NULL,
DBConstants.DBTYPE_INT4));
addColumn(new DBColumn(COLUMN.CALLER_PC_ADDRESS.name, DBConstants.EMPTY,
DBConstants.DBTYPE_LONG));
(Integer) (rowData.get(COLUMN.BINARY_ID.index)));
prep.setInt(COLUMN.FUNCTION_ID.index + 1,
(Integer) (rowData.get(COLUMN.FUNCTION_ID.index)));
- prep.setInt(COLUMN.API_ID.index + 1,
- (Integer) (rowData.get(COLUMN.API_ID.index)));
+ prep.setInt(COLUMN.MESSAGE_ID.index + 1,
+ (Integer) (rowData.get(COLUMN.MESSAGE_ID.index)));
prep.setLong(COLUMN.CALLER_PC_ADDRESS.index + 1,
(Long) (rowData.get(COLUMN.CALLER_PC_ADDRESS.index)));
prep.setLong(COLUMN.ALLOCATED_ADDRESS.index + 1,
row.add(Integer.valueOf(rs.getInt(COLUMN.THREAD_ID.index + 1)));
row.add(Integer.valueOf(rs.getInt(COLUMN.BINARY_ID.index + 1)));
row.add(Integer.valueOf(rs.getInt(COLUMN.FUNCTION_ID.index + 1)));
- row.add(Integer.valueOf(rs.getInt(COLUMN.API_ID.index + 1)));
+ row.add(Integer.valueOf(rs.getInt(COLUMN.MESSAGE_ID.index + 1)));
row.add(Long.valueOf(rs.getLong(COLUMN.CALLER_PC_ADDRESS.index + 1)));
row.add(Long.valueOf(rs.getLong(COLUMN.ALLOCATED_ADDRESS.index + 1)));
row.add(Long.valueOf(rs.getLong(COLUMN.ALLOCATED_TIME.index + 1)));
String message = WarningCase.getShortWarningMessage(warningCase);
text.add(message);
data.add(message);
- // create images
// create DATableDataFormat
long seq = (Long)idata.get(WarningDataDBTable.COLUMN_INDEX_SEQUENCE_NUMBER);
DATableDataFormat tableData = new DATableDataFormat(seq);
- ProbeCommonData probeData = new ProbeCommonData();
- probeData.setSeq(seq);
+ ProbeCommonData probeData = new ProbeCommonData(seq,
+ (Long) idata.get(WarningDataDBTable.COLUMN_INDEX_START_TIME), 0, pid,
+ (Integer) idata.get(WarningDataDBTable.COLUMN_INDEX_THREAD_ID), null, null, 0);
probeData.setId(msgID);
- probeData.setPid(pid);
- probeData.setTid((Integer)idata.get(WarningDataDBTable.COLUMN_INDEX_THREAD_ID));
- probeData.setTime((Long)idata.get(WarningDataDBTable.COLUMN_INDEX_START_TIME));
- probeData.setReserved1(warningCase); // warningCase
- probeData.setCallerAddress((Long)idata.get(WarningDataDBTable.COLUMN_INDEX_CALLER_PC_ADDRESS));
- probeData.setLibName((String)idata.get(WarningDataDBTable.COLUMN_INDEX_CALLER_LIBRARY_NAME));
+ probeData.setReserved1(warningCase); // warningCase
+ probeData.setCallerAddress((Long) idata
+ .get(WarningDataDBTable.COLUMN_INDEX_CALLER_PC_ADDRESS));
+ probeData.setLibName((String) idata
+ .get(WarningDataDBTable.COLUMN_INDEX_CALLER_LIBRARY_NAME));
+
tableData.getData().addAll(text);
tableData.setLogData(probeData);
tableData.setType(AnalyzerConstants.TYPE_TABLE_WARNING);
+
TableInput tableInput = new TableInput();
tableInput.setText(text);
tableInput.setData(tableData);
int tid = rs.getInt(API.TID.index);
String args = rs.getString(API.ARGUMENT.index);
String returnValue = rs.getString(API.RETURN.index);
- int errorno = rs.getInt(API.ERRORNO.index);
+ long errorno = rs.getLong(API.ERRORNO.index);
pData = new ProbeCommonData(seq, time, apiID, pid, tid, args, returnValue, errorno);
} catch (SQLException e) {
projects / sdk / tools / dynamic-analyzer.git / commitdiff