From: jooyoul_lee Date: Wed, 24 Jul 2013 07:12:28 +0000 (+0900) Subject: [Title] SWAP DA update X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=20b7b589744cb26368cd1adf0a72c317c6c53517;p=sdk%2Ftools%2Fdynamic-analyzer.git [Title] SWAP DA update [Desc.] [Issue] --- diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/AnalyzerManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/AnalyzerManager.java index 1c58588..bb99ac3 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/AnalyzerManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/AnalyzerManager.java @@ -33,6 +33,7 @@ import java.util.Collections; 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; @@ -42,7 +43,8 @@ import org.tizen.dynamicanalyzer.model.LogCenter; 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; @@ -77,6 +79,7 @@ public class AnalyzerManager { 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; @@ -182,6 +185,7 @@ public class AnalyzerManager { warningChecker.clear(); calledChecker.clear(); callstackManager.clear(); + swapCallstackManager.clear(); isHaveSampleThread = false; StopProcessManager.clear(); UserFunctionManager.getInstance().clear(); @@ -373,8 +377,12 @@ public class AnalyzerManager { return warningChecker; } - public static CallStackManager getCallstackManager() { - return callstackManager; + public static BaseCallstackManager getCallstackManager() { + if (DACommunicator.isSWAPVersion()) { + return swapCallstackManager; + } else { + return callstackManager; + } } public static FailedChecker getCalledFunctionChecker() { @@ -393,36 +401,6 @@ public class AnalyzerManager { } } - // public static List getLogCenters() { - // if (null != project) { - // return project.getLogCenters(); - // } - // return getInnerLogCenters(); - // } - - // public void initLogCenters() { - // if (null != logCenters) { - // logCenters.clear(); - // } else { - // logCenters = new ArrayList(); - // } - // - // logCenters.addAll(AnalyzerManager.getLogCenters()); - // } - - // public static LogCenter getLogCenterById(int id) { - // List 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; diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/AnalyzerShellCommands.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/AnalyzerShellCommands.java index 9018ad3..9b8d7fd 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/AnalyzerShellCommands.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/AnalyzerShellCommands.java @@ -45,4 +45,6 @@ public class AnalyzerShellCommands { 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$ } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/ElfSymbolExtractManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/ElfSymbolExtractManager.java new file mode 100644 index 0000000..b14f517 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/ElfSymbolExtractManager.java @@ -0,0 +1,106 @@ +/* + * Dynamic Analyzer + * + * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * YeongTaik Byeon + * Juyoung Kim + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * Contributors: + * - S-Core Co., Ltd + * + */ +package org.tizen.dynamicanalyzer.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 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(); + } + 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 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; + } + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/HostResult.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/HostResult.java index 59d424b..1493131 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/HostResult.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/HostResult.java @@ -42,6 +42,8 @@ public enum HostResult { 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"), diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/project/AppInfo.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/project/AppInfo.java index 86a83d2..54c56f6 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/project/AppInfo.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/project/AppInfo.java @@ -30,6 +30,7 @@ import java.util.ArrayList; import java.util.List; import org.tizen.dynamicanalyzer.common.CommonConstants; +import org.tizen.dynamicanalyzer.swap.model.control.BinaryInfo; public class AppInfo { @@ -51,7 +52,10 @@ 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; } @@ -75,4 +79,12 @@ public class AppInfo { public String getInfo(int index) { return appInfo.get(index); } + + public BinaryInfo getBinInfo() { + return binInfo; + } + + public void setBinInfo(BinaryInfo binInfo) { + this.binInfo = binInfo; + } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/project/Project.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/project/Project.java index ffe1d7d..8a42a7e 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/project/Project.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/project/Project.java @@ -302,6 +302,10 @@ public class Project { return processInfo.getLowestAddress(); } + public long getHighestAddress() { + return processInfo.getHighestAddress(); + } + public int getApplicationType() { return processInfo.getAppType(); } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/callstack/BaseCallstackManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/callstack/BaseCallstackManager.java new file mode 100644 index 0000000..b60be4e --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/callstack/BaseCallstackManager.java @@ -0,0 +1,139 @@ +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 callstackApiByAddrMap = new HashMap(); + protected HashMap callstackDataBySeqMap = new HashMap(); + protected String userFunctionBin = null; + protected HashMap> userCallstackByTidMap = new HashMap>(); + protected HashMap dupUserCallByTidMap = new HashMap(); + + abstract public void makeUserCallstack(LogData log, + ProfileDataMaker profiler); + + abstract public void makeCallstackWithoutBacktrace(LogData inputData); + + abstract public boolean isIrregularUserCall(LogData input); + + public HashMap getCallStackApiByAddrMap() { + if (null == callstackApiByAddrMap) { + callstackApiByAddrMap = new HashMap(); + } + return callstackApiByAddrMap; + } + + public HashMap getCallStackDataBySeqMap() { + if (null == callstackDataBySeqMap) { + callstackDataBySeqMap = new HashMap(); + } + return callstackDataBySeqMap; + } + + public HashMap getDupUserCallByTidMap() { + if (null == dupUserCallByTidMap) { + dupUserCallByTidMap = new HashMap(); + } + 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 getUserCallstack(int tid) { + if (null == userCallstackByTidMap) { + userCallstackByTidMap = new HashMap>(); + } + List userCallstack = userCallstackByTidMap.get(tid); + if (null == userCallstack) { + userCallstack = new ArrayList(); + 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 cdMap = getCallStackDataBySeqMap(); + if (null == cdMap) { + return -1; + } + CallStackData csd = cdMap.get(seq); + if (null == csd) { + return -1; + } + List addrs = csd.getAddrs(); + if (null == addrs || addrs.isEmpty()) { + return -1; + } + return addrs.get(0); + } + + abstract public void clear(); +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/callstack/SWAPCallStackManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/callstack/SWAPCallStackManager.java new file mode 100644 index 0000000..4d9e588 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/callstack/SWAPCallStackManager.java @@ -0,0 +1,380 @@ +/* + * Dynamic Analyzer + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * WooJin Jung + * Jooyoul Lee + * Juyoung Kim + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * Contributors: + * - S-Core Co., Ltd + * + */ + +package org.tizen.dynamicanalyzer.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 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 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 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 probeCallstack = new ArrayList( + 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 addrMap = getCallStackApiByAddrMap(); + HashMap 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 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(); + } + +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/communicator/Communicator30.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/communicator/Communicator30.java index 1e66ee7..20af329 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/communicator/Communicator30.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/communicator/Communicator30.java @@ -1,5 +1,6 @@ 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; @@ -7,9 +8,12 @@ import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_STOP_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; @@ -18,6 +22,7 @@ import java.util.ArrayList; 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; @@ -30,8 +35,11 @@ import org.tizen.dynamicanalyzer.project.AppInfo; 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; @@ -40,9 +48,12 @@ import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea; 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 binaryHashMultiLines = new ArrayList(); @Override public HostResult init() { @@ -69,7 +80,6 @@ public class Communicator30 extends BaseCommunicator { + " 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 @@ -80,7 +90,6 @@ public class Communicator30 extends BaseCommunicator { if (!HostResult.SUCCESS.equals(result)) { System.out.println(devInfo.getIDevice().getSerialNumber() + " port fowarding failed and remove this device"); - // devices.remove(devInfo); removeList.add(devInfo); } } @@ -106,12 +115,6 @@ public class Communicator30 extends BaseCommunicator { } } // 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); @@ -206,6 +209,124 @@ public class Communicator30 extends BaseCommunicator { return result; } +// private UserSpaceInst getUserSpaceInst() { +// UserSpaceInst output = new UserSpaceInst(); +// output.setCount(1); // single processing +// List applicationInstList = new ArrayList(); +// +// } + + 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 @@ -494,4 +615,13 @@ public class Communicator30 extends BaseCommunicator { 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; + } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/MessageParser.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/MessageParser.java index 535a320..52e2286 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/MessageParser.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/MessageParser.java @@ -386,7 +386,6 @@ public class MessageParser { // make log log = LogDataFactory.createInstance(data); if (null != log) { - buffer.add(new LogContainer(log, data)); messageCount += 1; } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/SWAPLogParser.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/SWAPLogParser.java index 4405615..ecbbc68 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/SWAPLogParser.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/SWAPLogParser.java @@ -40,8 +40,6 @@ import org.tizen.dynamicanalyzer.logparser.LogInserter; 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; @@ -50,7 +48,6 @@ import org.tizen.dynamicanalyzer.swap.model.probe2.ProbeCommonData; 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; @@ -178,59 +175,48 @@ public class SWAPLogParser implements Runnable { } 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() @@ -325,7 +311,7 @@ public class SWAPLogParser implements Runnable { 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()); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/probe2/LogDataFactory.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/probe2/LogDataFactory.java index f78db6c..82b3bb9 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/probe2/LogDataFactory.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/probe2/LogDataFactory.java @@ -122,7 +122,7 @@ public class LogDataFactory { output = new SystemData(input); break; default: - break; + return null; } DataFactory.createData(output, payload); return output; diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/probe2/ProfileData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/probe2/ProfileData.java index cddbb56..42ef620 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/probe2/ProfileData.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/probe2/ProfileData.java @@ -13,6 +13,7 @@ public class ProfileData extends LogData { int cpuNum = 0; // profiling common String args = null; // function entry specific long ret = 0; + String apiName = null; String callstack = null; @@ -99,4 +100,14 @@ public class ProfileData extends LogData { public String getCallstack() { return callstack; } + + public String getApiName() { + return apiName; + } + + public void setApiName(String apiName) { + this.apiName = apiName; + } + + } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/callstack/CallStackManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/callstack/CallStackManager.java index 546fc8d..a7808ae 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/callstack/CallStackManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/callstack/CallStackManager.java @@ -34,50 +34,18 @@ 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.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 callstackApiByAddrMap = new HashMap(); - private HashMap callstackDataBySeqMap = new HashMap(); - private String userFunctionBin = null; - private HashMap> userCallstackByTidMap = new HashMap>(); - private HashMap dupUserCallByTidMap = new HashMap(); - - public void makeUserCallstack(UserFunctionData log, - ProfileDataMaker profiler) { + public void makeUserCallstack(LogData input, ProfileDataMaker profiler) { + UserFunctionData log = (UserFunctionData) input; HashMap addrMap = getCallStackApiByAddrMap(); boolean isPieBuild = AnalyzerManager.getProject().isPieBuild(); String baseAddr = Long.toString(AnalyzerManager.getProject() @@ -324,7 +292,8 @@ public class CallStackManager { } // 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 addrMap = getCallStackApiByAddrMap(); HashMap dupUserCallMap = getDupUserCallByTidMap(); @@ -396,87 +365,6 @@ public class CallStackManager { return false; } - public HashMap getCallStackApiByAddrMap() { - if (null == callstackApiByAddrMap) { - callstackApiByAddrMap = new HashMap(); - } - return callstackApiByAddrMap; - } - - public HashMap getCallStackDataBySeqMap() { - if (null == callstackDataBySeqMap) { - callstackDataBySeqMap = new HashMap(); - } - return callstackDataBySeqMap; - } - - public HashMap getDupUserCallByTidMap() { - if (null == dupUserCallByTidMap) { - dupUserCallByTidMap = new HashMap(); - } - 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 getUserCallstack(int tid) { - if (null == userCallstackByTidMap) { - userCallstackByTidMap = new HashMap>(); - } - List userCallstack = userCallstackByTidMap.get(tid); - if (null == userCallstack) { - userCallstack = new ArrayList(); - 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 cdMap = getCallStackDataBySeqMap(); - if (null == cdMap) { - return -1; - } - CallStackData csd = cdMap.get(seq); - if (null == csd) { - return -1; - } - List addrs = csd.getAddrs(); - if (null == addrs || addrs.isEmpty()) { - return -1; - } - return addrs.get(0); - } - public void clear() { callstackApiByAddrMap.clear(); callstackDataBySeqMap.clear(); @@ -484,4 +372,5 @@ public class CallStackManager { userCallstackByTidMap.clear(); dupUserCallByTidMap.clear(); } + } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedChecker.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedChecker.java index 3d2d8ab..3416c21 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedChecker.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedChecker.java @@ -30,64 +30,50 @@ import java.util.ArrayList; 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 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); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/profiling/ProfileDataMaker.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/profiling/ProfileDataMaker.java index 070e724..eb0d398 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/profiling/ProfileDataMaker.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/profiling/ProfileDataMaker.java @@ -27,6 +27,8 @@ 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; @@ -34,9 +36,9 @@ 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; @@ -77,7 +79,7 @@ public class ProfileDataMaker { 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 @@ -95,7 +97,7 @@ public class ProfileDataMaker { private ProfilingData dependentLib = null; private String appBinName = null; - public ProfileDataMaker(CallStackManager callstackManager) { + public ProfileDataMaker(BaseCallstackManager callstackManager) { this.callstackManager = callstackManager; } @@ -109,7 +111,7 @@ public class ProfileDataMaker { getSymbolSeqHash().clear(); } - public CallStackManager getCallstackManager() { + public BaseCallstackManager getCallstackManager() { return callstackManager; } @@ -470,4 +472,71 @@ public class ProfileDataMaker { } } } + + 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; + } + } + } + } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/calltrace/CallTraceView.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/calltrace/CallTraceView.java index 8c63214..55616b7 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/calltrace/CallTraceView.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/calltrace/CallTraceView.java @@ -41,8 +41,10 @@ import org.tizen.dynamicanalyzer.resources.ColorResources; 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; @@ -97,7 +99,7 @@ public class CallTraceView extends DAView { 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 @@ -129,6 +131,9 @@ public class CallTraceView extends DAView { @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; } @@ -138,11 +143,17 @@ public class CallTraceView extends DAView { 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); + } } + } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/ToolbarArea.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/ToolbarArea.java index d5a1666..f9bf93d 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/ToolbarArea.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/ToolbarArea.java @@ -60,9 +60,6 @@ import org.tizen.dynamicanalyzer.resources.FontResources; 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; @@ -407,17 +404,21 @@ public class ToolbarArea { 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 symbolMap = ElfSymbolExtractManager +// .getInstance().symbolMap(); +// List symbols = new ArrayList(); +// 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);