From 9fe611bd5b86f9af8db64c2aec75fe3917b92001 Mon Sep 17 00:00:00 2001 From: woojin Date: Thu, 31 Oct 2013 14:57:08 +0900 Subject: [PATCH] [Title] enable function usage profile data [Desc.] 1. show functions usage profiling data for sample log, user function log 2. show callstack of calltrace [Issue] --- .../tizen/dynamicanalyzer/logparser/LogParser.java | 2 +- .../swap/callstack/BaseCallstackManager.java | 27 ++- .../swap/callstack/SWAPCallStackManager.java | 78 ++++--- .../swap/logparser/MessageParser.java | 10 + .../swap/logparser/SWAPLogParser.java | 111 +++++---- .../ui/info/callstack/CallStackItem.java | 51 ++++ .../ui/info/callstack/CallStackManager.java | 53 ++--- .../ui/summary/profiling/ProfileDataMaker.java | 257 +++++++++++++++++++-- .../tizen/dynamicanalyzer/utils/AnalyzerUtil.java | 5 +- 9 files changed, 453 insertions(+), 141 deletions(-) create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/callstack/CallStackItem.java diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/logparser/LogParser.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/logparser/LogParser.java index b61dd2d..f2f2010 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/logparser/LogParser.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/logparser/LogParser.java @@ -90,7 +90,7 @@ public class LogParser implements Runnable { dropCallTraceLog = drop; } - public static boolean isDrapCallTraceLog() { + public static boolean isDropCallTraceLog() { return dropCallTraceLog; } 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 index 67e7205..52cd430 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/callstack/BaseCallstackManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/callstack/BaseCallstackManager.java @@ -28,6 +28,7 @@ package org.tizen.dynamicanalyzer.swap.callstack; import java.util.ArrayList; import java.util.HashMap; import java.util.List; +import java.util.TreeMap; import org.tizen.dynamicanalyzer.common.AnalyzerConstants; import org.tizen.dynamicanalyzer.common.AnalyzerManager; @@ -37,6 +38,7 @@ import org.tizen.dynamicanalyzer.project.PackageInfo; import org.tizen.dynamicanalyzer.swap.model.data.LogData; import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackData; import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackUnit; +import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackItem; import org.tizen.dynamicanalyzer.ui.summary.profiling.ProfileDataMaker; public abstract class BaseCallstackManager { @@ -69,9 +71,10 @@ public abstract class BaseCallstackManager { protected HashMap callstackApiByAddrMap = new HashMap(); protected HashMap callstackDataBySeqMap = new HashMap(); protected String userFunctionBin = null; - protected HashMap> userCallstackByTidMap = new HashMap>(); + protected HashMap> userCallstackByTidMap = new HashMap>(); protected HashMap dupUserCallByTidMap = new HashMap(); - + protected HashMap> seqTimeByTidMap = new HashMap>(); + abstract public void makeUserCallstack(LogData log, ProfileDataMaker profiler); @@ -100,6 +103,18 @@ public abstract class BaseCallstackManager { return dupUserCallByTidMap; } + public TreeMap getSeqTimeByTidMap(int tid) { + if (null == seqTimeByTidMap) { + seqTimeByTidMap = new HashMap>(); + } + TreeMap seqByTimeMap = seqTimeByTidMap.get(tid); + if(null == seqByTimeMap) { + seqByTimeMap = new TreeMap(); + seqTimeByTidMap.put(tid, seqByTimeMap); + } + return seqByTimeMap; + } + public String getUserFunctionPosition() { if (userFunctionBin == null || userFunctionBin.isEmpty()) { if (AnalyzerManager.isOsp()) { @@ -113,13 +128,13 @@ public abstract class BaseCallstackManager { return userFunctionBin; } - public List getUserCallstack(int tid) { + public List getUserCallstack(int tid) { if (null == userCallstackByTidMap) { - userCallstackByTidMap = new HashMap>(); + userCallstackByTidMap = new HashMap>(); } - List userCallstack = userCallstackByTidMap.get(tid); + List userCallstack = userCallstackByTidMap.get(tid); if (null == userCallstack) { - userCallstack = new ArrayList(); + userCallstack = new ArrayList(); userCallstackByTidMap.put(tid, userCallstack); } return userCallstack; 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 index 08e3621..23d75e3 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/callstack/SWAPCallStackManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/callstack/SWAPCallStackManager.java @@ -33,18 +33,21 @@ import static org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants.M import java.util.ArrayList; import java.util.HashMap; import java.util.List; +import java.util.TreeMap; 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.swap.logparser.SWAPLogParser; import org.tizen.dynamicanalyzer.swap.channel.control.BinaryInfo; import org.tizen.dynamicanalyzer.swap.model.data.LogData; import org.tizen.dynamicanalyzer.swap.model.data.ProbeCommonData; import org.tizen.dynamicanalyzer.swap.model.data.ProfileData; import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackData; import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackUnit; +import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackItem; import org.tizen.dynamicanalyzer.ui.summary.profiling.ProfileDataMaker; import org.tizen.dynamicanalyzer.utils.AnalyzerUtil; @@ -67,6 +70,7 @@ public class SWAPCallStackManager extends BaseCallstackManager { int seq = log.getSeq(); int tid = log.getTid(); + long time = log.getTime(); long selfAddr = log.getPcAddr(); long callerAddr = log.getCallerPcAddr(); @@ -87,9 +91,10 @@ public class SWAPCallStackManager extends BaseCallstackManager { // insert call count profiler.makeFupDataForCallTrace(selfCallstackUnit, log); - List userCallstack = getUserCallstack(tid); + List userCallstack = getUserCallstack(tid); int size = userCallstack.size(); - + TreeMap seqByTimeMap = getSeqTimeByTidMap(tid); + CallStackUnit callerCallstackUnit = addrMap.get(callerAddr); if (null == callerCallstackUnit) { String strCallerFuncName = SymbolManager.addr2func(sourceBinPath, @@ -105,14 +110,14 @@ public class SWAPCallStackManager extends BaseCallstackManager { int eventType = log.getId(); if (eventType == MSG_FUNCTION_ENTRY) { if (size == 0) { - userCallstack.add(selfCallstackUnit); + userCallstack.add(new CallStackItem(selfCallstackUnit, time)); } else { if (!AnalyzerManager.isInBinaryRange(callerAddr)) { CallStackUnit callbackApi = new CallStackUnit( LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_ADDR, LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_SYMBOL, log); - userCallstack.add(callbackApi); + userCallstack.add(new CallStackItem(callbackApi)); if (addrMap .get(LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_ADDR) == null) { CallStackUnit defaultCallstackUnit = new CallStackUnit( @@ -129,7 +134,7 @@ public class SWAPCallStackManager extends BaseCallstackManager { LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_ADDR, LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_SYMBOL, log); - userCallstack.add(callbackApi); + userCallstack.add(new CallStackItem(callbackApi)); if (addrMap .get(LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_ADDR) == null) { CallStackUnit defaultCallstackUnit = new CallStackUnit( @@ -140,32 +145,33 @@ public class SWAPCallStackManager extends BaseCallstackManager { LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_ADDR, defaultCallstackUnit); } - userCallstack.add(callerCallstackUnit); + userCallstack.add(new CallStackItem(callerCallstackUnit)); } else { CallStackUnit callerCsa = addrMap.get(callerAddr); if (null == callerCsa) { - callerCsa = userCallstack.get(size - 1); + callerCsa = userCallstack.get(size - 1).getCallStackUnit(); callerCsa.setFunctionStartAddr(callerCsa.getAddr()); callerCsa.setAddr(callerAddr); } else { callerCsa.setFunctionStartAddr(userCallstack.get( - size - 1).getAddr()); - userCallstack.set(size - 1, callerCsa); + size - 1).getCallStackUnit().getAddr()); + userCallstack.set(size - 1, new CallStackItem(callerCsa)); } } - userCallstack.add(selfCallstackUnit); + userCallstack.add(new CallStackItem(selfCallstackUnit, time)); } size = userCallstack.size(); for (int i = size - 1; i >= 0; i--) { - callstackData.getAddrs().add(userCallstack.get(i).getAddr()); + callstackData.getAddrs().add(userCallstack.get(i).getCallStackUnit().getAddr()); } getCallStackDataBySeqMap().put(seq, callstackData); + seqByTimeMap.put(time, seq); } 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); + CallStackUnit removeCallStackUnit = userCallstack.get(size - 1).getCallStackUnit(); if (selfCallstackUnit.getFunctionName().equals( removeCallStackUnit.getFunctionName())) { userCallstack.remove(size - 1); @@ -173,7 +179,7 @@ public class SWAPCallStackManager extends BaseCallstackManager { if (callerCallstackUnit.getFunctionName().contains( AnalyzerConstants.VIRTUAL_THUNK)) { if (callerCallstackUnit.getFunctionName().equals( - userCallstack.get(size - 2).getFunctionName())) { + userCallstack.get(size - 2).getCallStackUnit().getFunctionName())) { userCallstack.remove(size - 2); } else { System.out @@ -185,7 +191,7 @@ public class SWAPCallStackManager extends BaseCallstackManager { size = userCallstack.size(); if (size - 1 > 0) { CallStackUnit checkCallStackUnit = userCallstack - .get(size - 1); + .get(size - 1).getCallStackUnit(); if (checkCallStackUnit.getFunctionName().equals( LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC)) { userCallstack.remove(size - 1); @@ -194,27 +200,32 @@ public class SWAPCallStackManager extends BaseCallstackManager { size = userCallstack.size(); if (size > 0) { CallStackUnit prevCallstackUnit = userCallstack - .get(size - 1); + .get(size - 1).getCallStackUnit(); long prevSelfAddr = prevCallstackUnit .getFunctionStartAddr(); CallStackUnit callerCsa = addrMap.get(prevSelfAddr); if (null == callerCsa) { prevCallstackUnit.setAddr(prevSelfAddr); } else { - userCallstack.set(size - 1, callerCsa); + userCallstack.set(size - 1, new CallStackItem(callerCsa)); } } + for (int i = size - 1; i >= 0; i--) { + callstackData.getAddrs().add(userCallstack.get(i).getCallStackUnit().getAddr()); + } + getCallStackDataBySeqMap().put(seq, callstackData); + seqByTimeMap.put(time, seq); } else { System.out .println("makeUserCallstack : EXIT self is not the same as top of user callstack"); } - // if (AnalyzerManager.isOsp()) { + if (AnalyzerManager.isOsp()) { // String apiName = input[LogCenterConstants.APINAME_INDEX]; - // String apiName = log.getApiName(); - // if (apiName.equals("OspMain")) { //$NON-NLS-1$ - // LogParser.setDropCallTraceLog(true); - // } - // } + String apiName = log.getApiName(); + if (apiName.equals("OspMain")) { //$NON-NLS-1$ + SWAPLogParser.setDropCallTraceLog(true); + } + } } } @@ -249,7 +260,7 @@ public class SWAPCallStackManager extends BaseCallstackManager { String strCallerAddr = Long.toString(callerAddr); // System.out.println("tid :" + tid); - List probeCallstack = new ArrayList( + List probeCallstack = new ArrayList( getUserCallstack(tid)); // List probeCallstack = // getUserCallstack(tid); @@ -261,7 +272,7 @@ public class SWAPCallStackManager extends BaseCallstackManager { CallStackUnit callbackApi = new CallStackUnit( LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_ADDR, LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_SYMBOL, log); - probeCallstack.add(callbackApi); + probeCallstack.add(new CallStackItem(callbackApi)); if (addrMap .get(LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_ADDR) == null) { CallStackUnit defaultCallstackUnit = new CallStackUnit( @@ -285,10 +296,10 @@ public class SWAPCallStackManager extends BaseCallstackManager { addrMap.put(callerAddr, callerCallstackUnit); } - CallStackUnit topUserCallstack = probeCallstack.get(size - 1); + CallStackUnit topUserCallstack = probeCallstack.get(size - 1).getCallStackUnit(); if (callerCallstackUnit.getFunctionName().equals( topUserCallstack.getFunctionName())) { - probeCallstack.set(size - 1, callerCallstackUnit); + probeCallstack.set(size - 1, new CallStackItem(callerCallstackUnit)); } else { System.out .println("bug : probe caller is not the same as top of user callstack"); //$NON-NLS-1$ @@ -297,7 +308,7 @@ public class SWAPCallStackManager extends BaseCallstackManager { size = probeCallstack.size(); for (int i = size - 1; i >= 0; i--) { - callstackData.getAddrs().add(probeCallstack.get(i).getAddr()); + callstackData.getAddrs().add(probeCallstack.get(i).getCallStackUnit().getAddr()); } getCallStackDataBySeqMap().put(seq, callstackData); @@ -336,13 +347,13 @@ public class SWAPCallStackManager extends BaseCallstackManager { addrMap.put(selfAddr, selfCallstackUnit); } - List userCallstack = getUserCallstack(tid); + 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); + CallStackUnit topCallstackUnit = userCallstack.get(size - 1).getCallStackUnit(); if (topCallstackUnit.equals(selfCallstackUnit)) { DuplicateUserCall dupUserCall = dupUserCallMap.get(tid); if (null == dupUserCall) { @@ -353,8 +364,8 @@ public class SWAPCallStackManager extends BaseCallstackManager { selfCallstackUnit)) { dupUserCall.increaseDupCallCount(); } else { - // System.out - // .println("isIrregularUserCall : dup callstack check error"); //$NON-NLS-1$ + System.out + .println("isIrregularUserCall : dup callstack check error"); //$NON-NLS-1$ } } return true; @@ -369,8 +380,8 @@ public class SWAPCallStackManager extends BaseCallstackManager { dupUserCallMap.remove(tid); } } else { - // System.out - // .println("isIrregularUserCall : dup callstack check error"); //$NON-NLS-1$ + System.out + .println("isIrregularUserCall : dup callstack check error"); //$NON-NLS-1$ } return true; } @@ -385,6 +396,7 @@ public class SWAPCallStackManager extends BaseCallstackManager { userFunctionBin = null; userCallstackByTidMap.clear(); dupUserCallByTidMap.clear(); + seqTimeByTidMap.clear(); } } 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 696fff9..5cff06c 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 @@ -45,6 +45,7 @@ import org.tizen.dynamicanalyzer.communicator.DACommunicator; import org.tizen.dynamicanalyzer.handlers.ReplayTraceHandler; import org.tizen.dynamicanalyzer.handlers.StopHandler; import org.tizen.dynamicanalyzer.nl.AnalyzerLabels; +import org.tizen.dynamicanalyzer.project.PackageInfo; import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants; import org.tizen.dynamicanalyzer.swap.channel.data.LibraryObject; import org.tizen.dynamicanalyzer.swap.channel.data.ProcessInfo; @@ -174,6 +175,7 @@ public class MessageParser { List libObjs = pInfo.getLibObjs(); HashMap libHash = pInfo.getLibObjHash(); + System.out.println("LIBCOUNT :: " + dependantLibCount); for (int i = 0; i < dependantLibCount; i++) { LibraryObject libObj = new LibraryObject(); libObj.setPid(pid); @@ -190,6 +192,8 @@ public class MessageParser { libObj.setLibPath(libPath); libObjs.add(libObj); libHash.put(libPath, libObj); + System.out.println("LIBPATH :: (" + i + ") " + libPath + + "low : " + AnalyzerUtil.toHexdecimal(lowestAddr) + " high : " + AnalyzerUtil.toHexdecimal(highestAddr)); } DATime startTime = AnalyzerManager.getProject().getProfileStartTime(); @@ -220,6 +224,12 @@ public class MessageParser { pInfo.setMainTargetBinaryPath(targetBinaryPath); pInfo.setDepLibCount(dependantLibCount); + // User Call Trace : App is Tizen C++ or Tizen native + String applicationType = DACommunicator.getSelectedApp().getInfo(PackageInfo.APPTYPE_INDEX); + if(applicationType.contains(PackageInfo.APPTYPE_CPP)) { + SWAPLogParser.setDropCallTraceLog(true); + } + AnalyzerManager.setProcessInfoArrived(true); } 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 9ed6a12..c41ba9e 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 @@ -46,6 +46,7 @@ import org.tizen.dynamicanalyzer.swap.model.data.ReplayData; import org.tizen.dynamicanalyzer.swap.model.data.ScreenShotData; import org.tizen.dynamicanalyzer.swap.model.data.SystemData; import org.tizen.dynamicanalyzer.ui.page.BaseView; +import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler; import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea; import org.tizen.dynamicanalyzer.uirecorder.UIRecorderPlayThread; import org.tizen.dynamicanalyzer.uirecorder.UIRecorderTool; @@ -56,7 +57,9 @@ import org.tizen.sdblib.service.SyncResult; public class SWAPLogParser implements Runnable { private final String OSP_MAIN = "OspMain"; //$NON-NLS-1$ private static Thread logParser = null; - private static boolean dropCallTraceLog = true; +// default false, turn on when Tizen C++ app +// private static boolean dropCallTraceLog = true; + private static boolean dropCallTraceLog = false; private static LogQueue logQueue = null; private int SMALL_IMG_WIDTH = 40; @@ -79,13 +82,14 @@ public class SWAPLogParser implements Runnable { dropCallTraceLog = drop; } - public static boolean isDrapCallTraceLog() { + public static boolean isDropCallTraceLog() { return dropCallTraceLog; } public static void startLogParser() { getLogQueue().clear(); - dropCallTraceLog = true; +// why here? +// dropCallTraceLog = true; if (null == logParser || !logParser.isAlive()) { logParser = new Thread(null, new SWAPLogParser(), AnalyzerConstants.LOG_QUEUE_OBSERVING_THREAD); @@ -168,56 +172,61 @@ public class SWAPLogParser implements Runnable { if (!AnalyzerManager.isProcessInfoArrived()) { continue; } - ProfileData pData = (ProfileData) log; - String apiName = pData.getApiName(); - if (null == apiName || apiName.isEmpty() - || apiName.equals("_end")) { //$NON-NLS-1$ - // setFuncName(pData); - apiName = AnalyzerUtil.getFuncName(pData); - if (apiName.equals("")) { - continue; - } else { - pData.setApiName(apiName); + + if (id != DataChannelConstants.MSG_DATA_SAMPLE) { + ProfileData pData = (ProfileData) log; + String apiName = pData.getApiName(); + if (null == apiName || apiName.isEmpty() + || apiName.equals("_end")) { //$NON-NLS-1$ + // setFuncName(pData); + apiName = AnalyzerUtil.getFuncName(pData); + if (apiName.equals("")) { +// necessary? pData.setApiName(apiName); + continue; + } else { + pData.setApiName(apiName); + } } - } - - if (isDrapCallTraceLog()) { - apiName = pData.getApiName(); - if (apiName.contains(OSP_MAIN)) { - setDropCallTraceLog(false); - } else { + + if (isDropCallTraceLog()) { + apiName = pData.getApiName(); + if (apiName.contains(OSP_MAIN)) { + setDropCallTraceLog(false); + } else { + continue; + } + } + // irregular call check still necessary? + if (AnalyzerManager.getCallstackManager().isIrregularUserCall( + pData)) { continue; } + + ProcessInfoPackage processInfoPkg = AnalyzerManager + .getProject().getProcessInfo(pData.getPid()); + ProcessInfo processInfo = processInfoPkg.getProcessInfo(pData + .getTime()); + + System.out.println(" PROFILE LOG DEBUG = ID: " + + pData.getId() + + " PC : " + + AnalyzerUtil.toHexdecimal(pData.getPcAddr()) + + " Api : " + + pData.getApiName() + + " caller : " + + AnalyzerUtil.toHexdecimal(pData.getCallerPcAddr()) + + " base addr : " + + AnalyzerUtil.toHexdecimal(processInfo + .getLowestAddress())); + pushLog(log, logPack); + /* user callstack create by entry and exit */ + AnalyzerManager.getCallstackManager().makeUserCallstack( + pData, + FunctionUsageProfiler.getInstance() + .getProfileDataMaker()); + } else { + pushLog(log, logPack); } - - // if - // (AnalyzerManager.getCallstackManager().isIrregularUserCall( - // pData)) { - // continue; - // } - - ProcessInfoPackage processInfoPkg = AnalyzerManager - .getProject().getProcessInfo(pData.getPid()); - ProcessInfo processInfo = processInfoPkg.getProcessInfo(pData - .getTime()); - - System.out.println(" PROFILE LOG DEBUG = ID: " - + pData.getId() - + " PC : " - + AnalyzerUtil.toHexdecimal(pData.getPcAddr()) - + " Api : " - + pData.getApiName() - + " caller : " - + AnalyzerUtil.toHexdecimal(pData.getCallerPcAddr()) - + " base addr : " - + AnalyzerUtil.toHexdecimal(processInfo - .getLowestAddress())); - pushLog(log, logPack); - /* user callstack create by entry and exit */ - // AnalyzerManager.getCallstackManager().makeUserCallstack( - // pData, - // FunctionUsageProfiler.getInstance() - // .getProfileDataMaker()); } else if (log instanceof ReplayData) { pushLog(log, logPack); } else if (log instanceof ContextSwitchData) { @@ -246,8 +255,8 @@ public class SWAPLogParser implements Runnable { .put(imgInfo.getSeq(), imgInfo); } pushLog(log, logPack); - // AnalyzerManager.getCallstackManager() - // .makeCallstackWithoutBacktrace(log); + AnalyzerManager.getCallstackManager() + .makeCallstackWithoutBacktrace(log); if (id == DataChannelConstants.MSG_PROBE_FILE || id == DataChannelConstants.MSG_PROBE_MEMORY) { AnalyzerManager.getLeakDetector().runLeakDectect(log); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/callstack/CallStackItem.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/callstack/CallStackItem.java new file mode 100644 index 0000000..d969c80 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/callstack/CallStackItem.java @@ -0,0 +1,51 @@ +/* + * Dynamic Analyzer + * + * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * WooJin Jung + * 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.ui.info.callstack; + +public class CallStackItem { + protected long startTime; + protected CallStackUnit callstackUnit; + + public CallStackItem(CallStackUnit CallstackUnit) { + callstackUnit = CallstackUnit; + startTime = -1; + } + + public CallStackItem(CallStackUnit CallstackUnit, long time) { + callstackUnit = CallstackUnit; + startTime = time; + } + + public long getStartTime() { + return startTime; + } + + public CallStackUnit getCallStackUnit() { + return callstackUnit; + } + +} \ No newline at end of file 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 cbaa227..f2d70e3 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 @@ -82,7 +82,7 @@ public class CallStackManager extends BaseCallstackManager { // insert call count profiler.makeFupDataForCallTrace(selfCallstackUnit, log); - List userCallstack = getUserCallstack(tid); + List userCallstack = getUserCallstack(tid); int size = userCallstack.size(); CallStackUnit callerCallstackUnit = addrMap.get(callerAddr); @@ -100,14 +100,14 @@ public class CallStackManager extends BaseCallstackManager { int eventType = log.getType(); if (eventType == LogCenterConstants.USER_FUNCTION_EVENT_TYPE_ENTER) { if (size == 0) { - userCallstack.add(selfCallstackUnit); + userCallstack.add(new CallStackItem(selfCallstackUnit)); } else { if (!AnalyzerManager.isInBinaryRange(callerAddr)) { CallStackUnit callbackApi = new CallStackUnit( LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_ADDR, LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_SYMBOL, log); - userCallstack.add(callbackApi); + userCallstack.add(new CallStackItem(callbackApi)); if (addrMap .get(LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_ADDR) == null) { CallStackUnit defaultCallstackUnit = new CallStackUnit( @@ -124,7 +124,7 @@ public class CallStackManager extends BaseCallstackManager { LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_ADDR, LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_SYMBOL, log); - userCallstack.add(callbackApi); + userCallstack.add(new CallStackItem(callbackApi)); if (addrMap .get(LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_ADDR) == null) { CallStackUnit defaultCallstackUnit = new CallStackUnit( @@ -135,24 +135,24 @@ public class CallStackManager extends BaseCallstackManager { LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_ADDR, defaultCallstackUnit); } - userCallstack.add(callerCallstackUnit); + userCallstack.add(new CallStackItem(callerCallstackUnit)); } else { CallStackUnit callerCsa = addrMap.get(callerAddr); if (null == callerCsa) { - callerCsa = userCallstack.get(size - 1); + callerCsa = userCallstack.get(size - 1).getCallStackUnit(); callerCsa.setFunctionStartAddr(callerCsa.getAddr()); callerCsa.setAddr(callerAddr); } else { callerCsa.setFunctionStartAddr(userCallstack.get( - size - 1).getAddr()); - userCallstack.set(size - 1, callerCsa); + size - 1).getCallStackUnit().getAddr()); + userCallstack.set(size - 1, new CallStackItem(callerCsa)); } } - userCallstack.add(selfCallstackUnit); + userCallstack.add(new CallStackItem(selfCallstackUnit)); } size = userCallstack.size(); for (int i = size - 1; i >= 0; i--) { - callstackData.getAddrs().add(userCallstack.get(i).getAddr()); + callstackData.getAddrs().add(userCallstack.get(i).getCallStackUnit().getAddr()); } getCallStackDataBySeqMap().put(seq, callstackData); } else if (eventType == LogCenterConstants.USER_FUNCTION_EVENT_TYPE_EXIT) { @@ -160,7 +160,7 @@ public class CallStackManager extends BaseCallstackManager { // this case only range profiling, other time is bug return; } - CallStackUnit removeCallStackUnit = userCallstack.get(size - 1); + CallStackUnit removeCallStackUnit = userCallstack.get(size - 1).getCallStackUnit(); if (selfCallstackUnit.getFunctionName().equals( removeCallStackUnit.getFunctionName())) { userCallstack.remove(size - 1); @@ -168,7 +168,7 @@ public class CallStackManager extends BaseCallstackManager { if (callerCallstackUnit.getFunctionName().contains( AnalyzerConstants.VIRTUAL_THUNK)) { if (callerCallstackUnit.getFunctionName().equals( - userCallstack.get(size - 2).getFunctionName())) { + userCallstack.get(size - 2).getCallStackUnit().getFunctionName())) { userCallstack.remove(size - 2); } else { System.out @@ -180,7 +180,7 @@ public class CallStackManager extends BaseCallstackManager { size = userCallstack.size(); if (size - 1 > 0) { CallStackUnit checkCallStackUnit = userCallstack - .get(size - 1); + .get(size - 1).getCallStackUnit(); if (checkCallStackUnit.getFunctionName().equals( LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC)) { userCallstack.remove(size - 1); @@ -189,14 +189,14 @@ public class CallStackManager extends BaseCallstackManager { size = userCallstack.size(); if (size > 0) { CallStackUnit prevCallstackUnit = userCallstack - .get(size - 1); + .get(size - 1).getCallStackUnit(); long prevSelfAddr = prevCallstackUnit .getFunctionStartAddr(); CallStackUnit callerCsa = addrMap.get(prevSelfAddr); if (null == callerCsa) { prevCallstackUnit.setAddr(prevSelfAddr); } else { - userCallstack.set(size - 1, callerCsa); + userCallstack.set(size - 1, new CallStackItem(callerCsa)); } } } else { @@ -250,7 +250,7 @@ public class CallStackManager extends BaseCallstackManager { } String strCallerAddr = Long.toString(callerAddr); - List probeCallstack = new ArrayList( + List probeCallstack = new ArrayList( getUserCallstack(tid)); int size = probeCallstack.size(); @@ -260,7 +260,7 @@ public class CallStackManager extends BaseCallstackManager { CallStackUnit callbackApi = new CallStackUnit( LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_ADDR, LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_SYMBOL, log); - probeCallstack.add(callbackApi); + probeCallstack.add(new CallStackItem(callbackApi)); if (addrMap .get(LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_ADDR) == null) { CallStackUnit defaultCallstackUnit = new CallStackUnit( @@ -284,10 +284,10 @@ public class CallStackManager extends BaseCallstackManager { addrMap.put(callerAddr, callerCallstackUnit); } - CallStackUnit topUserCallstack = probeCallstack.get(size - 1); + CallStackUnit topUserCallstack = probeCallstack.get(size - 1).getCallStackUnit(); if (callerCallstackUnit.getFunctionName().equals( topUserCallstack.getFunctionName())) { - probeCallstack.set(size - 1, callerCallstackUnit); + probeCallstack.set(size - 1, new CallStackItem(callerCallstackUnit)); } else { System.out .println("bug : probe caller is not the same as top of user callstack"); //$NON-NLS-1$ @@ -296,7 +296,7 @@ public class CallStackManager extends BaseCallstackManager { size = probeCallstack.size(); for (int i = size - 1; i >= 0; i--) { - callstackData.getAddrs().add(probeCallstack.get(i).getAddr()); + callstackData.getAddrs().add(probeCallstack.get(i).getCallStackUnit().getAddr()); } getCallStackDataBySeqMap().put(seq, callstackData); @@ -336,13 +336,13 @@ public class CallStackManager extends BaseCallstackManager { addrMap.put(selfAddr, selfCallstackUnit); } - List userCallstack = getUserCallstack(tid); + List userCallstack = getUserCallstack(tid); int size = userCallstack.size(); int eventType = input.getType(); if (size > 0) { if (eventType == LogCenterConstants.USER_FUNCTION_EVENT_TYPE_ENTER) { - CallStackUnit topCallstackUnit = userCallstack.get(size - 1); + CallStackUnit topCallstackUnit = userCallstack.get(size - 1).getCallStackUnit(); if (topCallstackUnit.equals(selfCallstackUnit)) { DuplicateUserCall dupUserCall = dupUserCallMap.get(tid); if (null == dupUserCall) { @@ -353,8 +353,8 @@ public class CallStackManager extends BaseCallstackManager { selfCallstackUnit)) { dupUserCall.increaseDupCallCount(); } else { - // System.out - // .println("isIrregularUserCall : dup callstack check error"); //$NON-NLS-1$ + System.out + .println("isIrregularUserCall : dup callstack check error"); //$NON-NLS-1$ } } return true; @@ -369,8 +369,8 @@ public class CallStackManager extends BaseCallstackManager { dupUserCallMap.remove(tid); } } else { - // System.out - // .println("isIrregularUserCall : dup callstack check error"); //$NON-NLS-1$ + System.out + .println("isIrregularUserCall : dup callstack check error"); //$NON-NLS-1$ } return true; } @@ -385,6 +385,7 @@ public class CallStackManager extends BaseCallstackManager { userFunctionBin = null; userCallstackByTidMap.clear(); dupUserCallByTidMap.clear(); + seqTimeByTidMap.clear(); } } 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 893d272..6d537d6 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 @@ -32,15 +32,28 @@ import static org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants.M import java.util.ArrayList; import java.util.HashMap; import java.util.List; +import java.util.TreeMap; import org.tizen.dynamicanalyzer.common.AnalyzerConstants; +import org.tizen.dynamicanalyzer.common.AnalyzerManager; import org.tizen.dynamicanalyzer.common.AnalyzerPaths; +import org.tizen.dynamicanalyzer.common.SymbolManager; +import org.tizen.dynamicanalyzer.communicator.DACommunicator; import org.tizen.dynamicanalyzer.logparser.LogCenterConstants; +import org.tizen.dynamicanalyzer.nl.InformationViewLabels; import org.tizen.dynamicanalyzer.swap.callstack.BaseCallstackManager; +import org.tizen.dynamicanalyzer.swap.channel.control.BinaryInfo; +import org.tizen.dynamicanalyzer.swap.channel.data.LibraryObject; +import org.tizen.dynamicanalyzer.swap.channel.data.ProcessInfo; +import org.tizen.dynamicanalyzer.swap.channel.data.ProcessInfoPackage; import org.tizen.dynamicanalyzer.swap.model.data.LogData; import org.tizen.dynamicanalyzer.swap.model.data.ProfileData; import org.tizen.dynamicanalyzer.swap.model.data.UserFunctionData; +import org.tizen.dynamicanalyzer.swap.platform.BinarySettingManager; +import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackData; +import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackItem; import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackUnit; +import org.tizen.dynamicanalyzer.utils.AnalyzerUtil; import org.tizen.dynamicanalyzer.utils.Formatter; public class ProfileDataMaker { @@ -179,9 +192,15 @@ public class ProfileDataMaker { double rate = 0.; if (exclusive) { count = data.getExCount(); + if(totalSampleCount == 0) { + rate = 0; + } rate = count / (double) totalSampleCount * 100; } else { count = data.getInCount(); + if(totalSampleCount == 0) { + rate = 0; + } rate = count / (double) totalSampleCount * 100; } @@ -229,25 +248,194 @@ public class ProfileDataMaker { } } + public String getSamplePCSymbol(ProfileData sampleLog) { + String functionName = null; + String symbol = null; + long pcAddr = sampleLog.getPcAddr(); + ProcessInfoPackage processInfoPkg = AnalyzerManager + .getProject().getProcessInfo(sampleLog.getPid()); + ProcessInfo processInfo = processInfoPkg.getProcessInfo(sampleLog + .getTime()); + + if (pcAddr >= processInfo.getLowestAddress() + && pcAddr <= processInfo.getHighestAddress()) { // application binary + String baseAddr = Long.toString(processInfo.getLowestAddress()); + String pcStr = Long.toString(pcAddr); + BinaryInfo binInfo = DACommunicator.getSelectedApp() + .getMainBinaryInfo(); + String localPath = binInfo.getSourceBinaryPath(); + boolean isPieBuild = true; + if (binInfo.getType() != 1) { + isPieBuild = false; + } + functionName = SymbolManager.addr2func(localPath, pcStr, isPieBuild, + baseAddr); + if (null == functionName || functionName.isEmpty() + || functionName.equals("_end")) { //$NON-NLS-1$ + functionName = InformationViewLabels.CALLSTACK_TABLE_UNKNOWN_FUNCTION; +// ApiNameManager.getApiId(functionName); + } else { + String prevFunctionName = functionName; + functionName = SymbolManager + .demanglingFunctionName(prevFunctionName); +// ApiNameManager.getApiId(functionName); + } + // need to be checked again - in case pid is not main application + symbol = callstackManager.getUserFunctionPosition() + + AnalyzerConstants.CALLSTACK_API_TOKEN_STRING + + functionName; + } else { + HashMap binInfoMap = BinarySettingManager + .getInstance().getTargetBinInfoMap(); +// List binPaths = new ArrayList(); +// binPaths.addAll(binInfoMap.keySet()); + + List libObjs = processInfo.getLibObjs(); +// HashMap libHash = processInfo +// .getLibObjHash(); + LibraryObject libraryObject = null; + int size = libObjs.size(); + for (int i = 0; i < size; i++) { +// String binPath = binPaths.get(i); + LibraryObject libObj = libObjs.get(i); +// if (null == libObj) { +// continue; +// } + long lowAddr = libObj.getLowestAddress(); + long highAddr = libObj.getHighestAddress(); + + /** for debug */ +/* if (lowAddr > pcAddr || highAddr < pcAddr) { + System.out.print(sampleLog.getId() + + "lib : " + libObj.getLibPath() + " ==> "); + AnalyzerUtil.printHexdecimal(lowAddr); + System.out.print(" < "); + AnalyzerUtil.printHexdecimal(pcAddr); + System.out.print(" < "); + AnalyzerUtil.printHexdecimal(highAddr); + System.out.println(); + } +*/ + if (pcAddr >= lowAddr && pcAddr <= highAddr) { + libraryObject = libObj; + break; + } + else { +// System.out.print(sampleLog.getId() +// + "lib : " + libObj.getLibPath() + " ==> "); +// AnalyzerUtil.printHexdecimal(lowAddr); +// System.out.print(" < "); +// AnalyzerUtil.printHexdecimal(pcAddr); +// System.out.print(" < "); +// AnalyzerUtil.printHexdecimal(highAddr); +// System.out.println(); + } + } + if (null != libraryObject) { + String path = libraryObject.getLibPath(); + BinaryInfo binInfo = binInfoMap.get(path); + if (null != binInfo) { + String localPath = binInfo.getSourceBinaryPath(); + String baseAddr = Long.toString(libraryObject + .getLowestAddress()); + String pcStr = Long.toString(pcAddr); + boolean isPieBuild = true; + if (binInfo.getType() != 1) { + isPieBuild = false; + } + functionName = SymbolManager.addr2func(localPath, pcStr, + isPieBuild, baseAddr); + if (null == functionName || functionName.isEmpty() + || functionName.equals("_end")) { //$NON-NLS-1$ + functionName = InformationViewLabels.CALLSTACK_TABLE_UNKNOWN_FUNCTION; +// ApiNameManager.getApiId(functionName); + } else { + String prevFunctionName = functionName; + functionName = SymbolManager + .demanglingFunctionName(prevFunctionName); +// ApiNameManager.getApiId(functionName); + } + // need to be checked again - in case pid is not main application + } else { + functionName = InformationViewLabels.CALLSTACK_TABLE_UNKNOWN_FUNCTION; + } + symbol = path + AnalyzerConstants.CALLSTACK_API_TOKEN_STRING + + functionName; + } else { + System.out + .println("binary for the sample pc is not found :" + AnalyzerUtil.toHexdecimal(pcAddr)); //$NON-NLS-1$ + symbol = InformationViewLabels.CALLSTACK_TABLE_UNKNOWN_LIBRARY + + AnalyzerConstants.CALLSTACK_API_TOKEN_STRING + + AnalyzerUtil.toHexdecimal(pcAddr); +// + InformationViewLabels.CALLSTACK_TABLE_UNKNOWN_FUNCTION; + } + } + + AnalyzerManager.getFuncNameMap().put(pcAddr, functionName); + return symbol; + } + public void makeFunctionUsageProfileData(ProfileData sampleLog) { totalSampleCount++; - String callstack = sampleLog.getCallstack(); - if (null == callstack) { - return; - } - String[] splitCallstack = callstack - .split(AnalyzerConstants.DATA_PARSING_TOKEN); - - List sampleCallstack = new ArrayList(); + List addrs = null; + long selfAddr = sampleLog.getPcAddr(); + + if(DACommunicator.isSWAPVersion()) { + int seq; + int tid = sampleLog.getTid(); + long sampleTime = sampleLog.getTime(); + long callstackTime; + Long longTime = null; + CallStackData callstackData; + TreeMap seqByTimeMap = callstackManager.getSeqTimeByTidMap(tid); + HashMap addrMap = callstackManager + .getCallStackApiByAddrMap(); + + CallStackUnit callstackUnit = addrMap.get(selfAddr); + if (null == callstackUnit) { + CallStackUnit newCallstackUnit = new CallStackUnit(selfAddr, + getSamplePCSymbol(sampleLog), sampleLog); + addrMap.put(selfAddr, newCallstackUnit); + } + + longTime = seqByTimeMap.floorKey(sampleTime); + if(null != longTime) { + callstackTime = longTime.longValue(); + seq = seqByTimeMap.get(callstackTime); + callstackData = callstackManager.getCallStackDataBySeqMap().get(seq); + addrs = new ArrayList(callstackData.getAddrs()); + for(int i = 0; i < addrs.size(); i++) { + if(addrs.get(i) == 0) { + addrs.remove(i); + } + } + addrs.add(0, selfAddr); + } else { + System.out + .println("makeFunctionUsageProfileData : cannot find seq by time"); + addrs = new ArrayList(); + addrs.add(selfAddr); + } - for (int i = 0; i < splitCallstack.length; i++) { - sampleCallstack.add(new String(splitCallstack[i])); + } else { + String callstack = sampleLog.getCallstack(); + if (null == callstack) { + return; + } + String[] splitCallstack = callstack + .split(AnalyzerConstants.DATA_PARSING_TOKEN); + + List sampleCallstack = new ArrayList(); + + for (int i = 0; i < splitCallstack.length; i++) { + sampleCallstack.add(new String(splitCallstack[i])); + } + + addrs = makeCallstackHashAndList(sampleCallstack, sampleLog); } - - List addrs = makeCallstackHashAndList(sampleCallstack, sampleLog); + HashMap addrMap = callstackManager .getCallStackApiByAddrMap(); - long selfAddr = sampleLog.getPcAddr(); CallStackUnit inputData = addrMap.get(selfAddr); if (null == inputData) { return; @@ -413,10 +601,21 @@ public class ProfileDataMaker { public void makeFupDataForCallTrace(CallStackUnit inputCallstackApiData, UserFunctionData log) { - totalSampleCount++; long exeTime = 0; int type = log.getType(); + int tid = log.getTid(); + List userCallstack = callstackManager.getUserCallstack(tid); + int size = userCallstack.size(); + if (type == LogCenterConstants.USER_FUNCTION_EVENT_TYPE_EXIT) { + if(size == 0 || + !userCallstack.get(size - 1).getCallStackUnit() + .getFunctionName().equals(inputCallstackApiData.getFunctionName())) { + System.out + .println("exit without entry or EXIT self is not the same as top of user callstack :" + + inputCallstackApiData.getFunctionName()); //$NON-NLS-1$ + return; + } exeTime += log.getElapsedTime(); } @@ -429,7 +628,6 @@ public class ProfileDataMaker { ProfilingData child = makeNewProfilingData(inputCallstackApiData, false); parent.addChild(child); - child.addExCount(); child.addElpasedTime(exeTime); child.setParent(parent.getName()); @@ -444,7 +642,6 @@ public class ProfileDataMaker { parent.addChild(child); child.setParent(parent.getName()); } - child.addExCount(); child.addElpasedTime(exeTime); if (type != LogCenterConstants.USER_FUNCTION_EVENT_TYPE_EXIT) { child.addCallCount(); @@ -480,12 +677,30 @@ 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(); - } + int tid = log.getTid(); + long time = log.getTime(); + long startTime; + + List userCallstack = callstackManager.getUserCallstack(tid); + int size = userCallstack.size(); + + if (type == MSG_FUNCTION_EXIT) { + if(size == 0 || + !userCallstack.get(size - 1).getCallStackUnit() + .getFunctionName().equals(inputCallstackApiData.getFunctionName())) { + System.out + .println("exit without entry or EXIT self is not the same as top of user callstack :" + + inputCallstackApiData.getFunctionName()); //$NON-NLS-1$ + return; + } + startTime = userCallstack.get(size - 1).getStartTime(); + if(startTime != -1) { + exeTime += time - startTime; + // exeTime += log.getElapsedTime(); + } + } ProfilingData parent = getProfilingDataByKey(inputCallstackApiData .getPath()); @@ -496,7 +711,6 @@ public class ProfileDataMaker { ProfilingData child = makeNewProfilingData(inputCallstackApiData, false); parent.addChild(child); - child.addExCount(); child.addElpasedTime(exeTime); child.setParent(parent.getName()); @@ -511,7 +725,6 @@ public class ProfileDataMaker { parent.addChild(child); child.setParent(parent.getName()); } - child.addExCount(); child.addElpasedTime(exeTime); if (type != MSG_FUNCTION_EXIT) { child.addCallCount(); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/utils/AnalyzerUtil.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/utils/AnalyzerUtil.java index 3d98af6..29813af 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/utils/AnalyzerUtil.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/utils/AnalyzerUtil.java @@ -1121,8 +1121,9 @@ public class AnalyzerUtil { public static String getBinarySourcePath(int pid, long time) { String localBinPath = AnalyzerUtil.getProcessLocalBinaryPath(pid, time); + String key = getTargetPathKey(localBinPath); BinaryInfo binInfo = DACommunicator.getSelectedApp().getBinaryInfo( - localBinPath); + key); String sourceBinPath = binInfo.getSourceBinaryPath(); return sourceBinPath; } @@ -1253,8 +1254,8 @@ public class AnalyzerUtil { if (null != libraryObject) { String path = libraryObject.getLibPath(); BinaryInfo binInfo = binInfoMap.get(path); - String localPath = binInfo.getSourceBinaryPath(); if (null != binInfo) { + String localPath = binInfo.getSourceBinaryPath(); String baseAddr = Long.toString(libraryObject .getLowestAddress()); String pcStr = Long.toString(pcAddr); -- 2.7.4