import java.util.HashMap;
import java.util.List;
+import org.tizen.dynamicanalyzer.communicator.DACommunicator;
import org.tizen.dynamicanalyzer.handlers.ClearHandler;
import org.tizen.dynamicanalyzer.handlers.StartHandler;
import org.tizen.dynamicanalyzer.model.BaseLogCenter;
import org.tizen.dynamicanalyzer.project.Project;
import org.tizen.dynamicanalyzer.resources.ColorResources;
import org.tizen.dynamicanalyzer.services.RecordStateSourceProvider;
-import org.tizen.dynamicanalyzer.swap.model.data.ApiNameManager;
+import org.tizen.dynamicanalyzer.swap.callstack.BaseCallstackManager;
+import org.tizen.dynamicanalyzer.swap.callstack.SWAPCallStackManager;
import org.tizen.dynamicanalyzer.theme.DATheme;
import org.tizen.dynamicanalyzer.theme.DAThemeWhite;
import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackManager;
private static FailedChecker calledChecker = new FailedChecker();
private static WarningChecker warningChecker = new WarningChecker();
private static CallStackManager callstackManager = new CallStackManager();
+ private static SWAPCallStackManager swapCallstackManager = new SWAPCallStackManager();
private static boolean appInfoArrived = false;
private static boolean isHaveSampleThread = false;
warningChecker.clear();
calledChecker.clear();
callstackManager.clear();
+ swapCallstackManager.clear();
isHaveSampleThread = false;
StopProcessManager.clear();
UserFunctionManager.getInstance().clear();
return warningChecker;
}
- public static CallStackManager getCallstackManager() {
- return callstackManager;
+ public static BaseCallstackManager getCallstackManager() {
+ if (DACommunicator.isSWAPVersion()) {
+ return swapCallstackManager;
+ } else {
+ return callstackManager;
+ }
}
public static FailedChecker getCalledFunctionChecker() {
}
}
- // public static List<LogCenter> getLogCenters() {
- // if (null != project) {
- // return project.getLogCenters();
- // }
- // return getInnerLogCenters();
- // }
-
- // public void initLogCenters() {
- // if (null != logCenters) {
- // logCenters.clear();
- // } else {
- // logCenters = new ArrayList<LogCenter>();
- // }
- //
- // logCenters.addAll(AnalyzerManager.getLogCenters());
- // }
-
- // public static LogCenter getLogCenterById(int id) {
- // List<LogCenter> logcs = getLogCenters();
- // if (null != logcs) {
- // int size = logcs.size();
- // for (int i = 0; i < size; i++) {
- // if (id == logcs.get(i).getId()) {
- // return logcs.get(i);
- // }
- // }
- // }
- // return null;
- // }
-
public static LeakCheckList getLeakCheckList() {
String path = AnalyzerPaths.DYNAMIC_ANALYZER_INSTALL_PATH
+ File.separator + AnalyzerConstants.XML_FOLDER_NAME;
public static final String CMD_IS_ARM_ARCH = "uname -m"; //$NON-NLS-1$
public static final String CMD_CAT_PORT_FILE = "cat /tmp/port.da"; //$NON-NLS-1$
+
+ public static final String CMD_MD_5_SUM = "/usr/bin/md5sum "; //$NON-NLS-1$
}
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * YeongTaik Byeon <yeongtaik.byeon@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.common;
+
+import java.io.IOException;
+import java.util.HashMap;
+
+import org.eclipse.cdt.utils.elf.Elf;
+import org.eclipse.cdt.utils.elf.Elf.Symbol;
+
+public class ElfSymbolExtractManager {
+ private String libPath = null;
+ private HashMap<Long, String> symbolMap = null;
+ private static ElfSymbolExtractManager instance = null;
+
+ private ElfSymbolExtractManager(){
+ }
+
+ public static ElfSymbolExtractManager getInstance(){
+ if(null == instance){
+ instance = new ElfSymbolExtractManager();
+ }
+ return instance;
+ }
+
+ public boolean makeSymbol(String libPath){
+ this.libPath = libPath;
+ if(null != symbolMap){
+ symbolMap.clear();
+ }
+ else{
+ symbolMap = new HashMap<Long, String>();
+ }
+ Elf elf;
+ try {
+ elf = new Elf(libPath);
+ elf.loadSymbols();
+ } catch (IOException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ return false;
+ }
+ Symbol[] symbols = elf.getSymtabSymbols();
+ for(Symbol symbol : symbols){
+ if(symbol.st_type() != Elf.Symbol.STT_FUNC || symbol.st_shndx == Elf.Symbol.SHN_UNDEF){
+ continue;
+ }
+ symbolMap.put(symbol.st_value.getValue().longValue(), symbol.toString());
+ }
+ return true;
+ }
+
+ public Long[] getSymbolAddress(){
+ if(null == symbolMap || 0 == symbolMap.size()){
+ return null;
+ }
+
+ Long[] ret = new Long[symbolMap.size()];
+ ret = (Long[])(symbolMap.keySet().toArray(ret));
+
+ return ret;
+ }
+
+ public HashMap<Long, String> symbolMap(){
+ return symbolMap;
+ }
+
+ public void setLibPath(String libPath){
+ this.libPath = libPath;
+ }
+
+ public String getLibPath(){
+ return libPath;
+ }
+
+ public void clear(){
+ libPath = null;
+ if(null != symbolMap){
+ symbolMap.clear();
+ symbolMap = null;
+ }
+ }
+}
ERR_TARGET_INFO_GET_FAIL(-505, "target info get fail..."),
ERR_KEEP_ALIVE(-506, "keep alive message ack fail..."),
+
+ ERR_BIN_INFO_GET_FAIL(-507, "binary info get fail..."),
ERR_DA_IS_EXIT(-901, "Dynamic Analyzer is closing"),
import java.util.List;
import org.tizen.dynamicanalyzer.common.CommonConstants;
+import org.tizen.dynamicanalyzer.swap.model.control.BinaryInfo;
public class AppInfo {
public static final String FLAG_ZERO = "0";//$NON-NLS-1$
public static final String FLAG_ONE = "1";//$NON-NLS-1$
+ private BinaryInfo binInfo = null;
+
private String installTime = null;
+
public String getInstallTime() {
return installTime;
}
public String getInfo(int index) {
return appInfo.get(index);
}
+
+ public BinaryInfo getBinInfo() {
+ return binInfo;
+ }
+
+ public void setBinInfo(BinaryInfo binInfo) {
+ this.binInfo = binInfo;
+ }
}
return processInfo.getLowestAddress();
}
+ public long getHighestAddress() {
+ return processInfo.getHighestAddress();
+ }
+
public int getApplicationType() {
return processInfo.getAppType();
}
--- /dev/null
+package org.tizen.dynamicanalyzer.swap.callstack;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
+import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.communicator.DACommunicator;
+import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
+import org.tizen.dynamicanalyzer.project.AppInfo;
+import org.tizen.dynamicanalyzer.swap.model.probe2.LogData;
+import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackData;
+import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackUnit;
+import org.tizen.dynamicanalyzer.ui.summary.profiling.ProfileDataMaker;
+
+public abstract class BaseCallstackManager {
+ protected class DuplicateUserCall {
+ private CallStackUnit dupCallstackUnit = null;
+ private int dupCallcount = 0;
+
+ public DuplicateUserCall(CallStackUnit callStackUnit) {
+ dupCallstackUnit = callStackUnit;
+ dupCallcount = 1;
+ }
+
+ public CallStackUnit getDupCallstackUnit() {
+ return dupCallstackUnit;
+ }
+
+ public int getDupCallCount() {
+ return dupCallcount;
+ }
+
+ public void increaseDupCallCount() {
+ dupCallcount++;
+ }
+
+ public void decreaseDupCallCount() {
+ dupCallcount--;
+ }
+ }
+
+ protected HashMap<Long, CallStackUnit> callstackApiByAddrMap = new HashMap<Long, CallStackUnit>();
+ protected HashMap<Integer, CallStackData> callstackDataBySeqMap = new HashMap<Integer, CallStackData>();
+ protected String userFunctionBin = null;
+ protected HashMap<Integer, List<CallStackUnit>> userCallstackByTidMap = new HashMap<Integer, List<CallStackUnit>>();
+ protected HashMap<Integer, DuplicateUserCall> dupUserCallByTidMap = new HashMap<Integer, DuplicateUserCall>();
+
+ abstract public void makeUserCallstack(LogData log,
+ ProfileDataMaker profiler);
+
+ abstract public void makeCallstackWithoutBacktrace(LogData inputData);
+
+ abstract public boolean isIrregularUserCall(LogData input);
+
+ public HashMap<Long, CallStackUnit> getCallStackApiByAddrMap() {
+ if (null == callstackApiByAddrMap) {
+ callstackApiByAddrMap = new HashMap<Long, CallStackUnit>();
+ }
+ return callstackApiByAddrMap;
+ }
+
+ public HashMap<Integer, CallStackData> getCallStackDataBySeqMap() {
+ if (null == callstackDataBySeqMap) {
+ callstackDataBySeqMap = new HashMap<Integer, CallStackData>();
+ }
+ return callstackDataBySeqMap;
+ }
+
+ public HashMap<Integer, DuplicateUserCall> getDupUserCallByTidMap() {
+ if (null == dupUserCallByTidMap) {
+ dupUserCallByTidMap = new HashMap<Integer, DuplicateUserCall>();
+ }
+ return dupUserCallByTidMap;
+ }
+
+ public String getUserFunctionPosition() {
+ if (userFunctionBin == null || userFunctionBin.isEmpty()) {
+ if (AnalyzerManager.isOsp()) {
+ userFunctionBin = new String(DACommunicator.getSelectedApp()
+ .getInfo(AppInfo.EXEC_INDEX) + ".exe"); //$NON-NLS-1$
+ } else {
+ userFunctionBin = new String(DACommunicator.getSelectedApp()
+ .getInfo(AppInfo.EXEC_INDEX));
+ }
+ }
+ return userFunctionBin;
+ }
+
+ public List<CallStackUnit> getUserCallstack(int tid) {
+ if (null == userCallstackByTidMap) {
+ userCallstackByTidMap = new HashMap<Integer, List<CallStackUnit>>();
+ }
+ List<CallStackUnit> userCallstack = userCallstackByTidMap.get(tid);
+ if (null == userCallstack) {
+ userCallstack = new ArrayList<CallStackUnit>();
+ userCallstackByTidMap.put(tid, userCallstack);
+ }
+ return userCallstack;
+ }
+
+ public CallStackData getCallStack(String seqNum) {
+ int seq = Integer.parseInt(seqNum);
+ return getCallStackDataBySeqMap().get(seq);
+ }
+
+ public boolean checkUserCall(String input) {
+ if (input.contains(AnalyzerConstants.USER_BIN_POS)) {
+ return true;
+ }
+ return false;
+ }
+
+ public boolean isUserCall(String input) {
+ if (!input.contains(LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC)) {
+ return true;
+ }
+ return false;
+ }
+
+ public long getPCAddrBySeq(int seq) {
+ HashMap<Integer, CallStackData> cdMap = getCallStackDataBySeqMap();
+ if (null == cdMap) {
+ return -1;
+ }
+ CallStackData csd = cdMap.get(seq);
+ if (null == csd) {
+ return -1;
+ }
+ List<Long> addrs = csd.getAddrs();
+ if (null == addrs || addrs.isEmpty()) {
+ return -1;
+ }
+ return addrs.get(0);
+ }
+
+ abstract public void clear();
+}
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * 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.swap.callstack;
+
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_FUNCTION_ENTRY;
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_FUNCTION_EXIT;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
+import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.SymbolManager;
+import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
+import org.tizen.dynamicanalyzer.logparser.LogParser;
+import org.tizen.dynamicanalyzer.swap.model.probe2.LogData;
+import org.tizen.dynamicanalyzer.swap.model.probe2.ProbeCommonData;
+import org.tizen.dynamicanalyzer.swap.model.probe2.ProfileData;
+import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackData;
+import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackUnit;
+import org.tizen.dynamicanalyzer.ui.summary.profiling.ProfileDataMaker;
+
+public class SWAPCallStackManager extends BaseCallstackManager {
+
+ public void makeUserCallstack(LogData input, ProfileDataMaker profiler) {
+ ProfileData log = (ProfileData) input;
+ HashMap<Long, CallStackUnit> addrMap = getCallStackApiByAddrMap();
+ boolean isPieBuild = AnalyzerManager.getProject().isPieBuild();
+ String baseAddr = Long.toString(AnalyzerManager.getProject()
+ .getBaseAddress());
+ String binPath = AnalyzerManager.getProject().getBinaryPath();
+ if (null == binPath || binPath.isEmpty()) {
+ return;
+ }
+ String strSelfAddr = Long.toString(log.getPcAddr());
+ String strCallerAddr = Long.toString(log.getCallerPcAddr());
+
+ int seq = log.getSeq();
+ int tid = log.getTid();
+
+ long selfAddr = log.getPcAddr();
+ long callerAddr = log.getCallerPcAddr();
+
+ CallStackData callstackData = new CallStackData(seq);
+ CallStackUnit selfCallstackUnit = addrMap.get(selfAddr);
+
+ if (null == selfCallstackUnit) {
+ String strSelfFuncName = SymbolManager.addr2func(binPath,
+ strSelfAddr, isPieBuild, baseAddr);
+ String strSelfSymbol = getUserFunctionPosition()
+ + AnalyzerConstants.CALLSTACK_API_TOKEN_STRING
+ + strSelfFuncName;
+ selfCallstackUnit = new CallStackUnit(selfAddr, strSelfSymbol);
+ addrMap.put(selfAddr, selfCallstackUnit);
+ }
+
+ // insert call count
+ profiler.makeFupDataForCallTrace(selfCallstackUnit, log);
+
+ List<CallStackUnit> userCallstack = getUserCallstack(tid);
+ int size = userCallstack.size();
+
+ CallStackUnit callerCallstackUnit = addrMap.get(callerAddr);
+ if (null == callerCallstackUnit) {
+ String strCallerFuncName = SymbolManager.addr2func(binPath,
+ strCallerAddr, isPieBuild, baseAddr);
+ String strCallerSymbol = getUserFunctionPosition()
+ + AnalyzerConstants.CALLSTACK_API_TOKEN_STRING
+ + strCallerFuncName;
+ callerCallstackUnit = new CallStackUnit(callerAddr, strCallerSymbol);
+ addrMap.put(callerAddr, callerCallstackUnit);
+ }
+
+ int eventType = log.getId();
+ if (eventType == MSG_FUNCTION_ENTRY) {
+ if (size == 0) {
+ userCallstack.add(selfCallstackUnit);
+ } else {
+ if (!AnalyzerManager.isInBinaryRange(callerAddr)) {
+ CallStackUnit callbackApi = new CallStackUnit(
+ LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_ADDR,
+ LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_SYMBOL);
+ userCallstack.add(callbackApi);
+ if (addrMap
+ .get(LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_ADDR) == null) {
+ CallStackUnit defaultCallstackUnit = new CallStackUnit(
+ LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_ADDR,
+ LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_SYMBOL);
+ addrMap.put(
+ LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_ADDR,
+ defaultCallstackUnit);
+ }
+ } else if (callerCallstackUnit.getFunctionName().contains(
+ AnalyzerConstants.VIRTUAL_THUNK)) {
+ CallStackUnit callbackApi = new CallStackUnit(
+ LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_ADDR,
+ LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_SYMBOL);
+ userCallstack.add(callbackApi);
+ if (addrMap
+ .get(LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_ADDR) == null) {
+ CallStackUnit defaultCallstackUnit = new CallStackUnit(
+ LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_ADDR,
+ LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_SYMBOL);
+ addrMap.put(
+ LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_ADDR,
+ defaultCallstackUnit);
+ }
+ userCallstack.add(callerCallstackUnit);
+ } else {
+ CallStackUnit callerCsa = addrMap.get(callerAddr);
+ if (null == callerCsa) {
+ callerCsa = userCallstack.get(size - 1);
+ callerCsa.setFunctionStartAddr(callerCsa.getAddr());
+ callerCsa.setAddr(callerAddr);
+ } else {
+ callerCsa.setFunctionStartAddr(userCallstack.get(
+ size - 1).getAddr());
+ userCallstack.set(size - 1, callerCsa);
+ }
+ }
+ userCallstack.add(selfCallstackUnit);
+ }
+ size = userCallstack.size();
+ for (int i = size - 1; i >= 0; i--) {
+ callstackData.getAddrs().add(userCallstack.get(i).getAddr());
+ }
+ getCallStackDataBySeqMap().put(seq, callstackData);
+ } else if (eventType == MSG_FUNCTION_EXIT) {
+ if (size == 0) {
+ // this case only range profiling, other time is bug
+ return;
+ }
+ CallStackUnit removeCallStackUnit = userCallstack.get(size - 1);
+ if (selfCallstackUnit.getFunctionName().equals(
+ removeCallStackUnit.getFunctionName())) {
+ userCallstack.remove(size - 1);
+ if (size - 2 > 0) {
+ if (callerCallstackUnit.getFunctionName().contains(
+ AnalyzerConstants.VIRTUAL_THUNK)) {
+ if (callerCallstackUnit.getFunctionName().equals(
+ userCallstack.get(size - 2).getFunctionName())) {
+ userCallstack.remove(size - 2);
+ } else {
+ System.out
+ .println("makeUserCallstack : [virtual thunk] EXIT caller is not the same"
+ + "as top of user callstack after remove EXIT self");
+ }
+ }
+ }
+ size = userCallstack.size();
+ if (size - 1 > 0) {
+ CallStackUnit checkCallStackUnit = userCallstack
+ .get(size - 1);
+ if (checkCallStackUnit.getFunctionName().equals(
+ LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC)) {
+ userCallstack.remove(size - 1);
+ }
+ }
+ size = userCallstack.size();
+ if (size > 0) {
+ CallStackUnit prevCallstackUnit = userCallstack
+ .get(size - 1);
+ long prevSelfAddr = prevCallstackUnit
+ .getFunctionStartAddr();
+ CallStackUnit callerCsa = addrMap.get(prevSelfAddr);
+ if (null == callerCsa) {
+ prevCallstackUnit.setAddr(prevSelfAddr);
+ } else {
+ userCallstack.set(size - 1, callerCsa);
+ }
+ }
+ } else {
+ System.out
+ .println("makeUserCallstack : EXIT self is not the same as top of user callstack");
+ }
+ if (AnalyzerManager.isOsp()) {
+ // String apiName = input[LogCenterConstants.APINAME_INDEX];
+ String apiName = log.getApiName();
+ if (apiName.equals("OspMain")) { //$NON-NLS-1$
+ LogParser.setDropCallTraceLog(true);
+ }
+ }
+ }
+ }
+
+ public void makeCallstackWithoutBacktrace(LogData inputData) {
+ HashMap<Long, CallStackUnit> addrMap = getCallStackApiByAddrMap();
+ boolean isPieBuild = AnalyzerManager.getProject().isPieBuild();
+ String baseAddr = Long.toString(AnalyzerManager.getProject()
+ .getBaseAddress());
+ String binPath = AnalyzerManager.getProject().getBinaryPath();
+ if (null == binPath || binPath.isEmpty()) {
+ return;
+ }
+
+ ProbeCommonData log = (ProbeCommonData) inputData;
+ // String strSeq = input[LogCenterConstants.SEQUENCE_NUMBER_INDEX];
+ // String strTid = input[LogCenterConstants.THREAD_ID_INDEX];
+ // String strCallerAddr = input[LogCenterConstants.CALLER_PCADDR_INDEX];
+
+ // int seq = Integer.parseInt(strSeq);
+ // int tid = Integer.parseInt(strTid);
+ int seq = log.getSeq();
+ int tid = log.getTid();
+ // long callerAddr = 0;
+ long callerAddr = log.getCallerPcAddr();
+ // if (!strCallerAddr.isEmpty()) {
+ // callerAddr = Long.parseLong(strCallerAddr);
+ // } else {
+ // CallStackData callstackData = new CallStackData(seq);
+ // getCallStackDataBySeqMap().put(seq, callstackData);
+ // return;
+ // }
+ if (callerAddr < 0) {
+ CallStackData callstackData = new CallStackData(seq);
+ getCallStackDataBySeqMap().put(seq, callstackData);
+ return;
+ }
+ String strCallerAddr = Long.toString(callerAddr);
+
+ List<CallStackUnit> probeCallstack = new ArrayList<CallStackUnit>(
+ getUserCallstack(tid));
+ int size = probeCallstack.size();
+
+ CallStackData callstackData = new CallStackData(seq);
+
+ if ((size == 0) || (!AnalyzerManager.isInBinaryRange(callerAddr))) {
+ CallStackUnit callbackApi = new CallStackUnit(
+ LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_ADDR,
+ LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_SYMBOL);
+ probeCallstack.add(callbackApi);
+ if (addrMap
+ .get(LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_ADDR) == null) {
+ CallStackUnit defaultCallstackUnit = new CallStackUnit(
+ LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_ADDR,
+ LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_SYMBOL);
+ addrMap.put(
+ LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_ADDR,
+ defaultCallstackUnit);
+ }
+ } else {
+ CallStackUnit callerCallstackUnit = addrMap.get(callerAddr);
+ if (null == callerCallstackUnit) {
+ String strCallerFuncName = SymbolManager.addr2func(binPath,
+ strCallerAddr, isPieBuild, baseAddr);
+ String strCallerSymbol = getUserFunctionPosition()
+ + AnalyzerConstants.CALLSTACK_API_TOKEN_STRING
+ + strCallerFuncName;
+ callerCallstackUnit = new CallStackUnit(callerAddr,
+ strCallerSymbol);
+ addrMap.put(callerAddr, callerCallstackUnit);
+ }
+
+ CallStackUnit topUserCallstack = probeCallstack.get(size - 1);
+ if (callerCallstackUnit.getFunctionName().equals(
+ topUserCallstack.getFunctionName())) {
+ probeCallstack.set(size - 1, callerCallstackUnit);
+ } else {
+ System.out
+ .println("bug : probe caller is not the same as top of user callstack"); //$NON-NLS-1$
+ }
+ }
+
+ size = probeCallstack.size();
+ for (int i = size - 1; i >= 0; i--) {
+ callstackData.getAddrs().add(probeCallstack.get(i).getAddr());
+ }
+ getCallStackDataBySeqMap().put(seq, callstackData);
+
+ }
+
+ // check irregular enter/exit log (multiple logs from 1 function call)
+ public boolean isIrregularUserCall(LogData log) {
+ ProfileData input = (ProfileData) log;
+ HashMap<Long, CallStackUnit> addrMap = getCallStackApiByAddrMap();
+ HashMap<Integer, DuplicateUserCall> dupUserCallMap = getDupUserCallByTidMap();
+
+ boolean isPieBuild = AnalyzerManager.getProject().isPieBuild();
+ String baseAddr = Long.toString(AnalyzerManager.getProject()
+ .getBaseAddress());
+ String binPath = AnalyzerManager.getProject().getBinaryPath();
+ if (null == binPath || binPath.isEmpty()) {
+ return false;
+ }
+
+ String strSelfAddr = Long.toString(input.getPcAddr());
+
+ int tid = input.getTid();
+ long selfAddr = input.getPcAddr();
+
+ CallStackUnit selfCallstackUnit = addrMap.get(selfAddr);
+
+ if (null == selfCallstackUnit) {
+ String strSelfFuncName = SymbolManager.addr2func(binPath,
+ strSelfAddr, isPieBuild, baseAddr);
+ String strSelfSymbol = getUserFunctionPosition()
+ + AnalyzerConstants.CALLSTACK_API_TOKEN_STRING
+ + strSelfFuncName;
+ selfCallstackUnit = new CallStackUnit(selfAddr, strSelfSymbol);
+ addrMap.put(selfAddr, selfCallstackUnit);
+ }
+
+ List<CallStackUnit> userCallstack = getUserCallstack(tid);
+ int size = userCallstack.size();
+
+ int eventType = input.getId();
+ if (size > 0) {
+ if (eventType == MSG_FUNCTION_ENTRY) {
+ CallStackUnit topCallstackUnit = userCallstack.get(size - 1);
+ if (topCallstackUnit.equals(selfCallstackUnit)) {
+ DuplicateUserCall dupUserCall = dupUserCallMap.get(tid);
+ if (null == dupUserCall) {
+ dupUserCall = new DuplicateUserCall(selfCallstackUnit);
+ dupUserCallMap.put(tid, dupUserCall);
+ } else {
+ if (dupUserCall.getDupCallstackUnit().equals(
+ selfCallstackUnit)) {
+ dupUserCall.increaseDupCallCount();
+ } else {
+ System.out
+ .println("isIrregularUserCall : dup callstack check error"); //$NON-NLS-1$
+ }
+ }
+ return true;
+ }
+ } else if (eventType == MSG_FUNCTION_EXIT) {
+ DuplicateUserCall dupUserCall = dupUserCallMap.get(tid);
+ if (null != dupUserCall) {
+ if (dupUserCall.getDupCallstackUnit().equals(
+ selfCallstackUnit)) {
+ dupUserCall.decreaseDupCallCount();
+ if (0 == dupUserCall.getDupCallCount()) {
+ dupUserCallMap.remove(tid);
+ }
+ } else {
+ System.out
+ .println("isIrregularUserCall : dup callstack check error"); //$NON-NLS-1$
+ }
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ public void clear() {
+ callstackApiByAddrMap.clear();
+ callstackDataBySeqMap.clear();
+ userFunctionBin = null;
+ userCallstackByTidMap.clear();
+ dupUserCallByTidMap.clear();
+ }
+
+}
package org.tizen.dynamicanalyzer.swap.communicator;
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_BINARY_INFO_ACK;
import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_CONFIG_ACK;
import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_KEEP_ALIVE_ACK;
import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_START_ACK;
import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_TARGET_INFO_ACK;
import static org.tizen.dynamicanalyzer.common.CommonConstants.INT_SIZE;
import static org.tizen.dynamicanalyzer.common.CommonConstants.LONG_SIZE;
+import static org.tizen.sdblib.service.SyncServiceConstants.RESULT_OK;
import java.io.BufferedReader;
+import java.io.File;
import java.io.IOException;
+import java.io.InputStreamReader;
import java.net.Socket;
import java.net.SocketException;
import java.net.SocketTimeoutException;
import java.util.List;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
+import org.tizen.dynamicanalyzer.common.AnalyzerPaths;
import org.tizen.dynamicanalyzer.common.AnalyzerShellCommands;
import org.tizen.dynamicanalyzer.common.CommonConstants;
import org.tizen.dynamicanalyzer.common.ErrorCode;
import org.tizen.dynamicanalyzer.swap.logparser.SWAPLogParser;
import org.tizen.dynamicanalyzer.swap.model.ByteUtils;
import org.tizen.dynamicanalyzer.swap.model.control.ApplicationInfo;
+import org.tizen.dynamicanalyzer.swap.model.control.ApplicationInst;
+import org.tizen.dynamicanalyzer.swap.model.control.BinaryInfo;
import org.tizen.dynamicanalyzer.swap.model.control.RunTimeConfiguration;
import org.tizen.dynamicanalyzer.swap.model.control.TargetInfo;
+import org.tizen.dynamicanalyzer.swap.model.control.UserSpaceInst;
import org.tizen.dynamicanalyzer.ui.file.FileChartManager;
import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler;
import org.tizen.dynamicanalyzer.ui.thread.ThreadChartManager;
import org.tizen.dynamicanalyzer.ui.userinterface.UIDataManager;
import org.tizen.dynamicanalyzer.uirecorder.UIRecorderTool;
import org.tizen.dynamicanalyzer.utils.UpdateViewTimer;
+import org.tizen.sdblib.receiver.MultiLineReceiver;
+import org.tizen.sdblib.service.SyncResult;
public class Communicator30 extends BaseCommunicator {
private boolean isInit = false;
+ private static List<String> binaryHashMultiLines = new ArrayList<String>();
@Override
public HostResult init() {
+ " remote port get failed and remove this device : "
+ devInfo.getIDevice().getSerialNumber());
removeList.add(devInfo);
- // devices.remove(devInfo);
} else {
devInfo.setRemotePort(remotePort);
// step 4. port foward
if (!HostResult.SUCCESS.equals(result)) {
System.out.println(devInfo.getIDevice().getSerialNumber()
+ " port fowarding failed and remove this device");
- // devices.remove(devInfo);
removeList.add(devInfo);
}
}
}
}
// create data socket - not create data receive thread
- // for (DeviceInfo devInfo : devices) {
- // HostResult result = createDataSocket(devInfo);
- // if (!result.isSuccess()) {
- // System.out.println(result.toString());
- // }
- // }
if (!removeList.isEmpty()) {
devices.removeAll(removeList);
return result;
}
+// private UserSpaceInst getUserSpaceInst() {
+// UserSpaceInst output = new UserSpaceInst();
+// output.setCount(1); // single processing
+// List<ApplicationInst> applicationInstList = new ArrayList<ApplicationInst>();
+//
+// }
+
+ public HostResult sendBinaryInfoMessage() {
+ // send config message
+ byte[] msgBinInfo = ByteUtils
+ .toBytes(AnalyzerConstants.MSG_BINARY_INFO);
+ ApplicationInfo appInfo = new ApplicationInfo();
+ AppInfo selectedApp = DACommunicator.getSelectedApp();
+ String appType = selectedApp.getInfo(AppInfo.APPTYPE_INDEX);
+ if (appType.contains(AppInfo.APPTYPE_CPP)) {
+ appInfo.setAppType(ApplicationInfo.APPTYPE_TIZEN);
+ } else {
+ appInfo.setAppType(ApplicationInfo.APPTYPE_COMMON_EXEC);
+ }
+ appInfo.setAppId(selectedApp.getInfo(AppInfo.APPID_INDEX));
+ appInfo.setExecPath(selectedApp.getInfo(AppInfo.EXEC_INDEX));
+
+ int length = appInfo.getByteValue().length;
+ byte[] msg = ByteUtils.concatByteArray(msgBinInfo, length,
+ appInfo.getByteValue());
+
+ HostResult result = handleControlMessage(
+ DACommunicator.getSelectedDevice(), msg);
+
+ if (!result.isSuccess() || isCorrectAck(MSG_BINARY_INFO_ACK, result)) {
+ return HostResult.ERR_BIN_INFO_GET_FAIL;
+ }
+
+ byte[] payload = getMessagePayload(result.getRet());
+ BinaryInfo binInfo = new BinaryInfo();
+ int binaryType = ByteUtils.toInt(payload, 0);
+
+ String targetPath = selectedApp.getInfo(AppInfo.EXEC_INDEX);
+ String binaryPath = ByteUtils.getString(payload, INT_SIZE);
+ if (null == binaryPath || binaryPath.isEmpty()) {
+ return HostResult.ERR_BIN_INFO_GET_FAIL;
+ }
+ binInfo.setType(binaryType);
+
+ // host has no binary file - pull binary file from target
+ // change binary file path of host
+ File binFile = new File(binaryPath);
+ if (!binFile.exists()) {
+ SyncResult res = CommunicatorUtils.pull(targetPath,
+ AnalyzerPaths.TEMP_FOLDER_PATH);
+ if (null != res && RESULT_OK == res.getCode()) {
+ System.out.println("binary copy success!!");//$NON-NLS-1$
+ } else {
+ System.out.println("Failed to get " + targetPath); //$NON-NLS-1$
+ return HostResult.ERR_BIN_INFO_GET_FAIL;
+ }
+ String[] splitName = binaryPath.split(CommonConstants.SLASH);
+ binaryPath = AnalyzerPaths.TEMP_FOLDER_PATH + File.separator
+ + new String(splitName[splitName.length - 1]);
+ binInfo.setPath(binaryPath);
+ selectedApp.setBinInfo(binInfo);
+ return result;
+ }
+
+ // host has binary then compare binary hash target and local
+ String command = AnalyzerShellCommands.CMD_MD_5_SUM + targetPath;
+ CommunicatorUtils.execShellCommand(command, new MultiLineReceiver() {
+ @Override
+ public void processNewLines(String[] appLines) {
+ binaryHashMultiLines.clear();
+ for (int i = 0; i < appLines.length; i++) {
+ binaryHashMultiLines.add(appLines[i]);
+ }
+ }
+ });
+
+ String commandResult = binaryHashMultiLines.get(0);
+ String[] splitResult = commandResult.trim()
+ .split(CommonConstants.SPACE);
+ String targetHashCode = new String(splitResult[0]);
+ String localHashCode = null;
+ command = AnalyzerShellCommands.CMD_MD_5_SUM + binaryPath;
+ try {
+ Process process = Runtime.getRuntime().exec(command);
+ BufferedReader reader = new BufferedReader(new InputStreamReader(
+ process.getInputStream()));
+ String line = reader.readLine();
+
+ splitResult = line.trim().split(CommonConstants.SPACE);
+ localHashCode = new String(splitResult[0]);
+ } catch (IOException e) {
+ e.printStackTrace();
+ return HostResult.ERR_BIN_INFO_GET_FAIL;
+ }
+
+ // hash code is not same - get binary from target
+ // change binary file path of host
+ if (!targetHashCode.equals(localHashCode)) {
+ SyncResult res = CommunicatorUtils.pull(targetPath,
+ AnalyzerPaths.TEMP_FOLDER_PATH);
+ if (null != res && RESULT_OK == res.getCode()) {
+ System.out.println("binary copy success!!");//$NON-NLS-1$
+ } else {
+ System.out.println("Failed to get " + targetPath + " step 2"); //$NON-NLS-1$
+ return HostResult.ERR_BIN_INFO_GET_FAIL;
+ }
+ String[] splitName = binaryPath.split(CommonConstants.SLASH);
+ binaryPath = AnalyzerPaths.TEMP_FOLDER_PATH + File.separator
+ + new String(splitName[splitName.length - 1]);
+ binInfo.setPath(binaryPath);
+ selectedApp.setBinInfo(binInfo);
+ }
+ binInfo.setPath(binaryPath);
+ selectedApp.setBinInfo(binInfo);
+
+ return result;
+ }
+
@Override
public HostResult sendRuntimeMessage(int type, String message) {
// send config message
int index = INT_SIZE * 2;
return ByteUtils.toInt(data, index);
}
+
+ private byte[] getMessagePayload(byte[] data) {
+ int index = INT_SIZE;
+ int size = ByteUtils.toInt(data, index);
+ index += INT_SIZE * 2;
+ byte[] payload = new byte[size];
+ System.arraycopy(data, index, payload, 0, size);
+ return payload;
+ }
}
// make log
log = LogDataFactory.createInstance(data);
if (null != log) {
-
buffer.add(new LogContainer(log, data));
messageCount += 1;
}
import org.tizen.dynamicanalyzer.logparser.LogParser;
import org.tizen.dynamicanalyzer.model.ImageInfo;
import org.tizen.dynamicanalyzer.nl.InformationViewLabels;
-import org.tizen.dynamicanalyzer.project.Project;
-import org.tizen.dynamicanalyzer.swap.model.DATime;
import org.tizen.dynamicanalyzer.swap.model.LogContainer;
import org.tizen.dynamicanalyzer.swap.model.data.ApiNameManager;
import org.tizen.dynamicanalyzer.swap.model.data.BasicDataMessage;
import org.tizen.dynamicanalyzer.swap.model.probe2.ProfileData;
import org.tizen.dynamicanalyzer.swap.model.probe2.ScreenShotData;
import org.tizen.dynamicanalyzer.swap.model.probe2.SystemData;
-import org.tizen.dynamicanalyzer.swap.model.probe2.UserFunctionData;
import org.tizen.dynamicanalyzer.ui.page.BaseView;
import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler;
import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
}
int seqNum = log.getSeq();
- if (log instanceof UserFunctionData) {
- UserFunctionData ufData = (UserFunctionData) log;
- String apiName = ufData.getApiName();
+ if (log instanceof SystemData) {
+ if (seqNum == 1) {
+ UIRecorderPlayThread rp = UIRecorderTool.getInstance()
+ .getPlayThead();
+ if (null != rp && rp.isAlive()) {
+ UIRecorderTool.getInstance().getPlayThead().interrupt();
+ }
+ }
+ pushLog(log, msg, logPack);
+ } else if (log instanceof ProfileData) {
+ ProfileData pData = (ProfileData) log;
+ String apiName = pData.getApiName();
if (null == apiName || apiName.isEmpty()
|| apiName.equals("_end")) { //$NON-NLS-1$
- setFuncName(ufData);
+ setFuncName(pData);
}
if (LogParser.isDrapCallTraceLog()) {
- apiName = ufData.getApiName();
+ apiName = pData.getApiName();
if (!apiName.equals(OSP_MAIN)) {
continue;
}
LogParser.setDropCallTraceLog(false);
}
- long binaryStartAddr = ufData.getLowPc();
- long binaryEndAddr = ufData.getHighPc();
-
- if (binaryStartAddr > 0 && binaryEndAddr > 0
- && !AnalyzerManager.isBinStartEndSet()) {
- AnalyzerManager.setBinaryStartEndAddr(binaryStartAddr,
- binaryEndAddr);
- }
if (AnalyzerManager.getCallstackManager().isIrregularUserCall(
- ufData)) {
+ pData)) {
continue;
}
pushLog(log, msg, logPack);
/* user callstack create by entry and exit */
AnalyzerManager.getCallstackManager().makeUserCallstack(
- ufData,
+ pData,
FunctionUsageProfiler.getInstance()
.getProfileDataMaker());
- } else if (log instanceof SystemData) {
- if (seqNum == 1) {
- UIRecorderPlayThread rp = UIRecorderTool.getInstance()
- .getPlayThead();
- if (null != rp && rp.isAlive()) {
- UIRecorderTool.getInstance().getPlayThead().interrupt();
- }
- }
- pushLog(log, msg, logPack);
- } else if (log instanceof ProfileData) {
- pushLog(log, msg, logPack);
} else {
if (log instanceof ScreenShotData) {
String remoteImgPath = ((ScreenShotData) log)
.getImageFilePath();
- String rotate = Integer.toString(((ScreenShotData) log)
- .getOrientation());
+ int rotate = ((ScreenShotData) log).getOrientation();
// TODO : fix
- // processImage(remoteImgPath, rotate);
+ processImage(remoteImgPath, rotate);
}
pushLog(log, msg, logPack);
AnalyzerManager.getCallstackManager()
System.out.println("view update!!");
}
- private void setFuncName(UserFunctionData input) {
+ private void setFuncName(ProfileData input) {
boolean isPieBuild = AnalyzerManager.getProject().isPieBuild();
String baseAddr = Long.toString(AnalyzerManager.getProject()
.getBaseAddress());
output = new SystemData(input);
break;
default:
- break;
+ return null;
}
DataFactory.createData(output, payload);
return output;
int cpuNum = 0; // profiling common
String args = null; // function entry specific
long ret = 0;
+ String apiName = null;
String callstack = null;
public String getCallstack() {
return callstack;
}
+
+ public String getApiName() {
+ return apiName;
+ }
+
+ public void setApiName(String apiName) {
+ this.apiName = apiName;
+ }
+
+
}
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.SymbolManager;
-import org.tizen.dynamicanalyzer.communicator.DACommunicator;
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
import org.tizen.dynamicanalyzer.logparser.LogParser;
-import org.tizen.dynamicanalyzer.project.AppInfo;
+import org.tizen.dynamicanalyzer.swap.callstack.BaseCallstackManager;
import org.tizen.dynamicanalyzer.swap.model.probe2.LogData;
import org.tizen.dynamicanalyzer.swap.model.probe2.ProbeCommonData;
import org.tizen.dynamicanalyzer.swap.model.probe2.UserFunctionData;
import org.tizen.dynamicanalyzer.ui.summary.profiling.ProfileDataMaker;
-public class CallStackManager {
- class DuplicateUserCall {
- private CallStackUnit dupCallstackUnit = null;
- private int dupCallcount = 0;
+public class CallStackManager extends BaseCallstackManager {
- public DuplicateUserCall(CallStackUnit callStackUnit) {
- dupCallstackUnit = callStackUnit;
- dupCallcount = 1;
- }
-
- public CallStackUnit getDupCallstackUnit() {
- return dupCallstackUnit;
- }
-
- public int getDupCallCount() {
- return dupCallcount;
- }
-
- public void increaseDupCallCount() {
- dupCallcount++;
- }
-
- public void decreaseDupCallCount() {
- dupCallcount--;
- }
- }
-
- private HashMap<Long, CallStackUnit> callstackApiByAddrMap = new HashMap<Long, CallStackUnit>();
- private HashMap<Integer, CallStackData> callstackDataBySeqMap = new HashMap<Integer, CallStackData>();
- private String userFunctionBin = null;
- private HashMap<Integer, List<CallStackUnit>> userCallstackByTidMap = new HashMap<Integer, List<CallStackUnit>>();
- private HashMap<Integer, DuplicateUserCall> dupUserCallByTidMap = new HashMap<Integer, CallStackManager.DuplicateUserCall>();
-
- public void makeUserCallstack(UserFunctionData log,
- ProfileDataMaker profiler) {
+ public void makeUserCallstack(LogData input, ProfileDataMaker profiler) {
+ UserFunctionData log = (UserFunctionData) input;
HashMap<Long, CallStackUnit> addrMap = getCallStackApiByAddrMap();
boolean isPieBuild = AnalyzerManager.getProject().isPieBuild();
String baseAddr = Long.toString(AnalyzerManager.getProject()
}
// check irregular enter/exit log (multiple logs from 1 function call)
- public boolean isIrregularUserCall(UserFunctionData input) {
+ public boolean isIrregularUserCall(LogData data) {
+ UserFunctionData input = (UserFunctionData) data;
HashMap<Long, CallStackUnit> addrMap = getCallStackApiByAddrMap();
HashMap<Integer, DuplicateUserCall> dupUserCallMap = getDupUserCallByTidMap();
return false;
}
- public HashMap<Long, CallStackUnit> getCallStackApiByAddrMap() {
- if (null == callstackApiByAddrMap) {
- callstackApiByAddrMap = new HashMap<Long, CallStackUnit>();
- }
- return callstackApiByAddrMap;
- }
-
- public HashMap<Integer, CallStackData> getCallStackDataBySeqMap() {
- if (null == callstackDataBySeqMap) {
- callstackDataBySeqMap = new HashMap<Integer, CallStackData>();
- }
- return callstackDataBySeqMap;
- }
-
- public HashMap<Integer, DuplicateUserCall> getDupUserCallByTidMap() {
- if (null == dupUserCallByTidMap) {
- dupUserCallByTidMap = new HashMap<Integer, DuplicateUserCall>();
- }
- return dupUserCallByTidMap;
- }
-
- public String getUserFunctionPosition() {
- if (userFunctionBin == null || userFunctionBin.isEmpty()) {
- if (AnalyzerManager.isOsp()) {
- userFunctionBin = new String(DACommunicator.getSelectedApp()
- .getInfo(AppInfo.EXEC_INDEX) + ".exe"); //$NON-NLS-1$
- } else {
- userFunctionBin = new String(DACommunicator.getSelectedApp()
- .getInfo(AppInfo.EXEC_INDEX));
- }
- }
- return userFunctionBin;
- }
-
- public List<CallStackUnit> getUserCallstack(int tid) {
- if (null == userCallstackByTidMap) {
- userCallstackByTidMap = new HashMap<Integer, List<CallStackUnit>>();
- }
- List<CallStackUnit> userCallstack = userCallstackByTidMap.get(tid);
- if (null == userCallstack) {
- userCallstack = new ArrayList<CallStackUnit>();
- userCallstackByTidMap.put(tid, userCallstack);
- }
- return userCallstack;
- }
-
- public CallStackData getCallStack(String seqNum) {
- int seq = Integer.parseInt(seqNum);
- return getCallStackDataBySeqMap().get(seq);
- }
-
- public boolean checkUserCall(String input) {
- if (input.contains(AnalyzerConstants.USER_BIN_POS)) {
- return true;
- }
- return false;
- }
-
- public boolean isUserCall(String input) {
- if (!input.contains(LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC)) {
- return true;
- }
- return false;
- }
-
- public long getPCAddrBySeq(int seq) {
- HashMap<Integer, CallStackData> cdMap = getCallStackDataBySeqMap();
- if (null == cdMap) {
- return -1;
- }
- CallStackData csd = cdMap.get(seq);
- if (null == csd) {
- return -1;
- }
- List<Long> addrs = csd.getAddrs();
- if (null == addrs || addrs.isEmpty()) {
- return -1;
- }
- return addrs.get(0);
- }
-
public void clear() {
callstackApiByAddrMap.clear();
callstackDataBySeqMap.clear();
userCallstackByTidMap.clear();
dupUserCallByTidMap.clear();
}
+
}
import java.util.List;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
+import org.tizen.dynamicanalyzer.swap.callstack.BaseCallstackManager;
import org.tizen.dynamicanalyzer.swap.model.probe2.FailedData2;
import org.tizen.dynamicanalyzer.swap.model.probe2.FileData;
import org.tizen.dynamicanalyzer.swap.model.probe2.LogData;
import org.tizen.dynamicanalyzer.swap.model.probe2.MemoryData;
import org.tizen.dynamicanalyzer.swap.model.probe2.ProbeCommonData;
import org.tizen.dynamicanalyzer.swap.model.probe2.UserFunctionData;
-import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackManager;
import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
public class FailedChecker {
List<FailedData2> failedList;
- public void check(LogData log, CallStackManager cm) {
- // String logcId = intput[LogCenterConstants.ID_INDEX];
- // int cid = Integer.parseInt(logcId);
+ public void check(LogData log, BaseCallstackManager cm) {
if (log instanceof MemoryData) {
if (AnalyzerUtil.isInternal((ProbeCommonData) log)) {
return;
}
- // String addr = intput[LogCenterConstants.MEMORY_ADDR_INDEX];
long addr = ((MemoryData) log).getAddress();
- // if (!addr.equals("0") && !addr.equals("0x0")) { //$NON-NLS-1$ //$NON-NLS-2$
- // return;
- // }
if (addr == 0) { //$NON-NLS-1$ //$NON-NLS-2$
return;
}
checkUserDefinedFunc(log, cm);
}
- // if (cid == LogCenterConstants.LOG_RESOURCE) {
if (log instanceof FileData) {
FileData fileData = ((FileData) log);
if (AnalyzerUtil.isInternal(fileData)) {
return;
}
- // String fdTypeStr =
- // intput[LogCenterConstants.RESOURCE_FDTYPE_INDEX];
- // String errnoStr = intput[LogCenterConstants.ERROR_INDEX];
- // int fdType = Integer.parseInt(fdTypeStr);
- // long errno = Long.parseLong(errnoStr);
int fdType = fileData.getFdType();
long errno = fileData.getErrno();
- // file or (not error) - file error check file page
if (fdType == 0 || errno == 0) {
return;
}
checkUserDefinedFunc(fileData, cm);
}
- // if (cid == LogCenterConstants.LOG_USER_FUNCTION) {
if (log instanceof UserFunctionData) {
// TODO : check user function error???
return;
}
}
- private void checkUserDefinedFunc(LogData log, CallStackManager cm) {
+ private void checkUserDefinedFunc(LogData log, BaseCallstackManager cm) {
if (AnalyzerConstants.USER_CALL == AnalyzerUtil
.checkUserCall((ProbeCommonData) log)) {
FailedData2 fd = new FailedData2(log);
package org.tizen.dynamicanalyzer.ui.summary.profiling;
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_FUNCTION_EXIT;
+
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerPaths;
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
+import org.tizen.dynamicanalyzer.swap.callstack.BaseCallstackManager;
import org.tizen.dynamicanalyzer.swap.model.probe2.ProfileData;
import org.tizen.dynamicanalyzer.swap.model.probe2.UserFunctionData;
-import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackManager;
import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackUnit;
import org.tizen.dynamicanalyzer.utils.Formatter;
private CallstackTree current = null;
private int totalSampleCount = 0;
- private CallStackManager callstackManager = null;
+ private BaseCallstackManager callstackManager = null;
/**
* key: seq - value : function usage profiling data hash map all function
private ProfilingData dependentLib = null;
private String appBinName = null;
- public ProfileDataMaker(CallStackManager callstackManager) {
+ public ProfileDataMaker(BaseCallstackManager callstackManager) {
this.callstackManager = callstackManager;
}
getSymbolSeqHash().clear();
}
- public CallStackManager getCallstackManager() {
+ public BaseCallstackManager getCallstackManager() {
return callstackManager;
}
}
}
}
+
+ public void makeFupDataForCallTrace(CallStackUnit inputCallstackApiData,
+ ProfileData log) {
+ totalSampleCount++;
+ long exeTime = 0;
+ int type = log.getId();
+ if (type == MSG_FUNCTION_EXIT) {
+ // exeTime += log.getElapsedTime();
+ }
+
+ ProfilingData parent = getProfilingDataByKey(inputCallstackApiData
+ .getPath());
+ if (null == parent) {
+ parent = makeNewProfilingData(inputCallstackApiData, true);
+ checkUserCall(inputCallstackApiData, parent, null);
+
+ ProfilingData child = makeNewProfilingData(inputCallstackApiData,
+ false);
+ parent.addChild(child);
+ child.addExCount();
+ child.addElpasedTime(exeTime);
+ child.setParent(parent.getName());
+
+ if (type != MSG_FUNCTION_EXIT) {
+ child.addCallCount();
+ }
+ } else { // null != parent
+ ProfilingData child = getProfilingDataByKey(inputCallstackApiData
+ .getSymbol());
+ if (null == child) {
+ child = makeNewProfilingData(inputCallstackApiData, false);
+ parent.addChild(child);
+ child.setParent(parent.getName());
+ }
+ child.addExCount();
+ child.addElpasedTime(exeTime);
+ if (type != MSG_FUNCTION_EXIT) {
+ child.addCallCount();
+ }
+
+ // calculate internal time
+ if (type == MSG_FUNCTION_EXIT) {
+ if (null == current) {
+ // bug
+ System.out
+ .println("exit without entry - range only :" + inputCallstackApiData.getFunctionName()); //$NON-NLS-1$
+ } else {
+ CallstackTree parentCt = current.getParent();
+ if (null != parentCt) {
+ parentCt.addChildExeTime(current.getThis()
+ .getLastElapsedTime());
+ }
+ child.addExclusiveElapsedTime(current.getInclusiveExeTime());
+ current = current.getParent();
+ }
+ } else {
+ if (null == current) {
+ CallstackTree ct = new CallstackTree(child, null);
+ current = ct;
+ } else {
+ CallstackTree ct = new CallstackTree(child, current);
+ current.addChild(ct);
+ current = ct;
+ }
+ }
+ }
+ }
}
import org.tizen.dynamicanalyzer.swap.logparser.LogPackage;
import org.tizen.dynamicanalyzer.swap.logparser.Logs;
import org.tizen.dynamicanalyzer.swap.model.probe2.LogData;
+import org.tizen.dynamicanalyzer.swap.model.probe2.ProfileData;
import org.tizen.dynamicanalyzer.swap.model.probe2.UserFunctionData;
import org.tizen.dynamicanalyzer.ui.info.callstack.CallstackView;
+import org.tizen.dynamicanalyzer.ui.summary.profiling.ProfilingData;
import org.tizen.dynamicanalyzer.ui.timeline.TimelinePage;
import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineView;
import org.tizen.dynamicanalyzer.ui.widgets.DATabComposite;
long start = selData.getStartTime();
long end = selData.getEndTime();
updateView();
- ((CallTraceTable)tableComp).setSelectionByTime(start, end);
+ ((CallTraceTable) tableComp).setSelectionByTime(start, end);
updateView();
/* only callstack update */
// timeline view and tabcomp top view : callstack
@Override
public void updateLog(LogPackage logPack) {
Logs logs = logPack.getLogs(LogCenterConstants.LOG_USER_FUNCTION);
+ if (null == logs) {
+ logs = logPack.getLogs(AnalyzerConstants.MSG_FUNCTION_ENTRY);
+ }
if (null == logs || null == logs.getLogs() || logs.getLogs().isEmpty()) {
return;
}
int size = inputs.size();
for (int i = 0; i < size; i++) {
- UserFunctionData input = (UserFunctionData) inputs.get(i);
- int type = input.getType();
- if (type == LogCenterConstants.USER_FUNCTION_EVENT_TYPE_ENTER) {
- userLog.add(input);
+ if (logs.getId() == AnalyzerConstants.MSG_FUNCTION_ENTRY) {
+ ProfileData pData = (ProfileData) inputs.get(i);
+ userLog.add(pData);
+ } else if (logs.getId() == LogCenterConstants.LOG_USER_FUNCTION) {
+ UserFunctionData input = (UserFunctionData) inputs.get(i);
+ int type = input.getType();
+ if (type == LogCenterConstants.USER_FUNCTION_EVENT_TYPE_ENTER) {
+ userLog.add(input);
+ }
}
+
}
}
import org.tizen.dynamicanalyzer.resources.ImageResources;
import org.tizen.dynamicanalyzer.services.RecordStateSourceProvider;
import org.tizen.dynamicanalyzer.shortcut.ShortCutManager;
-import org.tizen.dynamicanalyzer.swap.communicator.Communicator30;
-import org.tizen.dynamicanalyzer.swap.logparser.MessageParser;
-import org.tizen.dynamicanalyzer.swap.model.data.TestProbe;
import org.tizen.dynamicanalyzer.ui.timeline.TimelinePage;
import org.tizen.dynamicanalyzer.ui.toolbar.configuration.ConfigurationDialog;
import org.tizen.dynamicanalyzer.ui.toolbar.opentrace.OpenTraceDialog;
public void handleClickEvent(DACustomButton button) {
// TODO : use for test code...
-
- TestProbe test = new TestProbe();
-
- byte[] input = test.getByteValue();
- MessageParser.getInstance().testParsing(input);
-
- Communicator30 c30 = new Communicator30();
- c30.startTrace();
-
- c30.sendRuntimeMessage(0, "test");
- c30.stopTrace();
+// String path = "/home/casval/work/testApp/DATizenTestApp/Dynamic Analyzer/DATizenTestApp.exe";
+// ElfSymbolExtractManager.getInstance().makeSymbol(path);
+// Long[] result = ElfSymbolExtractManager.getInstance()
+// .getSymbolAddress();
+//
+// HashMap<Long, String> symbolMap = ElfSymbolExtractManager
+// .getInstance().symbolMap();
+// List<String> symbols = new ArrayList<String>();
+// symbols.addAll(symbolMap.values());
+//
+// for (String s : symbols) {
+// String symbol = SymbolManager
+// .demanglingFunctionName(s);
+// System.out.println("test : " + symbol);
+// }
// DACommunicator.getLocalhost();
// System.out.println(CommonConstants.LOCAL_HOST);
projects / sdk / tools / dynamic-analyzer.git / commitdiff