From: greatim Date: Fri, 30 Jan 2015 10:55:37 +0000 (+0900) Subject: INTERNAL: refactor host state management and trace start/stop management X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fchanges%2F77%2F34677%2F2;p=sdk%2Ftools%2Fdynamic-analyzer.git INTERNAL: refactor host state management and trace start/stop management refactor host state management refactor trace start / stop management refactor some lod data models refactor AnalyzerManager, DAResult, etc. remove unnecessary files Change-Id: Ieda51365c24c5a97b3df6716303a3a7cd99d08f8 Signed-off-by: greatim --- diff --git a/org.tizen.dynamicanalyzer.common/META-INF/MANIFEST.MF b/org.tizen.dynamicanalyzer.common/META-INF/MANIFEST.MF index e389bab..d006d9e 100644 --- a/org.tizen.dynamicanalyzer.common/META-INF/MANIFEST.MF +++ b/org.tizen.dynamicanalyzer.common/META-INF/MANIFEST.MF @@ -8,7 +8,8 @@ Require-Bundle: org.eclipse.ui, org.eclipse.core.runtime Bundle-ActivationPolicy: lazy Bundle-RequiredExecutionEnvironment: JavaSE-1.6 -Export-Package: org.tizen.dynamicanalyzer.callback, +Export-Package: org.tizen.dynamicanalyzer.annotation, + org.tizen.dynamicanalyzer.callback, org.tizen.dynamicanalyzer.constant, org.tizen.dynamicanalyzer.model, org.tizen.dynamicanalyzer.util diff --git a/org.tizen.dynamicanalyzer.common/src/org/tizen/dynamicanalyzer/annotation/FutureUse.java b/org.tizen.dynamicanalyzer.common/src/org/tizen/dynamicanalyzer/annotation/FutureUse.java new file mode 100644 index 0000000..8b74145 --- /dev/null +++ b/org.tizen.dynamicanalyzer.common/src/org/tizen/dynamicanalyzer/annotation/FutureUse.java @@ -0,0 +1,16 @@ +/** + * + */ +package org.tizen.dynamicanalyzer.annotation; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +/** + * @author greatim + * this annotation can be used for future using definition + */ +@Retention(RetentionPolicy.SOURCE) +public @interface FutureUse { + +} diff --git a/org.tizen.dynamicanalyzer.common/src/org/tizen/dynamicanalyzer/annotation/UIMethod.java b/org.tizen.dynamicanalyzer.common/src/org/tizen/dynamicanalyzer/annotation/UIMethod.java new file mode 100644 index 0000000..737e3c5 --- /dev/null +++ b/org.tizen.dynamicanalyzer.common/src/org/tizen/dynamicanalyzer/annotation/UIMethod.java @@ -0,0 +1,18 @@ +/** + * + */ +package org.tizen.dynamicanalyzer.annotation; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * @author greatim + * This annotation should be used for UI method only + */ +@Retention(RetentionPolicy.RUNTIME) +@Target(ElementType.METHOD) +public @interface UIMethod { +} diff --git a/org.tizen.dynamicanalyzer.common/src/org/tizen/dynamicanalyzer/util/ByteUtil.java b/org.tizen.dynamicanalyzer.common/src/org/tizen/dynamicanalyzer/util/ByteUtil.java index 320ef67..6ef46cd 100755 --- a/org.tizen.dynamicanalyzer.common/src/org/tizen/dynamicanalyzer/util/ByteUtil.java +++ b/org.tizen.dynamicanalyzer.common/src/org/tizen/dynamicanalyzer/util/ByteUtil.java @@ -221,10 +221,8 @@ public class ByteUtil { // remove EOS public static String getString(byte[] data, int start) { - int length = getStringLength(data, start)-1; - byte[] temp = new byte[length]; - System.arraycopy(data, start, temp, 0, length); - String str = new String(temp); + int length = getStringLength(data, start) - 1; + String str = new String(data, start, length); return str; } diff --git a/org.tizen.dynamicanalyzer.common/test/src/org/tizen/dynamicanalyzer/common/ExecutionCallbackManagerTest.java b/org.tizen.dynamicanalyzer.common/test/src/org/tizen/dynamicanalyzer/common/ExecutionCallbackManagerTest.java index 9381179..acf6175 100644 --- a/org.tizen.dynamicanalyzer.common/test/src/org/tizen/dynamicanalyzer/common/ExecutionCallbackManagerTest.java +++ b/org.tizen.dynamicanalyzer.common/test/src/org/tizen/dynamicanalyzer/common/ExecutionCallbackManagerTest.java @@ -26,14 +26,19 @@ package org.tizen.dynamicanalyzer.common; +import static org.mockito.Matchers.anyString; +import static org.mockito.Mockito.atLeast; +import static org.mockito.Mockito.atLeastOnce; +import static org.mockito.Mockito.atMost; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; + import org.junit.Test; import org.tizen.dynamicanalyzer.callback.ExecutionCallbackManager; import org.tizen.dynamicanalyzer.callback.IExecutionCallback; import org.tizen.dynamicanalyzer.unittest.UnitTestUtil; -import static org.mockito.Mockito.*; -import static org.mockito.Matchers.*; - public class ExecutionCallbackManagerTest { diff --git a/org.tizen.dynamicanalyzer.common/test/src/org/tizen/dynamicanalyzer/util/ByteUtilTest.java b/org.tizen.dynamicanalyzer.common/test/src/org/tizen/dynamicanalyzer/util/ByteUtilTest.java index b68c029..2231061 100644 --- a/org.tizen.dynamicanalyzer.common/test/src/org/tizen/dynamicanalyzer/util/ByteUtilTest.java +++ b/org.tizen.dynamicanalyzer.common/test/src/org/tizen/dynamicanalyzer/util/ByteUtilTest.java @@ -26,14 +26,14 @@ package org.tizen.dynamicanalyzer.util; import static java.lang.System.currentTimeMillis; -import static org.junit.Assert.*; +import static org.junit.Assert.assertEquals; import java.util.ArrayList; import java.util.Random; + import org.junit.Test; import org.tizen.dynamicanalyzer.unittest.UnitTestConstants; import org.tizen.dynamicanalyzer.unittest.UnitTestUtil; -import org.tizen.dynamicanalyzer.util.ByteUtil; public class ByteUtilTest { diff --git a/org.tizen.dynamicanalyzer.common/test/src/org/tizen/dynamicanalyzer/util/UnitTestUtilTest.java b/org.tizen.dynamicanalyzer.common/test/src/org/tizen/dynamicanalyzer/util/UnitTestUtilTest.java index 49e9a4c..faa2ea0 100644 --- a/org.tizen.dynamicanalyzer.common/test/src/org/tizen/dynamicanalyzer/util/UnitTestUtilTest.java +++ b/org.tizen.dynamicanalyzer.common/test/src/org/tizen/dynamicanalyzer/util/UnitTestUtilTest.java @@ -25,7 +25,7 @@ package org.tizen.dynamicanalyzer.util; -import static org.junit.Assert.*; +import static org.junit.Assert.assertEquals; import org.junit.Test; import org.tizen.dynamicanalyzer.unittest.UnitTestConstants; diff --git a/org.tizen.dynamicanalyzer.workbench/src/org/tizen/dynamicanalyzer/util/WorkbenchUtil.java b/org.tizen.dynamicanalyzer.workbench/src/org/tizen/dynamicanalyzer/util/WorkbenchUtil.java index b6cc971..3257c23 100644 --- a/org.tizen.dynamicanalyzer.workbench/src/org/tizen/dynamicanalyzer/util/WorkbenchUtil.java +++ b/org.tizen.dynamicanalyzer.workbench/src/org/tizen/dynamicanalyzer/util/WorkbenchUtil.java @@ -31,6 +31,7 @@ import org.eclipse.ui.IWorkbenchPage; import org.eclipse.ui.IWorkbenchWindow; import org.eclipse.ui.PlatformUI; import org.eclipse.ui.part.ViewPart; +import org.tizen.dynamicanalyzer.annotation.UIMethod; import org.tizen.dynamicanalyzer.constant.CommonConstants; public class WorkbenchUtil { @@ -60,6 +61,7 @@ public class WorkbenchUtil { } } + @UIMethod public static ViewPart getViewPart(String id) { ViewPart viewpart = null; IWorkbenchWindow window = getWorkbenchWindow(); diff --git a/org.tizen.dynamicanalyzer/plugin.xml b/org.tizen.dynamicanalyzer/plugin.xml index 53188dd..4e7dce8 100644 --- a/org.tizen.dynamicanalyzer/plugin.xml +++ b/org.tizen.dynamicanalyzer/plugin.xml @@ -61,7 +61,7 @@ commandId="org.tizen.dynamicanalyzer.handlers.OpenTraceHandler"> > funcIDMapByPid = null; + private static boolean exit = false; + private static boolean running = false; + + private static boolean processInfoArrived = false; + private static boolean terminateMsgArrived = false; // set by message parser + private static boolean dataSocketClosed = false; // set by data channel thread private static NewLeakDetector newLeakDetector = new NewLeakDetector(); private static WarningChecker warningChecker = new WarningChecker(); private static SWAPCallStackManager swapCallstackManager = new SWAPCallStackManager(false); - private static Timer screenshotTimer = null; - - private static boolean appInfoArrived = false; - private static boolean isHaveSampleThread = false; - private static boolean exit = false; - - private static long startBinaryAddr = -1; - private static long endBinaryAddr = -1; + public static boolean isPlatformSDK() { + return isPlatformSDK; + } - private static int processCount = 0; + public static void setPlatformSDK(boolean platform) { + isPlatformSDK = platform; + } public static boolean isExit() { return exit; } - public static void setExit(boolean e) { - exit = e; + public static void setExit(boolean ex) { + exit = ex; } - // theme deprecated - // public static void setTheme(DATheme t) { - // theme = t; - // ColorResources.initColors(); - // - // // redraw all widgets! - // } + public static boolean isRunning() { + return running; + } - public static boolean hasSampleThread() { - return isHaveSampleThread; + public static void setRunningState(boolean isRunning) { + running = isRunning; } - public static void setSampleThread(boolean b) { - isHaveSampleThread = b; + public static boolean isProcessInfoArrived() { + return processInfoArrived; } - public static boolean isBinStartEndSet() { - if ((startBinaryAddr > 0) && (endBinaryAddr > 0)) { - return true; - } - return false; + public static void setProcessInfoArrived(boolean arrived) { + processInfoArrived = arrived; } - public static void setBinaryStartEndAddr(long start, long end) { - startBinaryAddr = start; - endBinaryAddr = end; + public static boolean isTerminateMsgArrived() { + return terminateMsgArrived; } - public static boolean isInBinaryRange(long addr) { - if (addr > endBinaryAddr || addr < startBinaryAddr) { - return false; - } - return true; + public static void setTerminateMsgArrived(boolean arrived) { + terminateMsgArrived = arrived; } - public static void clear() { - Project project = Global.getProject(); - if (null != project) { - synchronized (project) { - if (!project.isValid()) { - String sourcePath = project.getSavePath(); - if (null != sourcePath && !sourcePath.isEmpty()) { - boolean success = AnalyzerUtil.deleteFile(new File(sourcePath)); - if (success) { - // logs for debug - Logger.debug("invalid project deleted!"); //$NON-NLS-1$ - } else { - Logger.debug("invalid project delete fail..."); //$NON-NLS-1$ - } - } - } - project.dispose(); - Global.setProject(null); - } - } + public static boolean isDataSocketClosed() { + return dataSocketClosed; + } - newLeakDetector.clear(); - warningChecker.clear(); - swapCallstackManager.clear(); - isHaveSampleThread = false; - isLogParsingComplete = false; - StopProcessManager.clear(); - // UserFunctionManager.getInstance().clear(); - LogDataFactory.clean(); - FunctionUsageProfiler.getInstance().clear(); - FunctionUsageProfiler.getInstance().stopThread(); - ProfilingData.clear(); // reset internal sequence number - RangeDataManager.getInstance().initRange(); - startBinaryAddr = -1; - endBinaryAddr = -1; - appInfoArrived = false; - if (funcIDMapByPid != null) - funcIDMapByPid.clear(); - processCount = 0; + public static void setDataSocketClosed(boolean closed) { + dataSocketClosed = closed; } public static NewLeakDetector getNewLeakDetector() { @@ -177,120 +124,48 @@ public class AnalyzerManager { } } - // if (DACommunicator.isSWAPVersion()) { return swapCallstackManager; - // } } - public static void initTraceStart() { - AnalyzerUtil.executeCommand(ClearHandler.ID); - if (!AnalyzerManager.isExit()) { - Project project = new Project(); - project.initForTrace(); - Logger.performance("TEST", "Start Trace", "Create and Initialize Project data"); - } + public static void clear() { + processInfoArrived = false; + terminateMsgArrived = false; - if (!AnalyzerManager.isExit()) { - AnalyzerUtil.executeCommand(StartHandler.ID); - Logger.performance("TEST", "Start Trace", "Execute command - StartHandler"); - } + newLeakDetector.clear(); + warningChecker.clear(); + swapCallstackManager.clear(); + // UserFunctionManager.getInstance().clear(); + FunctionUsageProfiler.getInstance().clear(); + FunctionUsageProfiler.getInstance().stopNormal(); + ProfilingData.clear(); // reset internal sequence number + RangeDataManager.getInstance().initRange(); } + @FutureUse public static boolean isOsp() { - // FIXME // if (AnalyzerUtil.isPieBuild(pid)) { // return true; // } return false; } - public static void setProcessInfoArrived(boolean arrived) { - appInfoArrived = arrived; - } - - public static boolean isProcessInfoArrived() { - return appInfoArrived; - } - + @UIMethod public static DAPageComposite getCurrentPage() { BaseView bv = (BaseView) WorkbenchUtil.getViewPart(BaseView.ID); return bv.getTopComposite(); } + @UIMethod public static boolean isVisibleView(String viewId) { BaseView bv = (BaseView) WorkbenchUtil.getViewPart(BaseView.ID); DABaseComposite tabView = bv.getMainTab().getView(viewId); return tabView.getVisible(); } + @UIMethod public static void updateView(String viewId, GLSelectionData selData) { BaseView bv = (BaseView) WorkbenchUtil.getViewPart(BaseView.ID); bv.getMainTab().getView(viewId).updateView(selData); } - - public static boolean isRunning() { - return isRunning; - } - - public static void setRunningState(boolean isRunning) { - AnalyzerManager.isRunning = isRunning; - } - - public static boolean isLogParsingComplete() { - return isLogParsingComplete; - } - - public static void setLogParsingComplete(boolean complete) { - isLogParsingComplete = complete; - } - - public static Map getFuncIDMapByPid(int pid) { - if (funcIDMapByPid == null) { - synchronized (AnalyzerManager.class) { - if (funcIDMapByPid == null) { - funcIDMapByPid = new ConcurrentHashMap>(); - } - } - } - ConcurrentHashMap funcIDMap = funcIDMapByPid.get(pid); - if (funcIDMap == null) { - funcIDMap = new ConcurrentHashMap(); - funcIDMapByPid.put(pid, funcIDMap); - } - return funcIDMap; - } - - public static int getProcessCount() { - return processCount; - } - - public static synchronized void increaseProcessCount() { - processCount++; - } - - public static synchronized void decreaseProcessCount() { - processCount--; - } - - public static synchronized void startScreenshotTimer() { - stopScreenshotTimer(); - SettingDataManager setting = SettingDataManager.getInstance(); - int featureIndex = SettingConstants.FEATURE_NAME_INDEX_SCREENSHOT_PERIODICALLY; - if (setting.isOptionsSelectedFeature(featureIndex)) { - int value = setting.getOptionsFeatureValue(featureIndex); - if (value > 0) { - screenshotTimer = new Timer(AnalyzerConstants.SCREENSHOT_TIMER); - screenshotTimer.scheduleAtFixedRate(new ScreenshotTimerTask(), 1000, - value * 1000); - } - } - } - - public static synchronized void stopScreenshotTimer() { - if (null != screenshotTimer) { - screenshotTimer.cancel(); - screenshotTimer = null; - } - } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/AnalyzerPlugin.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/AnalyzerPlugin.java index c6f7336..d28f565 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/AnalyzerPlugin.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/AnalyzerPlugin.java @@ -51,9 +51,9 @@ public class AnalyzerPlugin extends AbstractUIPlugin { public void start(BundleContext context) throws Exception { super.start(context); plugin = this; - + // check for platform sdk - Global.setPlatformSDK(PathManager.checkPlatformPlugin()); + AnalyzerManager.setPlatformSDK(PathManager.checkPlatformPlugin()); // Adds workbench listener. IWorkbench workbench = PlatformUI.getWorkbench(); @@ -63,7 +63,7 @@ public class AnalyzerPlugin extends AbstractUIPlugin { public void postShutdown(IWorkbench workbench) { // close db connection SqlConnectionManager.closeConnection(); - + File tempDir = new File(PathManager.DA_TEMP_FOLDER_PATH); if (tempDir.isDirectory() && tempDir.exists()) { if (AnalyzerUtil.deleteFile(tempDir)) { @@ -93,7 +93,7 @@ public class AnalyzerPlugin extends AbstractUIPlugin { Logger.debug("BUG: temp folder is already exists but failed to delete"); } } - + // if temp save folder does not exist or not a directory if (!saveFolder.isDirectory()) { if (!saveFolder.mkdirs()) { diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/AutoStartManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/AutoStartManager.java index fd01da2..62c256c 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/AutoStartManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/AutoStartManager.java @@ -88,7 +88,7 @@ public class AutoStartManager implements Runnable { isAutoClose = true; } - ToolbarArea.getInstance().setToolbarStartStopState(false); + ToolbarArea.getInstance().setAllControlState(false); final String deviceName = new String(strMsg[MSG_INDEX_DEVICE].trim()); final String appid = new String(strMsg[MSG_INDEX_APPID].trim()); final String appName = new String(strMsg[MSG_INDEX_APPNAME].trim()); @@ -131,7 +131,7 @@ public class AutoStartManager implements Runnable { warning.setIcon(ImageResources.DIALOG_WARNING_ICON); warning.open(); - ToolbarArea.getInstance().setToolbarStartStopState(true); + ToolbarArea.getInstance().setAllControlState(true); } }); Logger.debug("invalid application name :" + appid); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/DALimit.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/DALimit.java index 37d51b4..c564f9b 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/DALimit.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/DALimit.java @@ -29,17 +29,17 @@ import org.eclipse.swt.SWT; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Shell; import org.tizen.dynamicanalyzer.common.path.PathManager; +import org.tizen.dynamicanalyzer.handlers.CommandAction; import org.tizen.dynamicanalyzer.nl.AnalyzerLabels; import org.tizen.dynamicanalyzer.resources.ImageResources; -import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea; import org.tizen.dynamicanalyzer.util.WorkbenchUtil; import org.tizen.dynamicanalyzer.widgets.da.base.DADialog; public class DALimit { /* - * limit of each information size - * if the size is over, read/write/send/receive in file or cut it down. + * limit of each information size if the size is over, read/write/send/receive in file or cut it + * down. */ // common public static final int FUNCTION_NAME_LENGTH = 1024; @@ -54,40 +54,38 @@ public class DALimit { public static final int HTML_SCRIPT_LENGTH = 4096; // Thread Analysis public static final int CLASS_NAME_LENGTH = 1024; - public static final int TOOLTIP_LENGTH = 256; + public static final int TOOLTIP_LENGTH = 256; - /* - * maximum limit of the tool can manager - * if one of the value is over, stop the trace. + * maximum limit of the tool can manager if one of the value is over, stop the trace. */ // common - public static final int MAX_TRACE_TIME_INSECOND = 24*60*60; // 1 day - public static final long MAX_SEQUENCE_NUMBER = Long.MAX_VALUE; //2^63-1, 4G*2G-1 - public static final int MAX_PROCESS_COUNT = (int) Math.pow(2, 16); // 65536 + public static final int MAX_TRACE_TIME_INSECOND = 24 * 60 * 60; // 1 day + public static final long MAX_SEQUENCE_NUMBER = Long.MAX_VALUE; // 2^63-1, 4G*2G-1 + public static final int MAX_PROCESS_COUNT = (int) Math.pow(2, 16); // 65536 public static final int MAX_BINARY_COUNT = (int) Math.pow(2, 16); // 65536 - public static final int MAX_FUNCTION_COUNT = (int) Math.pow(2, 20); // 1,048,576 - public static final int MAX_FUNCTION_ARGUMENTS_COUNT = FUNCTION_ARGUMENTS_FORMAT_LENGTH; // Because "MAX_FUNCTION_ARGUMENTS_COUNT < FUNCTION_ARGUMENTS_FORMAT_LENGTH" is always true - public static final long MAX_DAEMON_LOG_SIZE = 1024*1024; // 1 mega byte + public static final int MAX_FUNCTION_COUNT = (int) Math.pow(2, 20); // 1,048,576 + // Because "MAX_FUNCTION_ARGUMENTS_COUNT < FUNCTION_ARGUMENTS_FORMAT_LENGTH" is always true + public static final int MAX_FUNCTION_ARGUMENTS_COUNT = FUNCTION_ARGUMENTS_FORMAT_LENGTH; + public static final long MAX_DAEMON_LOG_SIZE = 1024 * 1024; // 1 mega byte public static final int MAX_PAYLOAD_SIZE = (int) Math.pow(2, 16); // 65536 - - // Leak + + // Leak public static final int MAX_LEAK_CHECK_BUFFER_SIZE = (int) Math.pow(2, 20); // 1,048,576 // File Analysis - public static final int MAX_FILE_STATUS_COUNT = ((int) Math.pow(2, 10))*100; // 102400 // 102400 - public static final int MAX_FILE_ACCESS_COUNT = ((int) Math.pow(2, 10))*100; // 102400 // 102400 + public static final int MAX_FILE_STATUS_COUNT = ((int) Math.pow(2, 10)) * 100; // 102400 + public static final int MAX_FILE_ACCESS_COUNT = ((int) Math.pow(2, 10)) * 100; // 102400 public static final int MAX_STRING_LENGTH = 16; - + // Callstack public static final int MAX_CALLSTACK_SEQTIMEMAP_SIZE = 100000; - - + public static void stopTraceAndOpenWarningDialog() { if (!AnalyzerManager.isRunning()) { return; } - ToolbarArea.getInstance().stopTrace(); + CommandAction.stopTrace(DAResult.ERR_OUT_OF_MEMORY, false); Display.getDefault().asyncExec(new Runnable() { @Override public void run() { diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/DAResult.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/DAResult.java index b094236..03302f6 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/DAResult.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/DAResult.java @@ -58,14 +58,25 @@ public enum DAResult { ERR_DA_IS_EXIT(-901, "Dynamic Analyzer is closing"), // error for DA host (4 digits) ( -1000 ~ -9999 ) + ERR_OUT_OF_MEMORY(-1001, UserErrorWarningLabels.ERROR_OUT_OF_MEMORY), ERR_NO_DEVICE(-1010, UserErrorWarningLabels.ERROR_DEVICE_NOT_FOUND), ERR_DISCONNECTED(-1011, UserErrorWarningLabels.ERROR_DEVICE_CONNECTION), ERR_NO_APP(-1020, UserErrorWarningLabels.ERROR_NONEXIST_APPLICATION), ERR_INVALID_APP(-1021, UserErrorWarningLabels.ERROR_UNSUPPORTED_APPLICATION), ERR_BY_SECURITY(-1030, UserErrorWarningLabels.ERROR_BY_SECURITY_REASON), + ERR_BY_USER_CANCEL(-1031, UserErrorWarningLabels.WARNING_USER_CANCEL), ERR_CONFIG_FAILED(-1100, UserErrorWarningLabels.ERROR_SETTING_FAILED), ERR_LIB_NOTFOUND_INRPM(-1101, UserErrorWarningLabels.ERROR_LIB_NOT_FOUND_INRPM), ERR_RPM_NOTFOUND(-1102, UserErrorWarningLabels.ERROR_RPM_NOT_FOUND), + ERR_START_DATA_CHANNEL(-2001, UserErrorWarningLabels.ERROR_INTERNAL_REASON), + ERR_START_MESSAGE_PARSER(-2002, UserErrorWarningLabels.ERROR_INTERNAL_REASON), + ERR_START_LOG_PARSER(-2003, UserErrorWarningLabels.ERROR_INTERNAL_REASON), + ERR_STOP_DATA_CHANNEL(-2004, UserErrorWarningLabels.ERROR_INTERNAL_REASON), + ERR_STOP_MESSAGE_PARSER(-2005, UserErrorWarningLabels.ERROR_INTERNAL_REASON), + ERR_STOP_LOG_PARSER(-2006, UserErrorWarningLabels.ERROR_INTERNAL_REASON), + ERR_CONTINUITY_BROKEN(-2010, UserErrorWarningLabels.WARNING_OVERHEAD_EXPLODE), + ERR_WRONG_MESSAGE_FORMAT(-2011, UserErrorWarningLabels.ERROR_INTERNAL_REASON), + ERR_DATA_SOCKET_CLOSED(-2012, UserErrorWarningLabels.ERROR_CONNECTION_CLOSED), ERR_UNKNOWN(-9999, UserErrorWarningLabels.ERROR_BY_UNKNOWN_REASON); private final int errNo; diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/Global.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/Global.java index 59ff3b6..d894a89 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/Global.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/Global.java @@ -39,31 +39,16 @@ import org.tizen.dynamicanalyzer.swap.channel.control.RunTimeConfiguration; // So this class contains only static methods and variables. public class Global { public enum STATE { - INIT, - DONE, - PREPARE_START, - RUNNING, - PREPARE_END, - PREPARE_CANCEL; - } - - private static boolean isPlatformSDK = false; - - private static STATE currentState; - + INIT, DONE, PREPARE_START, RUNNING, PREPARE_END, PREPARE_CANCEL; + } + + private static STATE currentState = STATE.INIT; + private static DeviceInfo currentDevice = null; private static PackageInfo currentApplication = null; private static Project currentProject = null; private static RunTimeConfiguration currentConfiguration = null; - public static boolean isPlatformSDK() { - return isPlatformSDK; - } - - public static void setPlatformSDK(boolean isPlatformSDK) { - Global.isPlatformSDK = isPlatformSDK; - } - public static DeviceInfo getCurrentDeviceInfo() { return currentDevice; } @@ -151,12 +136,29 @@ public class Global { return null; } } - + public static STATE getCurrentState() { return currentState; } - + public static void setCurrentState(STATE state) { Global.currentState = state; } + + public static int getBinaryID(int pid, long time, long address) { + if (currentProject != null) { + return currentProject.getBinaryID(pid, time, address); + } else { + return -1; + } + } + + public static String getLibraryName(int binaryID) { + if (binaryID >= 0 && currentProject != null) { + return currentProject.getDeviceStatusInfo().getBinaryInfo(binaryID) + .getTargetBinaryPath(); + } else { + return "unknown"; + } + } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/SymbolManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/SymbolManager.java index 3612f37..39d6d91 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/SymbolManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/SymbolManager.java @@ -323,12 +323,11 @@ public class SymbolManager { } /** - * getFuncName : returns function id from pc address, pid, time and set - * build type and binary path for ProfileData + * getFuncName : returns function id from pc address, pid, time and set build type and binary + * path for ProfileData * * @param input - * : can be null. If not null, set build type and binary path for - * ProfileData + * : can be null. If not null, set build type and binary path for ProfileData * @param address * : pc address * @param pid @@ -339,19 +338,16 @@ public class SymbolManager { */ // TODO: remove unnecessary code public static int getFuncId(ProfileData input, long address, int pid, long time) { - Map funcIdMap = AnalyzerManager.getFuncIDMapByPid(pid); - Integer functionId = funcIdMap.get(address); - if (null != functionId) { - return functionId; + Project project = Global.getProject(); + ProcessInformation process = project.getProcessInformation(pid); + + int functionID = process.getFunctionID(address); + if (functionID != AnalyzerConstants.INVALID_INDEX) { + return functionID; } String functionName = null; - functionId = -1; - - Project project = Global.getProject(); - ProcessInformation process = project.getProcessInformation(pid); ProcessMemoryMap pmap = process.getProcessMemoryMap(time); - if (pmap != null) { if (address >= pmap.getMainbinary().getLowestAddress() && address <= pmap.getMainbinary().getHighestAddress()) { @@ -428,8 +424,10 @@ public class SymbolManager { String prevFunctionName = functionName; functionName = demanglingFunctionName(prevFunctionName); } - functionId = Global.getFunctionID(functionName); - funcIdMap.put(address, functionId); - return functionId; + functionID = Global.getFunctionID(functionName); + if (functionID != AnalyzerConstants.INVALID_INDEX) { + process.putFunctionID(address, functionID); + } + return functionID; } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/communicator/BaseCommunicator.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/communicator/BaseCommunicator.java index e0fc72d..b94eb46 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/communicator/BaseCommunicator.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/communicator/BaseCommunicator.java @@ -29,6 +29,7 @@ import java.io.BufferedReader; import java.net.Socket; import org.tizen.dynamicanalyzer.common.DAResult; +import org.tizen.dynamicanalyzer.control.IProgress; import org.tizen.dynamicanalyzer.model.DeviceInfo; import org.tizen.dynamicanalyzer.project.PackageInfo; @@ -38,7 +39,7 @@ public abstract class BaseCommunicator { public abstract DAResult init(DeviceInfo deviceInfo); - public abstract DAResult startTrace(); + public abstract DAResult startTrace(IProgress progress) throws InterruptedException; public abstract DAResult sendHostMessage(DeviceInfo dev, int msgid); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/communicator/CommunicatorUtils.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/communicator/CommunicatorUtils.java index 945ee2f..69edb3a 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/communicator/CommunicatorUtils.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/communicator/CommunicatorUtils.java @@ -37,8 +37,8 @@ import java.util.List; import org.tizen.common.sdb.command.SdbCommand; import org.tizen.dynamicanalyzer.common.AnalyzerConstants; import org.tizen.dynamicanalyzer.common.AnalyzerShellCommands; -import org.tizen.dynamicanalyzer.common.Global; import org.tizen.dynamicanalyzer.common.DAResult; +import org.tizen.dynamicanalyzer.common.Global; import org.tizen.dynamicanalyzer.common.path.PathConstants; import org.tizen.dynamicanalyzer.common.path.PathManager; import org.tizen.dynamicanalyzer.constant.CommonConstants; diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/communicator/DACommunicator.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/communicator/DACommunicator.java index 27430c2..54d3669 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/communicator/DACommunicator.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/communicator/DACommunicator.java @@ -44,12 +44,13 @@ import org.tizen.dynamicanalyzer.common.AnalyzerConstants; import org.tizen.dynamicanalyzer.common.AnalyzerManager; import org.tizen.dynamicanalyzer.common.AnalyzerShellCommands; import org.tizen.dynamicanalyzer.common.DALimit; -import org.tizen.dynamicanalyzer.common.Global; import org.tizen.dynamicanalyzer.common.DAResult; +import org.tizen.dynamicanalyzer.common.Global; import org.tizen.dynamicanalyzer.common.path.PathConstants; import org.tizen.dynamicanalyzer.common.path.PathManager; import org.tizen.dynamicanalyzer.constant.CommonConstants; import org.tizen.dynamicanalyzer.control.ApplistManager; +import org.tizen.dynamicanalyzer.control.IProgress; import org.tizen.dynamicanalyzer.model.DeviceInfo; import org.tizen.dynamicanalyzer.project.AppInfo; import org.tizen.dynamicanalyzer.project.PackageInfo; @@ -91,8 +92,8 @@ public class DACommunicator { } } - public static DAResult startTrace() { - return Global.getCurrentDeviceInfo().getCommunicator().startTrace(); + public static DAResult startTrace(IProgress progress) throws InterruptedException { + return Global.getCurrentDeviceInfo().getCommunicator().startTrace(progress); } public static DAResult sendHostMessage(int msgid) { @@ -453,54 +454,24 @@ public class DACommunicator { @Override public void onDisconnected(IDevice device) { // called : each device disconnected time - Display.getDefault().syncExec(new Runnable() { - @Override - public void run() { - ToolbarArea.getInstance().setMainControlEnablement(false); - } - }); - + ToolbarArea.getInstance().setAllControlState(false); onDisconnectedInternal(device); - - Display.getDefault().syncExec(new Runnable() { - @Override - public void run() { - ToolbarArea.getInstance().setMainControlEnablement(true); - } - }); + ToolbarArea.getInstance().setAllControlState(true); } @Override public void onConnected(IDevice device) { // It called when dynamic-analyzer start, only one time - - Display.getDefault().syncExec(new Runnable() { - @Override - public void run() { - ToolbarArea.getInstance().setMainControlEnablement(false); - } - }); - + ToolbarArea.getInstance().setAllControlState(false); onConnectedInternal(device); - - Display.getDefault().syncExec(new Runnable() { - @Override - public void run() { - ToolbarArea.getInstance().setMainControlEnablement(true); - } - }); + ToolbarArea.getInstance().setAllControlState(true); } @Override public void onChanged(IDevice device, int changeMask) { // called : device added - already dynamic-analyzer running (not // tracing) - Display.getDefault().syncExec(new Runnable() { - @Override - public void run() { - ToolbarArea.getInstance().setMainControlEnablement(false); - } - }); + ToolbarArea.getInstance().setAllControlState(false); Logger.debug("device changed : " + device.getSerialNumber() + " " + changeMask); if (1 == changeMask) { // state changed (offline -> online, vice versa) @@ -510,12 +481,7 @@ public class DACommunicator { Logger.debug("device changed type :" + changeMask); } - Display.getDefault().syncExec(new Runnable() { - @Override - public void run() { - ToolbarArea.getInstance().setMainControlEnablement(true); - } - }); + ToolbarArea.getInstance().setAllControlState(true); } private void onDisconnectedInternal(IDevice device) { @@ -548,14 +514,6 @@ public class DACommunicator { updateToolbarDevice(); } } - if (null != Global.getCurrentDeviceInfo() && null != Global.getCurrentApplication()) { - Display.getDefault().syncExec(new Runnable() { - @Override - public void run() { - ToolbarArea.getInstance().setStartButtonEnablement(true); - } - }); - } } }; diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/communicator/IDECommunicator.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/communicator/IDECommunicator.java index 1527e04..2907b9c 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/communicator/IDECommunicator.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/communicator/IDECommunicator.java @@ -330,7 +330,7 @@ public class IDECommunicator implements Runnable { Logger.debug("wrong message format!!"); return; } - ToolbarArea.getInstance().setToolbarStartStopState(false); + ToolbarArea.getInstance().setAllControlState(false); final String deviceName = new String(strMsg[MSG_INDEX_DEVICE].trim()); final String projectType = new String(strMsg[MSG_INDEX_PROJECT_TYPE].trim()); @@ -358,7 +358,7 @@ public class IDECommunicator implements Runnable { Global.setCurrentDeviceInfo(device); if (device == null) { popupMessage(UserErrorWarningLabels.ERROR_DEVICE_CONNECTION); - ToolbarArea.getInstance().setToolbarStartStopState(true); + ToolbarArea.getInstance().setAllControlState(true); return; } @@ -370,7 +370,7 @@ public class IDECommunicator implements Runnable { if (pkgInfo == null) { popupMessageWithAppname(binaryOfTarget, UserErrorWarningLabels.ERROR_NONEXIST_APPLICATION); - ToolbarArea.getInstance().setToolbarStartStopState(true); + ToolbarArea.getInstance().setAllControlState(true); return; } @@ -382,7 +382,7 @@ public class IDECommunicator implements Runnable { Logger.error("rpm package for library is not set"); popupMessage(UserErrorWarningLabels.ERROR_LIBTRACE_START + CommonConstants.NEW_LINE + UserErrorWarningLabels.ERROR_RPM_NOT_FOUND); - ToolbarArea.getInstance().setToolbarStartStopState(true); + ToolbarArea.getInstance().setAllControlState(true); return; } @@ -409,7 +409,7 @@ public class IDECommunicator implements Runnable { if (errormsg != null) { Logger.error("error during binary setting wit rpm"); popupMessage(errormsg); - ToolbarArea.getInstance().setToolbarStartStopState(true); + ToolbarArea.getInstance().setAllControlState(true); return; } @@ -425,7 +425,7 @@ public class IDECommunicator implements Runnable { if (pkgInfo == null) { popupMessageWithAppname(appID, UserErrorWarningLabels.ERROR_NONEXIST_APPLICATION); - ToolbarArea.getInstance().setToolbarStartStopState(true); + ToolbarArea.getInstance().setAllControlState(true); return; } } else { @@ -434,7 +434,7 @@ public class IDECommunicator implements Runnable { popupMessage(UserErrorWarningLabels.ERROR_LIBTRACE_START + CommonConstants.NEW_LINE + UserErrorWarningLabels.ERROR_NO_APPID_FOR_LAUNCHPAD); - ToolbarArea.getInstance().setToolbarStartStopState(true); + ToolbarArea.getInstance().setAllControlState(true); return; } } else { @@ -447,7 +447,7 @@ public class IDECommunicator implements Runnable { // TODO : get appInfo from executable path popupMessageWithAppname(executablePath, UserErrorWarningLabels.ERROR_UNSUPPORTED_APPLICATION); - ToolbarArea.getInstance().setToolbarStartStopState(true); + ToolbarArea.getInstance().setAllControlState(true); } if (pkgInfo != null) { diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/ApplistManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/ApplistManager.java index c54ea43..3b95afd 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/ApplistManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/ApplistManager.java @@ -32,7 +32,7 @@ import java.util.List; import java.util.Map; import org.tizen.dynamicanalyzer.common.AnalyzerConstants; -import org.tizen.dynamicanalyzer.common.Global; +import org.tizen.dynamicanalyzer.common.AnalyzerManager; import org.tizen.dynamicanalyzer.constant.CommonConstants; import org.tizen.dynamicanalyzer.project.AppInfo; import org.tizen.dynamicanalyzer.project.PackageInfo; @@ -145,7 +145,7 @@ public class ApplistManager { if (pkgInfo.getPackageId() == null) { return null; - } else if (!Global.isPlatformSDK() && pkgInfo.getPreload() != 0) { + } else if (!AnalyzerManager.isPlatformSDK() && pkgInfo.getPreload() != 0) { return null; } else { return pkgInfo; diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/screenshot/ScreenshotTimerTask.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/IProgress.java similarity index 70% rename from org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/screenshot/ScreenshotTimerTask.java rename to org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/IProgress.java index 67781ac..4d4249b 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/screenshot/ScreenshotTimerTask.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/IProgress.java @@ -4,7 +4,7 @@ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. * * Contact: - * Jungwook Ryu + * Jaewon Lim * Juyoung Kim * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -24,17 +24,16 @@ * */ -package org.tizen.dynamicanalyzer.ui.info.screenshot; +package org.tizen.dynamicanalyzer.control; -import java.util.TimerTask; +import org.tizen.dynamicanalyzer.control.ProgressTable.STAGE; -import org.tizen.dynamicanalyzer.communicator.DACommunicator; - -public class ScreenshotTimerTask extends TimerTask { - - @Override - public void run() { - DACommunicator.sendScreenShotMessage(); - } +public interface IProgress { + public void setStageComplete(STAGE stage); + + public boolean isCanceled(); + + public void checkCancel() throws InterruptedException; + } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/ProgressTable.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/ProgressTable.java new file mode 100644 index 0000000..9fa1e8a --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/ProgressTable.java @@ -0,0 +1,117 @@ +/* + * Dynamic Analyzer + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * Jaewon Lim + * 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.control; + +import java.util.EnumMap; +import java.util.Map; + +public class ProgressTable { + + public enum STAGE { + NONE(0), + CHECK_DEV(3), + CHECK_APP(3), + CHECK_CONFIG(5), + CREATE_PROJECT(2), + ESTABLISH_DB(5), + CREATE_DBTABLE(20), + RESET_UI(3), + CREATE_DATATHREAD(3), + CREATE_MPARSER(3), + CREATE_LPARSER(3), + CREATE_PAGEMGR(10), + SEND_STARTMSG(15), + WAIT_PROCINFO(20), + START_CLOCK(2), + CREATE_REPLAY_TIMER(2), + CREATE_SCREENSHOT_TIMER(2), + CREATE_UPDATE_TIMER(2), + STOP_CLOCK(2), + STOP_REPLAY_TIMER(2), + STOP_SCREENSHOT_TIMER(2), + STOP_UPDATE_TIMER(2), + SEND_STOPMSG(15), + STOP_DATATHREAD(10), + STOP_MPARSER(8), + STOP_LPARSER(8), + STOP_PAGEMGR(17), + SAVE_PROJECT(13), + SUMMARIZE_UI(5), + FINAL(0); + + protected int weight; + + private STAGE(int weight) { + this.weight = weight; + } + } + + public enum PHASE { + TRACE_START(traceStartProgress), CANCEL_TRACE_START(cancelTraceStartProgress), TRACE_END( + traceEndProgress), RANGE_ANALYSIS(rangeAnalysisProgress); + + protected STAGE[] stageArray; + protected Map accumMap = new EnumMap(STAGE.class); + + private PHASE(STAGE[] array) { + stageArray = array; + synchronized (accumMap) { + int total = 0; + for (int i = 0; i < stageArray.length; i++) { + total += stageArray[i].weight; + accumMap.put(stageArray[i], total); + } + } + } + } + + private static STAGE[] traceStartProgress = new STAGE[] { STAGE.CHECK_DEV, STAGE.CHECK_APP, + STAGE.CHECK_CONFIG, STAGE.CREATE_PROJECT, STAGE.ESTABLISH_DB, STAGE.CREATE_DBTABLE, + STAGE.RESET_UI, STAGE.CREATE_DATATHREAD, STAGE.CREATE_MPARSER, STAGE.CREATE_LPARSER, + STAGE.CREATE_PAGEMGR, STAGE.SEND_STARTMSG, STAGE.WAIT_PROCINFO, STAGE.START_CLOCK, + STAGE.CREATE_REPLAY_TIMER, STAGE.CREATE_SCREENSHOT_TIMER, STAGE.CREATE_UPDATE_TIMER, + STAGE.FINAL }; + private static STAGE[] cancelTraceStartProgress = new STAGE[] { STAGE.CREATE_UPDATE_TIMER, + STAGE.CREATE_SCREENSHOT_TIMER, STAGE.CREATE_REPLAY_TIMER, STAGE.START_CLOCK, + STAGE.SEND_STARTMSG, STAGE.CREATE_PAGEMGR, STAGE.CREATE_LPARSER, STAGE.CREATE_MPARSER, + STAGE.CREATE_DATATHREAD, STAGE.CREATE_PROJECT, STAGE.FINAL }; + private static STAGE[] traceEndProgress = new STAGE[] { STAGE.STOP_CLOCK, STAGE.SEND_STOPMSG, + STAGE.STOP_REPLAY_TIMER, STAGE.STOP_SCREENSHOT_TIMER, STAGE.STOP_UPDATE_TIMER, + STAGE.STOP_DATATHREAD, STAGE.STOP_MPARSER, STAGE.STOP_LPARSER, STAGE.STOP_PAGEMGR, + STAGE.SAVE_PROJECT, STAGE.SUMMARIZE_UI, STAGE.FINAL }; + private static STAGE[] rangeAnalysisProgress = new STAGE[] { STAGE.FINAL }; + + public static int getPercent(PHASE phase, STAGE stage) { + Map progressMap = phase.accumMap; + Integer accumVal = progressMap.get(stage); + if (accumVal != null) { + return accumVal.intValue() * 100 / progressMap.get(STAGE.FINAL).intValue(); + } else { + return 0; + } + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/SideWorker.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/SideWorker.java new file mode 100644 index 0000000..04d3346 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/SideWorker.java @@ -0,0 +1,89 @@ +/* + * Dynamic Analyzer + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * Jaewon Lim + * 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.control; + +import java.util.concurrent.BlockingQueue; +import java.util.concurrent.LinkedBlockingQueue; + +import org.tizen.dynamicanalyzer.common.AnalyzerConstants; +import org.tizen.dynamicanalyzer.util.Logger; + +public enum SideWorker implements Runnable { + INSTANCE; + + private static Thread thread = null; + + private BlockingQueue workQueue = new LinkedBlockingQueue(); + + public static void start() { + if (null == thread || !thread.isAlive()) { + thread = new Thread(null, INSTANCE, AnalyzerConstants.SIDEWORKER_THREAD); + thread.start(); + } + } + + public static void stop() { + if (null != thread && thread.isAlive()) { + thread.interrupt(); + try { + thread.join(AnalyzerConstants.THREAD_JOIN_WAIT_TIME); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + thread = null; + } + + public void offerWork(Runnable work) { + if (work != null) { + try { + workQueue.put(work); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + } + + @Override + public void run() { + while (!thread.isInterrupted()) { + Runnable runnable = null; + try { + runnable = workQueue.take(); + } catch (InterruptedException e) { + e.printStackTrace(); + break; + } + + if (runnable != null) { + runnable.run(); + } + } + + Logger.debug(AnalyzerConstants.SIDEWORKER_THREAD + " is terminated"); + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/StartTraceManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/StartTraceManager.java index 1f3b8be..bd24596 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/StartTraceManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/StartTraceManager.java @@ -31,21 +31,61 @@ import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Shell; import org.tizen.dynamicanalyzer.common.AnalyzerManager; import org.tizen.dynamicanalyzer.common.DAResult; +import org.tizen.dynamicanalyzer.common.Global; +import org.tizen.dynamicanalyzer.common.Global.STATE; +import org.tizen.dynamicanalyzer.communicator.DACommunicator; +import org.tizen.dynamicanalyzer.control.ProgressTable.PHASE; +import org.tizen.dynamicanalyzer.control.ProgressTable.STAGE; import org.tizen.dynamicanalyzer.handlers.CommonAction; +import org.tizen.dynamicanalyzer.handlers.ReplayManager; +import org.tizen.dynamicanalyzer.handlers.UIAction; import org.tizen.dynamicanalyzer.nl.AnalyzerLabels; -import org.tizen.dynamicanalyzer.ui.timeline.TimelinePage; +import org.tizen.dynamicanalyzer.project.Project; +import org.tizen.dynamicanalyzer.resources.ImageResources; +import org.tizen.dynamicanalyzer.shortcut.ShortCutManager; +import org.tizen.dynamicanalyzer.swap.communicator.DataChannelThread; +import org.tizen.dynamicanalyzer.swap.logparser.DataManagerRegistry; +import org.tizen.dynamicanalyzer.swap.logparser.LogParser; +import org.tizen.dynamicanalyzer.swap.logparser.MessageParser; +import org.tizen.dynamicanalyzer.ui.info.screenshot.ScreenshotTimer; +import org.tizen.dynamicanalyzer.ui.page.UpdateViewTimer; +import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea; +import org.tizen.dynamicanalyzer.ui.toolbar.setting.data.SettingConstants; +import org.tizen.dynamicanalyzer.ui.toolbar.setting.data.SettingDataManager; import org.tizen.dynamicanalyzer.util.WorkbenchUtil; -import org.tizen.dynamicanalyzer.utils.AnalyzerUtil; import org.tizen.dynamicanalyzer.widgets.button.DACustomButton; import org.tizen.dynamicanalyzer.widgets.button.DACustomButtonClickEventListener; +import org.tizen.dynamicanalyzer.widgets.da.base.DADialog; import org.tizen.dynamicanalyzer.widgets.da.base.ProgressDialog; import org.tizen.dynamicanalyzer.widgets.progress.Progress; import org.tizen.dynamicanalyzer.workbench.LayoutManager; public class StartTraceManager implements Runnable { - private boolean cancelCommand = false; + private static final int WAIT_GAP = 100; + + private STAGE lastStage = STAGE.NONE; + private boolean cancelAction = false; private ProgressDialog progressDlg = null; - + private Thread startThread = null; + private IProgress progress = new IProgress() { + @Override + public boolean isCanceled() { + return cancelAction; + } + + @Override + public void setStageComplete(STAGE stage) { + lastStage = stage; + int percent = ProgressTable.getPercent(PHASE.TRACE_START, lastStage); + setProgressPercent(percent); + } + + @Override + public void checkCancel() throws InterruptedException { + StartTraceManager.this.checkCancel(); + } + }; + public StartTraceManager() { // create progress dialog and open it Display.getDefault().syncExec(new Runnable() { @@ -63,58 +103,248 @@ public class StartTraceManager implements Runnable { progressDlg.setCancelListener(new DACustomButtonClickEventListener() { @Override public void handleClickEvent(DACustomButton button) { - cancelCommand = true; - // SEE : remove or not? - // ToolbarArea.getInstance().stopTrace(); + cancelAction = true; + if (startThread != null) { + startThread.interrupt(); + } } }); } }); } - - public boolean isCanceled() { - return cancelCommand; - } @Override public void run() { - if (!CommonAction.checkDeviceValidness()) { - showError(DAResult.ERR_DISCONNECTED); - return; - } - setPercent(5); + DAResult result = DAResult.SUCCESS; - if (!CommonAction.checkApplicatinValidness()) { - showError(DAResult.ERR_INVALID_APP); - return; - } - setPercent(10); + try { + startThread = Thread.currentThread(); - if (!CommonAction.checkConfiguration()) { - showError(DAResult.ERR_CONFIG_FAILED); - return; - } - setPercent(15); + if (!CommonAction.checkDeviceValidness()) { + result = DAResult.ERR_DISCONNECTED; + return; + } + setStageComplete(STAGE.CHECK_DEV); + + if (!CommonAction.checkApplicatinValidness()) { + result = DAResult.ERR_INVALID_APP; + return; + } + setStageComplete(STAGE.CHECK_APP); + + if (!CommonAction.checkConfiguration()) { + result = DAResult.ERR_CONFIG_FAILED; + return; + } + setStageComplete(STAGE.CHECK_CONFIG); + + AnalyzerManager.setRunningState(true); + CommonAction.clear(); - AnalyzerUtil.changePage(TimelinePage.pageID); - AnalyzerManager.setRunningState(true); + // make and initialize new project + Project project = new Project(); + Global.setProject(project); + project.init(progress); + // reset UI + UIAction.resetUI(); + setStageComplete(STAGE.RESET_UI); + + // start data receive thread + result = DataChannelThread.start(); + if (!result.isSuccess()) { + // failed to start data channel thread + return; + } + setStageComplete(STAGE.CREATE_DATATHREAD); + + // start message parser thread + MessageParser.start(); + setStageComplete(STAGE.CREATE_MPARSER); + + // start log parser thread + LogParser.start(); + setStageComplete(STAGE.CREATE_LPARSER); + + // start registered data manager thread and db inserters + DataManagerRegistry.startThreads(); + setStageComplete(STAGE.CREATE_PAGEMGR); + + // send start message to target + result = DACommunicator.startTrace(progress); + setStageComplete(STAGE.SEND_STARTMSG); + if (!result.isSuccess()) { + // failed to start trace (error from target) + return; + } + + // wait until process info message is arrived (for a few seconds) + while (!AnalyzerManager.isExit()) { + if (AnalyzerManager.isRunning() && AnalyzerManager.isProcessInfoArrived()) { + break; + } + + Thread.sleep(WAIT_GAP); + checkCancel(); + } + setStageComplete(STAGE.WAIT_PROCINFO); + + // start toolbar clock + ToolbarArea.getInstance().startTimer(); + setStageComplete(STAGE.START_CLOCK); + + // if it is replay mode, set stop alarm + ReplayManager.setStopAlarm(); + setStageComplete(STAGE.CREATE_REPLAY_TIMER); + + // start screenshot timer + SettingDataManager setting = SettingDataManager.getInstance(); + int featureIndex = SettingConstants.FEATURE_NAME_INDEX_SCREENSHOT_PERIODICALLY; + if (setting.isOptionsSelectedFeature(featureIndex)) { + int value = setting.getOptionsFeatureValue(featureIndex); + if (value > 0) { + ScreenshotTimer.start(value); + } + } + setStageComplete(STAGE.CREATE_SCREENSHOT_TIMER); + + // start update view timer + UpdateViewTimer.start(); + setStageComplete(STAGE.CREATE_UPDATE_TIMER); + + setStageComplete(STAGE.FINAL); + } catch (InterruptedException e) { + // operation is canceled + // re-interrupt thread to set the flag as 'interrupted' + Thread.currentThread().interrupt(); + + // set DA state to canceling + Global.setCurrentState(STATE.PREPARE_CANCEL); + result = DAResult.ERR_BY_USER_CANCEL; + + /********************************************************************* + * cancel some operations + *********************************************************************/ + switch (lastStage) { + case FINAL: + case CREATE_UPDATE_TIMER: + UpdateViewTimer.stop(); + setCancelProgress(STAGE.CREATE_UPDATE_TIMER); + case CREATE_SCREENSHOT_TIMER: + ScreenshotTimer.stop(); + setCancelProgress(STAGE.CREATE_SCREENSHOT_TIMER); + case CREATE_REPLAY_TIMER: + ReplayManager.resetStopAlarm(); + setCancelProgress(STAGE.CREATE_REPLAY_TIMER); + case START_CLOCK: + ToolbarArea.getInstance().stopTimer(); + setCancelProgress(STAGE.START_CLOCK); + case WAIT_PROCINFO: + case SEND_STARTMSG: + DACommunicator.stopTrace(); + setCancelProgress(STAGE.SEND_STARTMSG); + case CREATE_PAGEMGR: + DataManagerRegistry.stopThreadsForced(); + setCancelProgress(STAGE.CREATE_PAGEMGR); + case CREATE_LPARSER: + LogParser.stopForced(); + setCancelProgress(STAGE.CREATE_LPARSER); + case CREATE_MPARSER: + MessageParser.stopForced(); + setCancelProgress(STAGE.CREATE_MPARSER); + case CREATE_DATATHREAD: + DataChannelThread.stopForced(); + setCancelProgress(STAGE.CREATE_DATATHREAD); + case RESET_UI: + case CREATE_DBTABLE: + case ESTABLISH_DB: + case CREATE_PROJECT: + // clear including project + CommonAction.clear(); + setCancelProgress(STAGE.CREATE_PROJECT); + case CHECK_CONFIG: + case CHECK_APP: + case CHECK_DEV: + break; + default: + break; + } + } finally { + // set DA state as result of start progress + if (lastStage != STAGE.FINAL) { + AnalyzerManager.setRunningState(false); + Global.setCurrentState(STATE.DONE); + } else { + Global.setCurrentState(STATE.RUNNING); + } + + // close progress dialog + if (progressDlg != null) { + Display.getDefault().syncExec(new Runnable() { + @Override + public void run() { + progressDlg.close(); + } + }); + } + + // if error occurred, show the error dialog + if (!result.isSuccess()) { + showError(result); + } + + // set shortcut and toolbar UI as DA state + ShortCutManager.getInstance().setEnabled(true); + ToolbarArea.getInstance().changeUIState(Global.getCurrentState()); + } } - private void setPercent(int percent) { + private void setProgressPercent(int percent) { + final int per = percent; if (progressDlg != null) { - final int pnt = percent; - Display.getDefault().syncExec(new Runnable() { @Override public void run() { - progressDlg.setValue(pnt); + progressDlg.setValue(per); } }); } } + private void setStageComplete(STAGE st) throws InterruptedException { + lastStage = st; + + int percent = ProgressTable.getPercent(PHASE.TRACE_START, lastStage); + if (percent != 100) { + checkCancel(); + } + + setProgressPercent(percent); + } + + private void setCancelProgress(STAGE st) { + int percent = ProgressTable.getPercent(PHASE.CANCEL_TRACE_START, st); + setProgressPercent(percent); + } + + private void checkCancel() throws InterruptedException { + if (startThread.isInterrupted()) { + throw new InterruptedException(); + } + } + private void showError(DAResult result) { - // SEE : change dialog appearance to show error message + // open error dialog + final DAResult fResult = result; + Display.getDefault().syncExec(new Runnable() { + @Override + public void run() { + Shell shell = WorkbenchUtil.getWorkbenchWindow().getShell(); + DADialog warning = new DADialog(shell, SWT.NONE); + warning.setMessage(fResult.getMessage() + "(" + fResult.getErrorNumber() + ")"); + warning.setIcon(ImageResources.DIALOG_WARNING_ICON); + warning.open(); + } + }); } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/StopTraceManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/StopTraceManager.java new file mode 100644 index 0000000..2e43477 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/StopTraceManager.java @@ -0,0 +1,194 @@ +package org.tizen.dynamicanalyzer.control; + +import org.eclipse.swt.SWT; +import org.eclipse.swt.widgets.Display; +import org.eclipse.swt.widgets.Shell; +import org.tizen.dynamicanalyzer.common.AnalyzerManager; +import org.tizen.dynamicanalyzer.common.DAResult; +import org.tizen.dynamicanalyzer.common.Global; +import org.tizen.dynamicanalyzer.common.Global.STATE; +import org.tizen.dynamicanalyzer.communicator.DACommunicator; +import org.tizen.dynamicanalyzer.control.ProgressTable.PHASE; +import org.tizen.dynamicanalyzer.control.ProgressTable.STAGE; +import org.tizen.dynamicanalyzer.handlers.ReplayManager; +import org.tizen.dynamicanalyzer.handlers.UIAction; +import org.tizen.dynamicanalyzer.nl.AnalyzerLabels; +import org.tizen.dynamicanalyzer.project.Project; +import org.tizen.dynamicanalyzer.resources.ImageResources; +import org.tizen.dynamicanalyzer.shortcut.ShortCutManager; +import org.tizen.dynamicanalyzer.swap.communicator.DataChannelThread; +import org.tizen.dynamicanalyzer.swap.logparser.DataManagerRegistry; +import org.tizen.dynamicanalyzer.swap.logparser.LogParser; +import org.tizen.dynamicanalyzer.swap.logparser.MessageParser; +import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackInserter; +import org.tizen.dynamicanalyzer.ui.info.screenshot.ScreenshotTimer; +import org.tizen.dynamicanalyzer.ui.page.UpdateViewTimer; +import org.tizen.dynamicanalyzer.ui.summary.SummaryPage; +import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler; +import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea; +import org.tizen.dynamicanalyzer.util.WorkbenchUtil; +import org.tizen.dynamicanalyzer.utils.AnalyzerUtil; +import org.tizen.dynamicanalyzer.widgets.da.base.DADialog; +import org.tizen.dynamicanalyzer.widgets.da.base.ProgressDialog; +import org.tizen.dynamicanalyzer.workbench.LayoutManager; + +public class StopTraceManager implements Runnable { + + private STAGE lastStage = STAGE.NONE; + private ProgressDialog progressDlg = null; + private DAResult error; + private boolean stopFromTarget = false; + + public StopTraceManager(DAResult error, boolean stopFromTarget) { + AnalyzerManager.setRunningState(false); + this.error = error; + this.stopFromTarget = stopFromTarget; + + // create progress dialog and open it + Display.getDefault().syncExec(new Runnable() { + @Override + public void run() { + Shell shell = WorkbenchUtil.getWorkbenchWindow().getShell(); + progressDlg = new ProgressDialog(shell, LayoutManager.getBaseComposite()); + if (null != progressDlg) { + progressDlg.setStyle(SWT.ON_TOP); + progressDlg.setProgressMessage(AnalyzerLabels.DLG_SUMMARIZING_DATA); + progressDlg.setProgressInfo(AnalyzerLabels.DLG_PLEASE_WAIT); + progressDlg.open(); + } + } + }); + } + + @Override + public void run() { + DAResult result = DAResult.SUCCESS; + + try { + // send stop message if necessary + if (!stopFromTarget) { + DACommunicator.stopTrace(); + } + DACommunicator.setRunning(false); + setStageComplete(STAGE.SEND_STOPMSG); + + // stop clock + ToolbarArea.getInstance().stopTimer(); + setStageComplete(STAGE.STOP_CLOCK); + + // stop replay timer + ReplayManager.resetStopAlarm(); + setStageComplete(STAGE.STOP_REPLAY_TIMER); + + // stop screenshot timer + ScreenshotTimer.stop(); + setStageComplete(STAGE.STOP_SCREENSHOT_TIMER); + + // stop update timer + UpdateViewTimer.stop(); + setStageComplete(STAGE.STOP_UPDATE_TIMER); + + // stop data channel + DataChannelThread.stopNormal(); + setStageComplete(STAGE.STOP_DATATHREAD); + + // stop message parser + MessageParser.stopNormal(); + setStageComplete(STAGE.STOP_MPARSER); + + // stop log parser + LogParser.stopNormal(); + setStageComplete(STAGE.STOP_LPARSER); + + // stop page data manager + DataManagerRegistry.stopThreadsNormal(); + setStageComplete(STAGE.STOP_PAGEMGR); + + // stop other db inserters + CallStackInserter.getInstance().stopInserterThread(); + + // save project and others + Project project = Global.getProject(); + project.setTotalStopTime(ToolbarArea.getInstance().getTime()); + FunctionUsageProfiler.getInstance().saveProfilingData(); + FunctionUsageProfiler.getInstance().saveProfilingChildData(); + project.save(); + setStageComplete(STAGE.SAVE_PROJECT); + + // change summary UI + // change to summary page + UIAction.summarizeUI(); + AnalyzerUtil.changePage(SummaryPage.pageID); + setStageComplete(STAGE.SUMMARIZE_UI); + } catch (InterruptedException e) { + // canceled stop tracing + // never happened + e.printStackTrace(); + } finally { + // set DA state as result of start progress + AnalyzerManager.setRunningState(false); + Global.setCurrentState(STATE.DONE); + + // close progress dialog + if (progressDlg != null) { + Display.getDefault().syncExec(new Runnable() { + @Override + public void run() { + progressDlg.close(); + } + }); + } + + // if error occurred, show the error dialog + if (!result.isSuccess()) { + showError(result); + } + + // set shortcut and toolbar UI as DA state + ShortCutManager.getInstance().setEnabled(true); + ToolbarArea.getInstance().changeUIState(Global.getCurrentState()); + } + } + + private void setProgressPercent(int percent) { + final int per = percent; + if (progressDlg != null) { + Display.getDefault().syncExec(new Runnable() { + @Override + public void run() { + progressDlg.setValue(per); + } + }); + } + } + + private void setStageComplete(STAGE st) throws InterruptedException { + lastStage = st; + + int percent = ProgressTable.getPercent(PHASE.TRACE_END, lastStage); + if (percent != 100) { + checkCancel(); + } + + setProgressPercent(percent); + } + + private void checkCancel() throws InterruptedException { + // do nothing + } + + private void showError(DAResult result) { + // open error dialog + final DAResult fResult = result; + Display.getDefault().syncExec(new Runnable() { + @Override + public void run() { + Shell shell = WorkbenchUtil.getWorkbenchWindow().getShell(); + DADialog warning = new DADialog(shell, SWT.NONE); + warning.setMessage(fResult.getMessage() + "(" + fResult.getErrorNumber() + ")"); + warning.setIcon(ImageResources.DIALOG_WARNING_ICON); + warning.open(); + } + }); + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/DBInsertManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/DBInsertManager.java deleted file mode 100644 index b00dd12..0000000 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/DBInsertManager.java +++ /dev/null @@ -1,65 +0,0 @@ -/* - * Dynamic Analyzer - * - * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved. - * - * Contact: - * Jaewon Lim - * 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.database; - -import java.util.HashMap; -import java.util.Map; - -public class DBInsertManager { - private static Map insertThreads = new HashMap(); - - public static DBInserter makeInserter(DBTable table) { - DBInserter ret = null; - String tablename = table.getTableName(); - if (!insertThreads.containsKey(tablename)) { - DBInserter thread = new DBInserter(table); - insertThreads.put(tablename, thread); - ret = thread; - } else { - ret = insertThreads.get(tablename); - } - return ret; - } - - public static void startInserters() { - for (Map.Entry entry : insertThreads.entrySet()) { - DBInserter inserter = entry.getValue(); - inserter.startThread(); - } - } - - public static void stopInserters() { - for (Map.Entry entry : insertThreads.entrySet()) { - DBInserter thread = entry.getValue(); - thread.stopThread(); - } - } - - public static DBInserter getInserter(String tablename) { - return insertThreads.get(tablename); - } -} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/DBInserter.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/DBInserter.java index dc8a859..04289bb 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/DBInserter.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/DBInserter.java @@ -30,10 +30,8 @@ import java.util.ArrayList; import java.util.List; import java.util.concurrent.LinkedBlockingQueue; -import org.tizen.dynamicanalyzer.common.AnalyzerConstants; - public class DBInserter implements Runnable { - private static List> END_OF_QUEUE = new ArrayList>(); + public static List> END_OF_QUEUE = new ArrayList>(); private LinkedBlockingQueue>> dataQueue = new LinkedBlockingQueue>>(); private DBTable table = null; @@ -43,32 +41,39 @@ public class DBInserter implements Runnable { this.table = table; } - public void startThread() { - if (thread != null) { - if (thread.isAlive()) { - thread.interrupt(); - } + public void start() { + if (thread != null && thread.isAlive()) { try { - thread.join(AnalyzerConstants.THREAD_JOIN_WAIT_TIME); + thread.interrupt(); + thread.join(); thread = null; } catch (InterruptedException e) { e.printStackTrace(); } } - - clear(); thread = new Thread(this, table.getTableName() + " inserter"); thread.start(); } - public void stopThread() { - if (thread != null) { - if (thread.isAlive()) { - setToStop(); + public void stopNormal() { + if (thread != null && thread.isAlive()) { + try { + thread.join(); + thread = null; + } catch (InterruptedException e) { + e.printStackTrace(); } + } + + clear(); + } + + public void stopForced() { + if (thread != null && thread.isAlive()) { try { - thread.join(AnalyzerConstants.THREAD_JOIN_WAIT_TIME); + thread.interrupt(); + thread.join(); thread = null; } catch (InterruptedException e) { e.printStackTrace(); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/DBTable.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/DBTable.java index 7e8ef34..47b741b 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/DBTable.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/DBTable.java @@ -36,6 +36,7 @@ import org.tizen.dynamicanalyzer.constant.CommonConstants; public abstract class DBTable implements IPreparedStatement, IResultSet { private List columns = new ArrayList(); + protected DBInserter dbInserter = null; // instance initializing block { @@ -57,6 +58,10 @@ public abstract class DBTable implements IPreparedStatement, IResultSet { return columns.size(); } + public final void setDBInserter(DBInserter inserter) { + dbInserter = inserter; + } + protected final void addColumn(DBColumn col) { columns.add(col); } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/ClearHandler.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/ClearHandler.java deleted file mode 100644 index ac7808f..0000000 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/ClearHandler.java +++ /dev/null @@ -1,63 +0,0 @@ -/* - * Dynamic Analyzer - * - * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. - * - * Contact: - * Jaewon Lim - * 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.handlers; - -import org.eclipse.core.commands.AbstractHandler; -import org.eclipse.core.commands.ExecutionEvent; -import org.eclipse.core.commands.ExecutionException; -import org.eclipse.swt.widgets.Display; -import org.tizen.dynamicanalyzer.common.AnalyzerManager; -import org.tizen.dynamicanalyzer.ui.page.BaseView; -import org.tizen.dynamicanalyzer.ui.page.UpdateViewTimer; -import org.tizen.dynamicanalyzer.ui.toolbar.StopLogProcessor; -import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea; -import org.tizen.dynamicanalyzer.util.WorkbenchUtil; - -public class ClearHandler extends AbstractHandler { - - public final static String ID = ClearHandler.class.getName(); - - @Override - public Object execute(ExecutionEvent event) throws ExecutionException { - UpdateViewTimer.stop(); - AnalyzerManager.clear(); -// CallStackManager.clear(); - AnalyzerManager.getWarningChecker().clear(); - StopLogProcessor.clear(); - - Display.getDefault().syncExec(new Runnable() { - @Override - public void run() { - ((BaseView) WorkbenchUtil.getViewPart(BaseView.ID)).clear(); - ToolbarArea.getInstance().clearTimer(); - } - }); - - return null; - } - -} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/CommandAction.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/CommandAction.java index efecd4a..5a4b04c 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/CommandAction.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/CommandAction.java @@ -27,18 +27,25 @@ package org.tizen.dynamicanalyzer.handlers; import java.io.File; + import org.tizen.dynamicanalyzer.common.AnalyzerConstants; +import org.tizen.dynamicanalyzer.common.DAResult; import org.tizen.dynamicanalyzer.common.Global; +import org.tizen.dynamicanalyzer.common.Global.STATE; import org.tizen.dynamicanalyzer.common.path.PathManager; import org.tizen.dynamicanalyzer.control.StartTraceManager; +import org.tizen.dynamicanalyzer.control.StopTraceManager; import org.tizen.dynamicanalyzer.database.SqlConnectionManager; import org.tizen.dynamicanalyzer.project.Project; +import org.tizen.dynamicanalyzer.shortcut.ShortCutManager; import org.tizen.dynamicanalyzer.swap.logparser.DataManagerRegistry; +import org.tizen.dynamicanalyzer.ui.timeline.TimelinePage; +import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea; import org.tizen.dynamicanalyzer.util.Logger; import org.tizen.dynamicanalyzer.utils.AnalyzerUtil; public class CommandAction { - + public static boolean save(String saveFileName) { Project project = Global.getProject(); String sourcePath = project.getSavePath(); @@ -83,11 +90,54 @@ public class CommandAction { } public static void startTrace() { - // set DA state to PREPARE_START - Global.setCurrentState(Global.STATE.PREPARE_START); - + // only when trace is not running, trace can be started + STATE curState = Global.getCurrentState(); + synchronized (curState) { + if (curState != STATE.INIT && curState != STATE.DONE) { + Logger.warning("Try to start trace though trace is not stopped completely"); + return; + } + + // set DA state to PREPARE_START + Global.setCurrentState(STATE.PREPARE_START); + } + + // change UI state + ToolbarArea.getInstance().changeUIState(STATE.PREPARE_START); + ShortCutManager.getInstance().setEnabled(false); + + // reset current project to null + Global.setProject(null); + AnalyzerUtil.changePage(TimelinePage.pageID); + // make thread to prepare start Thread thread = new Thread(new StartTraceManager()); thread.start(); } + + // stop trace with result + // if result is success, then just stop trace + // else if result is error, then show error message and stop trace + public static void stopTrace(DAResult error, boolean stopFromTarget) { + // only when trace is running, trace can be stopped + STATE curState = Global.getCurrentState(); + synchronized (curState) { + if (curState != STATE.RUNNING) { + Logger.warning("Try to stop trace though trace is not running"); + return; + } + + // set DA state to PREPARE_START + Global.setCurrentState(STATE.PREPARE_END); + } + + // change UI state + ToolbarArea.getInstance().changeUIState(STATE.PREPARE_END); + ShortCutManager.getInstance().setEnabled(false); + + // make thread to prepare start + Thread thread = new Thread(new StopTraceManager(error, stopFromTarget)); + thread.start(); + } + } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/CommonAction.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/CommonAction.java index 063f05a..e01a195 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/CommonAction.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/CommonAction.java @@ -29,19 +29,27 @@ package org.tizen.dynamicanalyzer.handlers; import java.util.List; import java.util.Map; +import org.eclipse.swt.widgets.Display; import org.tizen.dynamicanalyzer.common.AnalyzerConstants; +import org.tizen.dynamicanalyzer.common.AnalyzerManager; import org.tizen.dynamicanalyzer.common.DAResult; import org.tizen.dynamicanalyzer.common.Global; import org.tizen.dynamicanalyzer.communicator.DACommunicator; import org.tizen.dynamicanalyzer.control.ApplistManager; import org.tizen.dynamicanalyzer.model.DeviceInfo; import org.tizen.dynamicanalyzer.project.PackageInfo; +import org.tizen.dynamicanalyzer.project.Project; +import org.tizen.dynamicanalyzer.ui.page.BaseView; +import org.tizen.dynamicanalyzer.ui.page.UpdateViewTimer; +import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea; import org.tizen.dynamicanalyzer.util.Logger; +import org.tizen.dynamicanalyzer.util.WorkbenchUtil; public class CommonAction { /** * send configuration message to target and set result + * * @return true if succeed to configuration, false otherwise */ public static boolean configure() { @@ -60,9 +68,10 @@ public class CommonAction { return ret; } - + /** * check current device is valid for tracing or not + * * @return true if device is connected normally, false otherwise */ public static boolean checkDeviceValidness() { @@ -91,6 +100,7 @@ public class CommonAction { /** * check current application is valid for tracing or not + * * @return true if application is valid, false otherwise */ public static boolean checkApplicatinValidness() { @@ -120,6 +130,7 @@ public class CommonAction { /** * check configuration is performed with target or not + * * @return true if configuration to target is done, false otherwise */ public static boolean checkConfiguration() { @@ -134,5 +145,35 @@ public class CommonAction { } else { return true; } - } + } + + /** + * clear current trace result and state + */ + public static void clear() { + // stop some timer + UpdateViewTimer.stop(); + + // clear project + Project project = Global.getProject(); + if (null != project) { + synchronized (project) { + project.dispose(); + Global.setProject(null); + } + } + + // clear each data checker + AnalyzerManager.clear(); + + // reset page + // reset toolbar timer + Display.getDefault().syncExec(new Runnable() { + @Override + public void run() { + ((BaseView) WorkbenchUtil.getViewPart(BaseView.ID)).clear(); + ToolbarArea.getInstance().clearTimer(); + } + }); + } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/ExitHandler.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/ExitHandler.java index 3d863d9..29a50d3 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/ExitHandler.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/ExitHandler.java @@ -31,14 +31,14 @@ import org.eclipse.core.commands.ExecutionEvent; import org.eclipse.core.commands.ExecutionException; import org.tizen.dynamicanalyzer.common.AnalyzerManager; import org.tizen.dynamicanalyzer.common.AnalyzerShellCommands; +import org.tizen.dynamicanalyzer.common.DAResult; import org.tizen.dynamicanalyzer.communicator.CommunicatorUtils; import org.tizen.dynamicanalyzer.communicator.DACommunicator; import org.tizen.dynamicanalyzer.communicator.IDECommunicator; -import org.tizen.dynamicanalyzer.swap.logparser.SWAPLogParser; +import org.tizen.dynamicanalyzer.control.SideWorker; +import org.tizen.dynamicanalyzer.swap.logparser.LogParser; import org.tizen.dynamicanalyzer.ui.page.UpdateViewTimer; -import org.tizen.dynamicanalyzer.ui.toolbar.StopLogProcessor; import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea; -import org.tizen.dynamicanalyzer.ui.toolbar.opentrace.OpenTraceInputReader; public class ExitHandler extends AbstractHandler { @@ -46,15 +46,15 @@ public class ExitHandler extends AbstractHandler { @Override public Object execute(ExecutionEvent event) throws ExecutionException { + CommandAction.stopTrace(DAResult.SUCCESS, false); + AnalyzerManager.setExit(true); ToolbarArea.getInstance().stopTimer(); UpdateViewTimer.stop(); - SWAPLogParser.stopLogParser(); - StopLogProcessor.stopStopLogProcessThread(); + LogParser.stopForced(); + SideWorker.stop(); IDECommunicator.stopIDEcommunicatorThread(); - OpenTraceInputReader.stopOpenTraceInputReader(); - CommunicatorUtils - .execCommand(AnalyzerShellCommands.DACOMMAND_KILL_MANAGER); + CommunicatorUtils.execCommand(AnalyzerShellCommands.DACOMMAND_KILL_MANAGER); DACommunicator.pullDaemonLog(); return null; } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/OpenTraceCompleteHandler.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/OpenTraceCompleteHandler.java index 09f2d5f..aac0e8a 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/OpenTraceCompleteHandler.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/OpenTraceCompleteHandler.java @@ -31,8 +31,6 @@ import org.eclipse.core.commands.ExecutionEvent; import org.eclipse.core.commands.ExecutionException; import org.eclipse.swt.widgets.Display; import org.tizen.dynamicanalyzer.common.AnalyzerManager; -import org.tizen.dynamicanalyzer.common.Global; -import org.tizen.dynamicanalyzer.common.path.PathManager; import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea; import org.tizen.dynamicanalyzer.util.Logger; import org.tizen.dynamicanalyzer.widgets.da.view.DAPageComposite; @@ -46,12 +44,14 @@ public class OpenTraceCompleteHandler extends AbstractHandler { Display.getDefault().syncExec(new Runnable() { @Override public void run() { - if (Global.getProject().getSavePath() - .contains(PathManager.DA_TEMP_FOLDER_PATH)) { - ToolbarArea.getInstance().setMainControlEnablement(true); - } else { - ToolbarArea.getInstance().setSaveButtonEnable(false); - } +// if (Global.getProject().getSavePath() +// .contains(PathManager.DA_TEMP_FOLDER_PATH)) { +// ToolbarArea.getInstance().setAllControlState(true); +// } else { +// ToolbarArea.getInstance().setSaveButtonState(false); +// } + + ToolbarArea.getInstance().setAllControlState(true); DAPageComposite page = AnalyzerManager.getCurrentPage(); page.updateView(); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/OpenTraceHandler.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/OpenTraceHandler.java index d98327a..9eb00bb 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/OpenTraceHandler.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/OpenTraceHandler.java @@ -90,7 +90,7 @@ public class OpenTraceHandler extends AbstractHandler { OpenTraceProgressManager.getInstance().closeOpenTraceDialog( AnalyzerLabels.OPEN_TRACE_PROGRESS_LOADING_FAILED); createWarningDialog(AnalyzerLabels.OPEN_TRACE_PROGRESS_VERSION_INVALID_REMOVE); - AnalyzerUtil.executeCommand(ClearHandler.ID); + CommonAction.clear(); return null; } @@ -102,8 +102,6 @@ public class OpenTraceHandler extends AbstractHandler { DACustomCombo appCombo = ToolbarArea.getInstance().getAppCombo(); deviceCombo.setText(Global.getProject().getDevice()); appCombo.setText(Global.getProject().getAppName()); - deviceCombo.setEnabled(true); - appCombo.setEnabled(true); } }); } @@ -116,17 +114,15 @@ public class OpenTraceHandler extends AbstractHandler { OpenTraceProgressManager.getInstance().closeOpenTraceDialog( AnalyzerLabels.OPEN_TRACE_PROGRESS_LOADING_FAILED); createWarningDialog(AnalyzerLabels.OPEN_TRACE_PROGRESS_INVALID_REMOVE); - AnalyzerUtil.executeCommand(ClearHandler.ID); + CommonAction.clear(); return null; } ToolbarArea.getInstance().setTime(project.getTotalStopTime()); ToolbarArea.getInstance().setDeviceComboText(project.getDevice()); ToolbarArea.getInstance().setAppComboText(project.getAppName()); - ToolbarArea.getInstance().checkStartButtonAndAppListEnablement(); - ToolbarArea.getInstance().setRepalyButtonEnable(true); - ToolbarArea.getInstance().setSourceViewEnable(true); - ToolbarArea.getInstance().setSourceViewTooltip(AnalyzerLabels.MESSAGE_PROCESS_VIEW_SOURCE); + + ToolbarArea.getInstance().setAllControlState(true); OpenTraceProgressManager.getInstance().setProgressPercent( AnalyzerLabels.OPEN_TRACE_PROGRESS_LOADING, percent += 3); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/ReplayTraceHandler.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/ReplayManager.java similarity index 65% rename from org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/ReplayTraceHandler.java rename to org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/ReplayManager.java index 247d29c..7e73b0b 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/ReplayTraceHandler.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/ReplayManager.java @@ -27,9 +27,7 @@ package org.tizen.dynamicanalyzer.handlers; -import org.eclipse.core.commands.AbstractHandler; -import org.eclipse.core.commands.ExecutionEvent; -import org.eclipse.core.commands.ExecutionException; +import org.tizen.dynamicanalyzer.common.DAResult; import org.tizen.dynamicanalyzer.common.Global; import org.tizen.dynamicanalyzer.communicator.DACommunicator; import org.tizen.dynamicanalyzer.swap.model.DATime; @@ -40,29 +38,25 @@ import org.tizen.dynamicanalyzer.ui.toolbar.setting.data.SettingConstants; import org.tizen.dynamicanalyzer.ui.toolbar.setting.data.SettingDataManager; import org.tizen.dynamicanalyzer.util.ByteUtil; import org.tizen.dynamicanalyzer.widgets.timer.IAlarm; -import org.tizen.dynamicanalyzer.widgets.timer.TimerClock; -public class ReplayTraceHandler extends AbstractHandler { +public class ReplayManager { - public static final String ID = ReplayTraceHandler.class.getName(); - public static Integer FAILED = 1; - public static boolean isReplay = false; - public static DATime startTime = null; - public static long stopTime = -1; - public static String RECORD_DATA_FILE_NAME = "/uirecorder.xml"; //$NON-NLS-1$ + private static boolean isReplay = false; + private static DATime startTime = null; + private static long stopTime = -1; + private static String RECORD_DATA_FILE_NAME = "/uirecorder.xml"; //$NON-NLS-1$ public final static int REPLAY_OFF = 0; public final static int REPLAY_ON = 1; private static byte[] replayEvent = null; - @Override - public Object execute(ExecutionEvent event) throws ExecutionException { + public static boolean init() { if (!DACommunicator.isSWAPVersion()) { String xmlFileName = Global.getProject().getSavePath() + RECORD_DATA_FILE_NAME; if (xmlFileName == null || xmlFileName.isEmpty()) { - return FAILED; + return false; } else { isReplay = true; stopTime = Global.getProject().getReplayStopTime(); @@ -84,39 +78,42 @@ public class ReplayTraceHandler extends AbstractHandler { for (int i = 0; i < count; i++) { eventObjs = ByteUtil.concatByteArray(eventObjs, replayData.getRecordEvent().get(i) .getByteValues()); - -// Logger.debug(" sec : " -// + replayData.getRecordEvent().get(i).getEventTime().getSec() + " nano : " -// + replayData.getRecordEvent().get(i).getEventTime().getNano() + " id : " -// + replayData.getRecordEvent().get(i).getEventId() + " code : " -// + replayData.getRecordEvent().get(i).getEventCode() + " type : " -// + replayData.getRecordEvent().get(i).getEventType() + " value : " -// + replayData.getRecordEvent().get(i).getEventValue()); } replayEvent = ByteUtil.getByte(REPLAY_ON, startTime.getSec(), startTime.getNano(), count, eventObjs); } - return null; + + return true; } public static void setStopAlarm() { - if (SettingDataManager.getInstance().isOptionsSelectedFeature( - SettingConstants.FEATURE_NAME_INDEX_AUTO_STOP)) { - TimerClock timer = ToolbarArea.getInstance().getTimer(); - timer.setAlarm(stopTime, new IAlarm() { - + if (isReplay + && SettingDataManager.getInstance().isOptionsSelectedFeature( + SettingConstants.FEATURE_NAME_INDEX_AUTO_STOP)) { + ToolbarArea.getInstance().setTimerAlarm(stopTime, new IAlarm() { @Override public void action() { - ToolbarArea.getInstance().stopTrace(); - isReplay = false; - stopTime = -1; + CommandAction.stopTrace(DAResult.SUCCESS, false); + reset(); } }); } } + public static void resetStopAlarm() { + ToolbarArea.getInstance().removeTimerAlarm(); + reset(); + } + public static byte[] getReplayEvent() { return replayEvent; } + public static boolean isReplayMode() { + return isReplay; + } + + public static void reset() { + isReplay = false; + } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/StopHandler.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/StopHandler.java deleted file mode 100644 index 9a81ddf..0000000 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/StopHandler.java +++ /dev/null @@ -1,66 +0,0 @@ -/* - * Dynamic Analyzer - * - * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. - * - * Contact: - * Jaewon Lim - * 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.handlers; - -import org.eclipse.core.commands.AbstractHandler; -import org.eclipse.core.commands.ExecutionEvent; -import org.eclipse.core.commands.ExecutionException; -import org.eclipse.swt.widgets.Display; -import org.tizen.dynamicanalyzer.nl.SummaryLabels; -import org.tizen.dynamicanalyzer.ui.info.screenshot.ScreenshotView; -import org.tizen.dynamicanalyzer.ui.page.ScreenshotTabComposite; -import org.tizen.dynamicanalyzer.ui.summary.SummaryPage; -import org.tizen.dynamicanalyzer.ui.summary.leaks.LeakView; -import org.tizen.dynamicanalyzer.ui.timeline.TimelinePage; -import org.tizen.dynamicanalyzer.utils.AnalyzerUtil; -import org.tizen.dynamicanalyzer.widgets.da.view.DATabComposite; - -public class StopHandler extends AbstractHandler { - - public final static String ID = StopHandler.class.getName(); - - @Override - public Object execute(ExecutionEvent event) throws ExecutionException { - Display.getDefault().syncExec(new Runnable() { - @Override - public void run() { - DATabComposite timelineTabComp = (DATabComposite) AnalyzerUtil - .getView(TimelinePage.pageID, ScreenshotTabComposite.tabID); - ScreenshotView screenshotView = (ScreenshotView) timelineTabComp - .getView(ScreenshotTabComposite.screenshotViewID); - screenshotView.setLatestButtonEnable(false); - - LeakView leakView = (LeakView) AnalyzerUtil.getView( - SummaryPage.pageID, SummaryPage.leakViewID); - leakView.setTitle(SummaryLabels.LEAK_VIEW_TITLE_LEAK); - } - }); - return null; - } - -} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/StartHandler.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/UIAction.java similarity index 65% rename from org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/StartHandler.java rename to org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/UIAction.java index a8cc0ed..664053d 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/StartHandler.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/UIAction.java @@ -5,7 +5,6 @@ * * Contact: * Jaewon Lim - * Jooyoul Lee * Juyoung Kim * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -27,11 +26,7 @@ package org.tizen.dynamicanalyzer.handlers; -import org.eclipse.core.commands.AbstractHandler; -import org.eclipse.core.commands.ExecutionEvent; -import org.eclipse.core.commands.ExecutionException; import org.eclipse.swt.widgets.Display; -import org.tizen.dynamicanalyzer.common.AnalyzerManager; import org.tizen.dynamicanalyzer.nl.SummaryLabels; import org.tizen.dynamicanalyzer.ui.info.screenshot.ScreenshotView; import org.tizen.dynamicanalyzer.ui.page.ScreenshotTabComposite; @@ -41,30 +36,42 @@ import org.tizen.dynamicanalyzer.ui.timeline.TimelinePage; import org.tizen.dynamicanalyzer.utils.AnalyzerUtil; import org.tizen.dynamicanalyzer.widgets.da.view.DATabComposite; -public class StartHandler extends AbstractHandler { +public class UIAction { - public final static String ID = StartHandler.class.getName(); - - @Override - public Object execute(ExecutionEvent event) throws ExecutionException { + /** + * Reset UI. Disable lastest button in screenshot view, and change leak view title. + */ + public static void resetUI() { Display.getDefault().syncExec(new Runnable() { @Override public void run() { - DATabComposite timelineTabComp = (DATabComposite) AnalyzerUtil - .getView(TimelinePage.pageID, - ScreenshotTabComposite.tabID); + DATabComposite timelineTabComp = (DATabComposite) AnalyzerUtil.getView( + TimelinePage.pageID, ScreenshotTabComposite.tabID); ScreenshotView screenshotView = (ScreenshotView) timelineTabComp .getView(ScreenshotTabComposite.screenshotViewID); screenshotView.setLatestButtonEnable(false); - LeakView leakView = (LeakView) AnalyzerUtil.getView( - SummaryPage.pageID, SummaryPage.leakViewID); + LeakView leakView = (LeakView) AnalyzerUtil.getView(SummaryPage.pageID, + SummaryPage.leakViewID); leakView.setTitle(SummaryLabels.LEAK_VIEW_TITLE_LEAK_CANDIDATE); } }); + } - // start screenshot timer - AnalyzerManager.startScreenshotTimer(); - return null; + public static void summarizeUI() { + Display.getDefault().syncExec(new Runnable() { + @Override + public void run() { + DATabComposite timelineTabComp = (DATabComposite) AnalyzerUtil.getView( + TimelinePage.pageID, ScreenshotTabComposite.tabID); + ScreenshotView screenshotView = (ScreenshotView) timelineTabComp + .getView(ScreenshotTabComposite.screenshotViewID); + screenshotView.setLatestButtonEnable(false); + + LeakView leakView = (LeakView) AnalyzerUtil.getView(SummaryPage.pageID, + SummaryPage.leakViewID); + leakView.setTitle(SummaryLabels.LEAK_VIEW_TITLE_LEAK); + } + }); } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/listeners/AnalyzerPerspectiveListener.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/listeners/AnalyzerPerspectiveListener.java index b3ca1fe..a3943ef 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/listeners/AnalyzerPerspectiveListener.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/listeners/AnalyzerPerspectiveListener.java @@ -31,10 +31,13 @@ import org.eclipse.ui.IPerspectiveDescriptor; import org.eclipse.ui.IWorkbenchPage; import org.eclipse.ui.PerspectiveAdapter; import org.tizen.dynamicanalyzer.callback.ExecutionCallbackManager; +import org.tizen.dynamicanalyzer.common.Global; import org.tizen.dynamicanalyzer.common.PostWindowOpenCallback; import org.tizen.dynamicanalyzer.common.PreWindowShellCloseCallback; +import org.tizen.dynamicanalyzer.common.Global.STATE; import org.tizen.dynamicanalyzer.communicator.DACommunicator; import org.tizen.dynamicanalyzer.communicator.IDECommunicator; +import org.tizen.dynamicanalyzer.control.SideWorker; import org.tizen.dynamicanalyzer.swap.platform.BinarySettingManager; import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea; import org.tizen.dynamicanalyzer.ui.toolbar.setting.data.SettingDataManager; @@ -58,6 +61,7 @@ public class AnalyzerPerspectiveListener extends PerspectiveAdapter { Logger.performance("TEST", "DA Start", "Target Binary Setting"); IDECommunicator.startIDECommunicatorThread(); + SideWorker.start(); Logger.performance("TEST", "DA Start", "Start IDE Communicator"); SettingDataManager.getInstance(); @@ -69,6 +73,7 @@ public class AnalyzerPerspectiveListener extends PerspectiveAdapter { ExecutionCallbackManager.WINDOWADVISOR_PREWINDOWCLOSE, new PreWindowShellCloseCallback()); + Global.setCurrentState(STATE.INIT); init = true; } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/listeners/SummaryMouseDoubleClickListener.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/listeners/SummaryMouseDoubleClickListener.java index 285434f..e1f045c 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/listeners/SummaryMouseDoubleClickListener.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/listeners/SummaryMouseDoubleClickListener.java @@ -109,7 +109,7 @@ public class SummaryMouseDoubleClickListener implements MouseListener { // return; // } - switch (data.getId()) { + switch (data.getMsgID()) { case DataChannelConstants.MSG_PROBE_FILE: pageId = FilePage.pageID; break; diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/listeners/TableTooltipListener.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/listeners/TableTooltipListener.java index ac70ee8..1432da3 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/listeners/TableTooltipListener.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/listeners/TableTooltipListener.java @@ -96,7 +96,7 @@ public class TableTooltipListener implements Listener { } public void handleEvent(Event event) { - if (!ToolbarArea.getInstance().getSourceViewEnable()) { + if (!ToolbarArea.getInstance().getButtonEnabled(ToolbarArea.SOURCE_BUTTON)) { return; } @@ -219,8 +219,7 @@ public class TableTooltipListener implements Listener { break; case AnalyzerConstants.TYPE_TABLE_CALLTRACE: List calltraceData = tableData.getData(); - addr = (Long) calltraceData - .get(FunctionEntryDBTable.COLUMN.CALLERPCADDR.index); + addr = (Long) calltraceData.get(FunctionEntryDBTable.COLUMN.CALLERPCADDR.index); pid = (Integer) calltraceData.get(FunctionEntryDBTable.COLUMN.PID.index); time = (Long) calltraceData.get(FunctionEntryDBTable.COLUMN.STARTTIME.index); break; @@ -449,12 +448,10 @@ public class TableTooltipListener implements Listener { String filePath = null; String libName = getLibPath(item); - BinarySettingData binData = BinarySettingManager.getInstance() - .getBinarySetting(libName); + BinarySettingData binData = BinarySettingManager.getInstance().getBinarySetting(libName); if (null != binData) { - if (null != binData.getUserSourceDir() - && !binData.getUserSourceDir().isEmpty()) { + if (null != binData.getUserSourceDir() && !binData.getUserSourceDir().isEmpty()) { String fileName = getSourceFilePath(sourceLine.getFilePath()); filePath = binData.getUserSourceDir() + File.separator + fileName; } else { @@ -492,11 +489,11 @@ public class TableTooltipListener implements Listener { Point pt = grid.toDisplay(x, y); Rectangle displayRect = Display.getCurrent().getBounds(); // 1. right side check! - pt.x = ((pt.x + size.x) > displayRect.width) ? pt.x - size.x - TOOLTIP_OFFSET - : pt.x + TOOLTIP_OFFSET; + pt.x = ((pt.x + size.x) > displayRect.width) ? pt.x - size.x - TOOLTIP_OFFSET : pt.x + + TOOLTIP_OFFSET; // 2. bottom check! - pt.y = ((pt.y + size.y) > displayRect.height) ? pt.y - size.y - TOOLTIP_OFFSET - : pt.y + TOOLTIP_OFFSET; + pt.y = ((pt.y + size.y) > displayRect.height) ? pt.y - size.y - TOOLTIP_OFFSET : pt.y + + TOOLTIP_OFFSET; tooltip.setBounds(pt.x, pt.y, size.x, size.y); tooltip.setVisible(true); } @@ -530,10 +527,8 @@ public class TableTooltipListener implements Listener { break; case AnalyzerConstants.TYPE_TABLE_CALLTRACE: List calltraceData = tableData.getData(); - int binaryId = (Integer) calltraceData - .get(FunctionEntryDBTable.COLUMN.BINARYID.index); - BinaryInfo binInfo = Global.getProject().getDeviceStatusInfo() - .getBinaryInfo(binaryId); + int binaryId = (Integer) calltraceData.get(FunctionEntryDBTable.COLUMN.BINARYID.index); + BinaryInfo binInfo = Global.getProject().getDeviceStatusInfo().getBinaryInfo(binaryId); libName = binInfo.getTargetBinaryPath(); break; default: // normal @@ -555,16 +550,15 @@ public class TableTooltipListener implements Listener { return sl; } - BinaryInfo binInfo = project.getDeviceStatusInfo().getBinaryInfo( - libobj.getBinaryID()); + BinaryInfo binInfo = project.getDeviceStatusInfo().getBinaryInfo(libobj.getBinaryID()); boolean isPieBuild = (binInfo.getType() == 1) ? true : false; String baseAddr = null; String path = null; baseAddr = Long.toString(libobj.getLowestAddress()); - BinarySettingData binData = BinarySettingManager.getInstance() - .getBinarySetting(binInfo.getTargetBinaryPath()); + BinarySettingData binData = BinarySettingManager.getInstance().getBinarySetting( + binInfo.getTargetBinaryPath()); if (null != binData) { // binary for the address is set in binary setting String debugPath = binData.getDebugFilePath(); if (null != debugPath && !debugPath.isEmpty()) { diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/logparser/InsertLogQueue.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/logparser/InsertLogQueue.java deleted file mode 100644 index 98982ab..0000000 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/logparser/InsertLogQueue.java +++ /dev/null @@ -1,101 +0,0 @@ -/* - * Dynamic Analyzer - * - * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. - * - * Contact: - * Jaewon Lim - * 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.logparser; - -import java.util.ArrayList; -import java.util.List; - -import org.tizen.dynamicanalyzer.common.AnalyzerManager; -import org.tizen.dynamicanalyzer.swap.logparser.LogPackage; -import org.tizen.dynamicanalyzer.util.Logger; - -; - -public class InsertLogQueue { - private static final int FULL_COUNT = 10000; - public boolean isWait = false; - List logs = null; - - private List getLogs() { - if (null == logs) { - logs = new ArrayList(); - } - return logs; - } - - public synchronized LogPackage getFirstLog() { - while (isEmpty()) { - if (AnalyzerManager.isLogParsingComplete()) { - return null; - } - try { - wait(); - } catch (InterruptedException e) { - Logger.debug("insert log queue interrupt called!!"); //$NON-NLS-1$ - continue; - } - } - - LogPackage output = logs.get(0); - logs.remove(0); - notifyAll(); - return output; - } - - public synchronized void push(LogPackage input) { - while (isFull()) { - try { - wait(); - } catch (InterruptedException e) { - e.printStackTrace(); - break; - } - } - getLogs().add(input); - notifyAll(); - } - - public boolean isEmpty() { - return getLogs().isEmpty(); - } - - private boolean isFull() { - if (size() > FULL_COUNT) { - return true; - } - return false; - } - - public int size() { - return getLogs().size(); - } - - public void clear() { - getLogs().clear(); - } -} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/logparser/LogListQueue.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/logparser/LogListQueue.java deleted file mode 100644 index 4f30ef7..0000000 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/logparser/LogListQueue.java +++ /dev/null @@ -1,94 +0,0 @@ -/* - * Dynamic Analyzer - * - * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. - * - * Contact: - * Jaewon Lim - * 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.logparser; - -import java.util.ArrayList; -import java.util.List; - -import org.tizen.dynamicanalyzer.common.AnalyzerManager; -import org.tizen.dynamicanalyzer.swap.model.data.LogData; - -public class LogListQueue { - private List> data = null; - - public LogListQueue() { - data = new ArrayList>(); - } - - public synchronized List getFirst() { - while (isEmpty()) { - if (AnalyzerManager.isLogParsingComplete()) { - return null; - } - try { - wait(); - } catch (InterruptedException e) { - e.printStackTrace(); - } - } - List output = data.get(0); - data.remove(0); - notifyAll(); - return output; - } - - public synchronized void putLog(List input) { - while (isFull()) { - try { - wait(); - } catch (InterruptedException e) { - e.printStackTrace(); - break; - } - } - data.add(input); - notifyAll(); - } - - public boolean isEmpty() { - if (null == data) { - data = new ArrayList>(); - } - return data.isEmpty(); - } - - private boolean isFull() { - if (size() > 10000) { - return true; - } - return false; - } - - public int size() { - return data.size(); - } - - public void clear() { - data.clear(); - } -} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/logparser/LogPackage.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/logparser/LogPackage.java deleted file mode 100644 index 43815a7..0000000 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/logparser/LogPackage.java +++ /dev/null @@ -1,99 +0,0 @@ -/* - * Dynamic Analyzer - * - * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. - * - * Contact: - * Jaewon Lim - * 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.logparser; - -import java.util.HashMap; -import java.util.List; - - -public class LogPackage { - private HashMap logMap; - - public void clear() - { - getLogMap().clear(); - } - - public LogPackage() { - logMap = new HashMap(); - } - - private HashMap getLogMap() - { - if (null == logMap) - { - logMap = new HashMap(); - } - return logMap; - } - public boolean isEmpty() - { - return getLogMap().isEmpty(); - } - - public void setLogs(int id, List input) { - Logs logs = getLogMap().get(id); - if (null == logs) - { - logs = new Logs(id); - logMap.put(id, logs); - } - logs.getLogs().add(input); - } - - public void setLogs(int id, Logs logs) - { - if (null != getLogMap().get(id)) - { - logMap.remove(id); - } - logMap.put(id, logs); - } - - public Logs getLogs(int id) - { - return getLogMap().get(id); - } - - public void putLogs(Logs logs) - { - if (null != logs) - { - int id = logs.getId(); - Logs base = getLogMap().get(id); - if (null == base) - { - logMap.put(id, logs); - } - else - { - base.getLogs().addAll(logs.getLogs()); - } - } - } -} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/logparser/LogQueue.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/logparser/LogQueue.java deleted file mode 100755 index aa6ae49..0000000 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/logparser/LogQueue.java +++ /dev/null @@ -1,100 +0,0 @@ -/* - * Dynamic Analyzer - * - * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. - * - * Contact: - * Jaewon Lim - * 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.logparser; - -import java.util.ArrayList; -import java.util.List; - -import org.tizen.dynamicanalyzer.common.AnalyzerManager; -import org.tizen.dynamicanalyzer.util.Logger; - -/** log queue model **/ -public class LogQueue { - private static final int FULL_COUNT = 10000; - private List> data = null; - - public LogQueue() { - data = new ArrayList>(); - } - - public synchronized List getFirst() { - while (isEmpty()) { - try { - if (!AnalyzerManager.isRunning()) { - return null; - } - wait(); - } catch (InterruptedException e) { - Logger.debug("log queue interrupt!!"); //$NON-NLS-1$ - continue; - } - } - - List output = data.get(0); - data.remove(0); - notifyAll(); - return output; - } - - public synchronized void putLog(List input) { - while (isFull()) { - try { - wait(); - } catch (InterruptedException e) { - // never reach here! - e.printStackTrace(); - break; - } - } - - data.add(input); - notifyAll(); - } - - public boolean isEmpty() { - if (null == data) { - data = new ArrayList>(); - } - return data.isEmpty(); - } - - public boolean isFull() { - if (size() > FULL_COUNT) { - return true; - } - return false; - } - - public int size() { - return data.size(); - } - - public void clear() { - data.clear(); - } -} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/logparser/Logs.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/logparser/Logs.java deleted file mode 100644 index ac9e531..0000000 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/logparser/Logs.java +++ /dev/null @@ -1,73 +0,0 @@ -/* - * Dynamic Analyzer - * - * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. - * - * Contact: - * Jaewon Lim - * 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.logparser; - -import java.util.ArrayList; -import java.util.List; - -public class Logs { - private List> logs; - int logCenterId; - - public Logs(int id) { - logs = new ArrayList>(); - logCenterId = id; - } - - public int getId() { - return logCenterId; - } - - // getLogs -> getRawLogs - public List> getLogs() { - if (null == logs) { - logs = new ArrayList>(); - } - return logs; - } - - public void setLogs(List> input) { - logs = input; - } - - public void setLogCenterId(int id) { - logCenterId = id; - } - - // cloneLogs -> getLogs - public List> getCloneLogs() { - List> newLogs = new ArrayList>(); - int size = logs.size(); - for (int i = 0; i < size; i++) { - List newLog = new ArrayList(); - newLog.addAll(logs.get(i)); - newLogs.add(newLog); - } - return newLogs; - } -} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/model/StreamElement.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/model/StreamElement.java deleted file mode 100644 index b63eafa..0000000 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/model/StreamElement.java +++ /dev/null @@ -1,41 +0,0 @@ -/* - * Dynamic Analyzer - * - * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. - * - * Contact: - * Jaewon Lim - * 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.model; - -// this class is parent class of data class which is element of blocking queue. -// this class has methods to confirm that is end of stream or not -public abstract class StreamElement { - private boolean endOfStream = false; - - public final boolean isEndOfStream() { - return endOfStream; - } - - public final void setEndOfStream() { - endOfStream = true; - } -} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/nl/UserErrorWarningLabels.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/nl/UserErrorWarningLabels.java index 64f7a18..ecf953d 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/nl/UserErrorWarningLabels.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/nl/UserErrorWarningLabels.java @@ -44,8 +44,13 @@ public class UserErrorWarningLabels extends NLS { public static String ERROR_UNSUPPORTED_APPLICATION; public static String ERROR_SETTING_FAILED; + public static String ERROR_CONNECTION_CLOSED; + + public static String ERROR_INTERNAL_REASON; public static String ERROR_BY_UNKNOWN_REASON; + + public static String ERROR_OUT_OF_MEMORY; public static String WARNING_PATH_NOT_FOUND; public static String WARNING_FILE_NOT_FOUND; @@ -53,6 +58,8 @@ public class UserErrorWarningLabels extends NLS { public static String WARNING_RUNNING_PROCESS_LIMIT; public static String WARNING_OVERHEAD_EXPLODE; + public static String WARNING_USER_CANCEL; + static { NLS.initializeMessages(BUNDLE_NAME, UserErrorWarningLabels.class); } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/nl/UserErrorWarningLabels.properties b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/nl/UserErrorWarningLabels.properties index 0cf0aad..9a196eb 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/nl/UserErrorWarningLabels.properties +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/nl/UserErrorWarningLabels.properties @@ -11,11 +11,18 @@ ERROR_NONEXIST_APPLICATION=does not exist in device.\nPlease check that the appl ERROR_UNSUPPORTED_APPLICATION=is unsupported application. ERROR_SETTING_FAILED=Configuration is failed. +ERROR_CONNECTION_CLOSED=Connection with target device is closed.\nPlease check the connection with device. + +ERROR_INTERNAL_REASON=Failed by internal reason.\nPlease try again or restart DA. ERROR_BY_UNKNOWN_REASON=Failed by unknown reason. +ERROR_OUT_OF_MEMORY=Out of memory. + WARNING_PATH_NOT_FOUND=Path cannot be found. WARNING_FILE_NOT_FOUND=File cannot be found. WARNING_RUNNING_PROCESS_LIMIT=Only some limited features (System, Function profiling / sampling) can be worked in Running process tracing. WARNING_OVERHEAD_EXPLODE=Tracing overhead is too heavy to show the accurate \nresult. Please except some features in Settings to \nreduce overhead. + +WARNING_USER_CANCEL=Operation is canceled by user. \ No newline at end of file diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/project/ProcessInformation.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/project/ProcessInformation.java index 5dad8f7..e14feff 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/project/ProcessInformation.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/project/ProcessInformation.java @@ -32,8 +32,10 @@ import java.util.List; import java.util.Map; import java.util.NavigableMap; import java.util.TreeMap; +import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.atomic.AtomicInteger; +import org.tizen.dynamicanalyzer.common.AnalyzerConstants; import org.tizen.dynamicanalyzer.communicator.DACommunicator; import org.tizen.dynamicanalyzer.database.DBTable; import org.tizen.dynamicanalyzer.database.SqlConnectionManager; @@ -60,6 +62,10 @@ public class ProcessInformation { private NavigableMap processMemSnapshots = new TreeMap(); private boolean isMapping = true; + // not saved data + // temporary function address-id map + private Map funcIDMap = null; + public int getPid() { return pid; } @@ -186,6 +192,31 @@ public class ProcessInformation { return isMapping; } + private Map getFuncIDMap() { + if (funcIDMap == null) { + synchronized (this) { + if (funcIDMap == null) { + funcIDMap = new ConcurrentHashMap(); + } + } + } + + return funcIDMap; + } + + public int getFunctionID(long address) { + Integer id = getFuncIDMap().get(Long.valueOf(address)); + if (id == null) { + return AnalyzerConstants.INVALID_INDEX; + } else { + return id.intValue(); + } + } + + public void putFunctionID(long address, int funcID) { + getFuncIDMap().put(Long.valueOf(address), Integer.valueOf(funcID)); + } + public void saveMemoryMap(DBTable table) { for (Map.Entry entry : processMemSnapshots.entrySet()) { entry.getValue().saveMemoryMap(table); 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 01e23fe..477b73e 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/project/Project.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/project/Project.java @@ -49,8 +49,9 @@ import org.tizen.dynamicanalyzer.common.AnalyzerConstants; import org.tizen.dynamicanalyzer.common.Global; import org.tizen.dynamicanalyzer.common.path.PathConstants; import org.tizen.dynamicanalyzer.common.path.PathManager; -import org.tizen.dynamicanalyzer.communicator.DACommunicator; import org.tizen.dynamicanalyzer.constant.CommonConstants; +import org.tizen.dynamicanalyzer.control.IProgress; +import org.tizen.dynamicanalyzer.control.ProgressTable.STAGE; import org.tizen.dynamicanalyzer.database.DBTableRegistry; import org.tizen.dynamicanalyzer.database.SqlConnectionManager; import org.tizen.dynamicanalyzer.model.DeviceInfo; @@ -61,10 +62,10 @@ import org.tizen.dynamicanalyzer.project.data.ProcessInfoDBTable; import org.tizen.dynamicanalyzer.swap.channel.control.RunTimeConfiguration; import org.tizen.dynamicanalyzer.swap.model.DATime; import org.tizen.dynamicanalyzer.ui.page.BaseView; -import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea; import org.tizen.dynamicanalyzer.util.CommonUtil; import org.tizen.dynamicanalyzer.util.Logger; import org.tizen.dynamicanalyzer.util.WorkbenchUtil; +import org.tizen.dynamicanalyzer.utils.AnalyzerUtil; public class Project { private static final ProcessInfoDBTable processInfoTable; @@ -113,10 +114,13 @@ public class Project { private DeviceStatusInfo targetDeviceStatusInfo = null; private AppInfo targetApplicationInfo = null; - // temporary list for image info (not to save) + // following data will not be saved + + // temporary list for image info private NavigableMap imageInfos = new TreeMap(); - - private int seqRotation = -1; + + private int seqRotation = 0; + private int activeProcessCount = 0; static { // register DB table @@ -230,15 +234,27 @@ public class Project { public void setSavePath(String savePath) { this.savePath = savePath; } - + public int getSeqRotation() { return seqRotation; } - + public void incSeqRotation() { seqRotation++; } + public int getActiveProcessCount() { + return activeProcessCount; + } + + public void incActiveProcessCount() { + activeProcessCount++; + } + + public void descActiveProcessCount() { + activeProcessCount--; + } + // add and getter of config history public void addConfigHistory(RunTimeConfiguration config) { if (config != null) { @@ -405,32 +421,41 @@ public class Project { } } - // this initForTrace() function called only when trace is started. - public void initForTrace() { - if (null == Global.getCurrentApplication()) { - String comboText = ToolbarArea.getInstance().getAppCombo().getText(); - PackageInfo pkgInfo = DACommunicator.getPkgInfoByLabel(comboText); - Global.setCurrentApplication(pkgInfo); - Global.getCurrentDeviceInfo().getCommunicator().onAppSelected(pkgInfo); + public int getBinaryID(int pid, long time, long address) { + int binID = -1; + ProcessInformation process = getProcessInformation(pid); + if (null == process) { + Logger.warning("Failed to get binaryID (process info does not exist) for pid : " + pid); + } else if (time > 0) { + LibraryObject obj = null; + ProcessMemoryMap pmap = process.getProcessMemoryMap(time); + if (pmap == null || (obj = pmap.getLibraryByAddress(address)) == null) { + binID = -1; + } else { + binID = obj.getBinaryID(); + } } - setProtocolVersion(Global.getCurrentDeviceInfo().getTargetVersion()); + return binID; + } - setDeviceStatusInfo(Global.getCurrentDeviceInfo().getDeviceStatusInfo()); - setApplicationInfo(Global.getCurrentApplication().getMainApp()); + // this initForTrace() function called only when trace is started. + // current device and application should be validated before calling this method. + public void init(IProgress progress) throws InterruptedException { + PackageInfo curApp = Global.getCurrentApplication(); + DeviceInfo curDev = Global.getCurrentDeviceInfo(); + + setProtocolVersion(curDev.getTargetVersion()); + setDeviceStatusInfo(curDev.getDeviceStatusInfo()); + setApplicationInfo(curApp.getMainApp()); RunTimeConfiguration currentConfig = Global.getCurrentConfiguration(); if (currentConfig != null) { addConfigHistory(currentConfig); } - setAppName(Global.getCurrentApplication().getMainApp().getLabel()); - setPackageID(Global.getCurrentApplication().getPackageId()); - DeviceInfo device = Global.getCurrentDeviceInfo(); - String deviceSerial = null; - if (device != null) { - deviceSerial = device.getIDevice().getSerialNumber(); - } - + setAppName(curApp.getMainApp().getLabel()); + setPackageID(curApp.getPackageId()); + String deviceSerial = curDev.getIDevice().getSerialNumber(); if (null != deviceSerial && !deviceSerial.isEmpty()) { setDevice(deviceSerial); } else { @@ -465,24 +490,40 @@ public class Project { } } } + progress.checkCancel(); + progress.setStageComplete(STAGE.CREATE_PROJECT); - Global.setProject(this); - - // close previous database connection + // make sure previous database connection is closed SqlConnectionManager.closeConnection(); // establish database connection SqlConnectionManager.establishConnection(getSavePath() + File.separator + AnalyzerConstants.DATABASE_NAME); + progress.checkCancel(); + progress.setStageComplete(STAGE.ESTABLISH_DB); + // create table DBTableRegistry.createDBTables(); + + progress.checkCancel(); + progress.setStageComplete(STAGE.CREATE_DBTABLE); } public void dispose() { // close previous database connection SqlConnectionManager.closeConnection(); + String sourcePath = getSavePath(); + if (null != sourcePath && !sourcePath.isEmpty()) { + boolean success = AnalyzerUtil.deleteFile(new File(sourcePath)); + if (success) { + Logger.debug("invalid project deleted!"); //$NON-NLS-1$ + } else { + Logger.debug("invalid project delete fail..."); //$NON-NLS-1$ + } + } + // initialize variable version = null; protocolVersion = null; @@ -574,13 +615,13 @@ public class Project { List list = bv.getMainTab().getViewIDList(); for (int i = 0; i < list.size(); i++) { buffer.append(list.get(i)); - if (i < list.size() -1) { + if (i < list.size() - 1) { buffer.append(CommonConstants.COMMA); } } return buffer.toString(); } - + private void saveTargetStatusInfo(BufferedWriter writer) throws IOException { writer.write(DEVICE_SECTION + CommonConstants.NEW_LINE); targetDeviceStatusInfo.savePrimitive(writer); @@ -752,7 +793,7 @@ public class Project { bv.addTabViewPage(list[i]); } } - + private void openTargetStatusInfo(BufferedReader in) throws IOException { String content = in.readLine(); if (content != null && content.equals(DEVICE_SECTION)) { diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/shortcut/ShortCutKeyBindingHandler.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/shortcut/ShortCutKeyBindingHandler.java index 17bab03..a669fd1 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/shortcut/ShortCutKeyBindingHandler.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/shortcut/ShortCutKeyBindingHandler.java @@ -31,9 +31,8 @@ import org.eclipse.core.commands.ExecutionException; import org.eclipse.swt.SWT; import org.eclipse.swt.widgets.Event; import org.eclipse.swt.widgets.Shell; -import org.tizen.dynamicanalyzer.common.AnalyzerConstants; import org.tizen.dynamicanalyzer.common.AnalyzerManager; -import org.tizen.dynamicanalyzer.handlers.ReplayTraceHandler; +import org.tizen.dynamicanalyzer.handlers.ReplayManager; import org.tizen.dynamicanalyzer.ui.file.FilePage; import org.tizen.dynamicanalyzer.ui.kernel.KernelPage; import org.tizen.dynamicanalyzer.ui.network.NetworkPage; @@ -54,8 +53,6 @@ import org.tizen.dynamicanalyzer.util.CommonUtil; import org.tizen.dynamicanalyzer.util.Logger; import org.tizen.dynamicanalyzer.util.WorkbenchUtil; import org.tizen.dynamicanalyzer.utils.AnalyzerUtil; -import org.tizen.dynamicanalyzer.widgets.button.DACustomButton; -import org.tizen.dynamicanalyzer.widgets.button.toggle.DACustomToggleButton; public class ShortCutKeyBindingHandler extends AbstractHandler { private int CTRL_STATE_MASK = SWT.CTRL; @@ -69,35 +66,33 @@ public class ShortCutKeyBindingHandler extends AbstractHandler { private static int KEY_7 = 55; private static int KEY_8 = 56; private static int KEY_9 = 57; - + @Override public Object execute(ExecutionEvent event) throws ExecutionException { - Event e = (Event)event.getTrigger(); + Event e = (Event) event.getTrigger(); ShortCutManager instance = ShortCutManager.getInstance(); - boolean enabled = instance.isEnabled(); + boolean enabled = instance.isEnabled(); if (CommonUtil.isMac()) { CTRL_STATE_MASK = SWT.COMMAND; } - + if (!enabled) { return null; } - + if (e.keyCode == SWT.F1) { Logger.debug("about"); Shell shell = WorkbenchUtil.getWorkbenchWindow().getShell(); - AboutDialog dialog = new AboutDialog(shell); + AboutDialog dialog = new AboutDialog(shell); dialog.open(); } else if (e.keyCode == SWT.F2) { Logger.debug("configuration"); Shell shell = WorkbenchUtil.getWorkbenchWindow().getShell(); - SettingDialog dialog = new SettingDialog(shell); + SettingDialog dialog = new SettingDialog(shell); dialog.open(); } else if (e.keyCode == SWT.F3) { Logger.debug("view source toggle"); - DACustomToggleButton button = (DACustomToggleButton) ToolbarArea - .getInstance().getButton(ToolbarArea.SOURCE_BUTTON); - button.setToggled(!button.isToggled()); + ToolbarArea.getInstance().toggleSourceView(); } // ctrl + number 1 ~ 6 page else if (e.stateMask == CTRL_STATE_MASK && e.keyCode == KEY_1) { @@ -155,26 +150,18 @@ public class ShortCutKeyBindingHandler extends AbstractHandler { // s else if (e.stateMask == CTRL_STATE_MASK && e.keyCode == 115) { Logger.debug("save trace"); - if (ToolbarArea.getInstance().getButton(ToolbarArea.SAVE_BUTTON) - .isButtonEnabled()) { + if (ToolbarArea.getInstance().getButtonEnabled(ToolbarArea.SAVE_BUTTON)) { Shell shell = WorkbenchUtil.getWorkbenchWindow().getShell(); SaveAsDialog dialog = new SaveAsDialog(shell); - Object result = dialog.open(); - if (result != null) { - ToolbarArea.getInstance() - .getButton(ToolbarArea.SAVE_BUTTON) - .setButtonEnabled(false); - } + dialog.open(); } } // p else if (e.stateMask == CTRL_STATE_MASK && e.keyCode == 112) { Logger.debug("replay "); if (!AnalyzerManager.isRunning()) { - DACustomButton button = (DACustomButton) ToolbarArea - .getInstance().getButton(ToolbarArea.REPLAY_BUTTON); - if (button.isButtonEnabled()) { - if (AnalyzerUtil.executeCommand(ReplayTraceHandler.ID) == AnalyzerConstants.SUCCESS) { + if (ToolbarArea.getInstance().getButtonEnabled(ToolbarArea.REPLAY_BUTTON)) { + if (ReplayManager.init()) { ToolbarArea.getInstance().startTrace(); } } @@ -200,8 +187,8 @@ public class ShortCutKeyBindingHandler extends AbstractHandler { dialog.open(); } } - + return null; - - } + + } } 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 5d79cd6..aa9baab 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 @@ -30,12 +30,12 @@ package org.tizen.dynamicanalyzer.swap.callstack; import static org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants.MSG_FUNCTION_ENTRY; import static org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants.MSG_FUNCTION_EXIT; +import java.sql.ResultSet; +import java.sql.SQLException; import java.util.ArrayList; import java.util.List; import java.util.Map; import java.util.NavigableMap; -import java.sql.ResultSet; -import java.sql.SQLException; import org.tizen.dynamicanalyzer.common.AnalyzerConstants; import org.tizen.dynamicanalyzer.common.Global; @@ -112,7 +112,7 @@ public class SWAPCallStackManager extends BaseCallstackManager { addrMap.put(callerAddr, callerCallstackUnit); } - int eventType = log.getId(); + int eventType = log.getMsgID(); if (eventType == MSG_FUNCTION_ENTRY) { if (size == 0) { userCallstack.add(new CallStackItem(selfCallstackUnit, time)); @@ -236,7 +236,7 @@ public class SWAPCallStackManager extends BaseCallstackManager { addrMap.put(callerAddr, callerCallstackUnit); } - int eventType = pData.getId(); + int eventType = pData.getMsgID(); if (eventType == MSG_FUNCTION_ENTRY) { if (size == 0) { userCallstack.add(new CallStackItem(selfCallstackUnit, time)); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/channel/data/DataChannelConstants.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/channel/data/DataChannelConstants.java index 85d9c5e..af68c8a 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/channel/data/DataChannelConstants.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/channel/data/DataChannelConstants.java @@ -28,7 +28,19 @@ package org.tizen.dynamicanalyzer.swap.channel.data; public class DataChannelConstants { public static final int BUFFER_SIZE = 1024; + + public static final int HEADER_SIZE = 20; + + public static final int MSGID_INDEX = 0; + public static final int SEQNUM_INDEX = 4; + public static final int TIME_SEC_INDEX = 8; + public static final int TIME_NANO_INDEX = 12; + public static final int PAYLOADLEN_INDEX = 16; + + // sequence number + public static final long MAX_SEQ_NUMBER = 0xFFFFFFFFL; + // message id by data channel from target public final static int MSG_DATA_PROCESS_INFO = 0x0001; public final static int MSG_DATA_TERMINATE = 0x0002; public final static int MSG_DATA_ERROR = 0x0003; 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 659e194..56b3274 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 @@ -27,14 +27,14 @@ package org.tizen.dynamicanalyzer.swap.communicator; -import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_CONFIG; import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_BINARY_INFO_ACK; +import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_CONFIG; import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_CONFIG_ACK; +import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_GET_PROCESS_ADD_INFO_ACK; import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_KEEP_ALIVE_ACK; import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_START_ACK; import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_STOP_ACK; import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_TARGET_INFO_ACK; -import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_GET_PROCESS_ADD_INFO_ACK; import static org.tizen.dynamicanalyzer.constant.CommonConstants.INT_SIZE; import static org.tizen.dynamicanalyzer.constant.CommonConstants.LONG_SIZE; @@ -63,16 +63,17 @@ import org.eclipse.swt.widgets.Shell; import org.tizen.dynamicanalyzer.common.AnalyzerConstants; import org.tizen.dynamicanalyzer.common.AnalyzerManager; import org.tizen.dynamicanalyzer.common.AnalyzerShellCommands; +import org.tizen.dynamicanalyzer.common.DAResult; import org.tizen.dynamicanalyzer.common.ElfSymbolExtractor; import org.tizen.dynamicanalyzer.common.Global; -import org.tizen.dynamicanalyzer.common.DAResult; import org.tizen.dynamicanalyzer.common.path.PathManager; import org.tizen.dynamicanalyzer.communicator.BaseCommunicator; import org.tizen.dynamicanalyzer.communicator.CommunicatorUtils; import org.tizen.dynamicanalyzer.communicator.DACommunicator; import org.tizen.dynamicanalyzer.constant.CommonConstants; import org.tizen.dynamicanalyzer.control.ApplistManager; -import org.tizen.dynamicanalyzer.handlers.ReplayTraceHandler; +import org.tizen.dynamicanalyzer.control.IProgress; +import org.tizen.dynamicanalyzer.handlers.ReplayManager; import org.tizen.dynamicanalyzer.model.AddrSymbolPair; import org.tizen.dynamicanalyzer.model.DeviceInfo; import org.tizen.dynamicanalyzer.nl.UserErrorWarningLabels; @@ -85,15 +86,11 @@ import org.tizen.dynamicanalyzer.swap.channel.control.ApplicationInst; import org.tizen.dynamicanalyzer.swap.channel.control.FunctionInst; import org.tizen.dynamicanalyzer.swap.channel.control.RunTimeConfiguration; import org.tizen.dynamicanalyzer.swap.channel.control.UserSpaceInst; -import org.tizen.dynamicanalyzer.swap.logparser.DataManagerRegistry; -import org.tizen.dynamicanalyzer.swap.logparser.SWAPLogParser; import org.tizen.dynamicanalyzer.swap.model.DATime; import org.tizen.dynamicanalyzer.swap.model.data.LogDataUtils; import org.tizen.dynamicanalyzer.swap.platform.BinarySettingData; import org.tizen.dynamicanalyzer.ui.info.screenshot.EmulatorScreenshot; import org.tizen.dynamicanalyzer.ui.info.screenshot.SocketClient; -import org.tizen.dynamicanalyzer.ui.page.UpdateViewTimer; -import org.tizen.dynamicanalyzer.ui.toolbar.StartProcessManager; import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea; import org.tizen.dynamicanalyzer.ui.toolbar.setting.data.SettingConstants; import org.tizen.dynamicanalyzer.ui.toolbar.setting.data.SettingDataManager; @@ -189,7 +186,7 @@ public class Communicator30 extends BaseCommunicator { } @Override - public DAResult startTrace() { + public DAResult startTrace(IProgress progress) throws InterruptedException { DeviceInfo curDev = Global.getCurrentDeviceInfo(); if (curDev == null) { return DAResult.ERR_DEVICE_IS_NULL; @@ -200,17 +197,16 @@ public class Communicator30 extends BaseCommunicator { Logger.performance("TEST", "Start Trace", "Set application inst"); if (userSpaceInst == null || userSpaceInst.getAppInstList().isEmpty()) { - StartProcessManager.getInstance().setValue(100); // set progress bar to 100% Logger.error("cannot get user space inst"); return DAResult.ERR_MSG_START_FAIL; } byte[] replayData; // create replay data - if (ReplayTraceHandler.isReplay) { - replayData = ReplayTraceHandler.getReplayEvent(); + if (ReplayManager.isReplayMode()) { + replayData = ReplayManager.getReplayEvent(); } else { - replayData = ByteUtil.getByte(ReplayTraceHandler.REPLAY_OFF); + replayData = ByteUtil.getByte(ReplayManager.REPLAY_OFF); } byte[] rear = ByteUtil.getByte(userSpaceInst.toByteStream(), replayData); @@ -219,7 +215,6 @@ public class Communicator30 extends BaseCommunicator { byte[] ret = ByteUtil.getByte(AnalyzerConstants.MSG_START_SWAP, length, rear); Logger.debug("print start message"); - // ByteUtils.printByteArrayForStart(ret); if (PRINT_CONTROL_LOG_TOFILE) { File logPath = new File(PathManager.DA_DEBUG_CONTROL_CHANNEL_LOG_FILE); @@ -238,12 +233,6 @@ public class Communicator30 extends BaseCommunicator { AckMessage result = handleControlMessage(curDev, ret); Logger.performance("TEST", "Start Trace", "Make and Send start message"); - // FIX - if (!StartProcessManager.getInstance().isCancelled()) { - // StartProcessManager.getInstance().setCancelDisable(); - StartProcessManager.getInstance().setValue(100); - } - if (result != null && result.isCorrectID(MSG_START_ACK) && result.isSuccess()) { byte[] payload = result.getPayload(); int index = INT_SIZE; // return code @@ -252,28 +241,11 @@ public class Communicator30 extends BaseCommunicator { int nano = ByteUtil.toInt(payload, index); index += INT_SIZE; - Global.getProject().setProfilingStartTime(new DATime(sec, nano)); - - // data receive thread create and start - Thread dataThread = new Thread(null, new DataChannelThread(), - AnalyzerConstants.COMMUNICATOR_RECEIVE_THREAD); - dataThread.start(); - Logger.performance("TEST", "Start Trace", "Start data receiving thread"); - - ToolbarArea.getInstance().startTimer(); - Logger.performance("TEST", "Start Trace", "Start Timer"); - SWAPLogParser.startLogParser(); - Logger.performance("TEST", "Start Trace", "Start SWAP log parser thread"); - - // start registered data manager thread - DataManagerRegistry.startThreads(); - Logger.performance("TEST", "Start Trace", "Start DataManager threads"); - - /* Timeline */ - UpdateViewTimer.start(); - Logger.performance("TEST", "Start Trace", "Start Update view timer"); + synchronized (AnalyzerManager.waitStartAck) { + Global.getProject().setProfilingStartTime(new DATime(sec, nano)); + AnalyzerManager.waitStartAck.notifyAll(); + } - Logger.debug("Start recorder, timer, log parser, file, thread, ui, profile , update timer"); return DAResult.SUCCESS; } else { DACommunicator.setRunning(false); @@ -748,7 +720,7 @@ public class Communicator30 extends BaseCommunicator { Socket dataSock = null; try { dataSock = new Socket(CommonConstants.LOCAL_HOST, CommunicatorUtils.LOCAL_PORT); - dataSock.setSoTimeout(AnalyzerConstants.DATA_SOCKET_TIMEOUT); + dataSock.setSoTimeout(AnalyzerConstants.DATA_SOCKET_TIMEOUT_NORMAL); dataSock.setReuseAddress(true); dataSock.setTcpNoDelay(true); @@ -771,6 +743,7 @@ public class Communicator30 extends BaseCommunicator { if (result.isSuccess()) { device.setDataSock(dataSock); + AnalyzerManager.setDataSocketClosed(false); } return result; @@ -842,11 +815,12 @@ public class Communicator30 extends BaseCommunicator { index += INT_SIZE; for (int i = 0; i < numberOfDevice; i++) { - deviceList += LogDataUtils.getString(index, payload); + int length = LogDataUtils.getStringLength(index, payload); + deviceList += new String(payload, index, length); if (i + 1 != numberOfDevice) { deviceList += CommonConstants.COMMA; } - index += LogDataUtils.getStringLength(index, payload); + index += length; } tInfo.setSystemMemorySize(systemMemorySize); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/communicator/DataChannelThread.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/communicator/DataChannelThread.java index 73f7ee9..c5700a6 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/communicator/DataChannelThread.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/communicator/DataChannelThread.java @@ -26,15 +26,322 @@ */ package org.tizen.dynamicanalyzer.swap.communicator; +import java.io.BufferedInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.InterruptedIOException; +import java.net.Socket; +import java.net.SocketException; +import java.net.SocketTimeoutException; + +import org.tizen.dynamicanalyzer.common.AnalyzerConstants; +import org.tizen.dynamicanalyzer.common.AnalyzerManager; +import org.tizen.dynamicanalyzer.common.DALimit; +import org.tizen.dynamicanalyzer.common.DAResult; +import org.tizen.dynamicanalyzer.common.Global; import org.tizen.dynamicanalyzer.communicator.DACommunicator; +import org.tizen.dynamicanalyzer.control.SideWorker; +import org.tizen.dynamicanalyzer.handlers.CommandAction; +import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants; import org.tizen.dynamicanalyzer.swap.logparser.MessageParser; +import org.tizen.dynamicanalyzer.swap.model.data.LogData; +import org.tizen.dynamicanalyzer.swap.model.data.LogDataFactory; +import org.tizen.dynamicanalyzer.util.Logger; public class DataChannelThread implements Runnable { + private static final int RECEIVE_BUF_SIZE = 2097152; // 2MB + private static final int LOCAL_BUF_SIZE = 1024; + + private static Thread mThread = null; + + private Object waitObject = new Object(); + boolean throughMode = false; + + private enum STATE { + INITIALIZED, ACTIVATED, TERMINATED; + } + + private STATE state = STATE.INITIALIZED; + + public static DAResult start() { + if (mThread != null && mThread.isAlive()) { + try { + mThread.interrupt(); + mThread.join(); + mThread = null; + } catch (InterruptedException e) { + e.printStackTrace(); + return DAResult.ERR_START_DATA_CHANNEL; + } + } + + DataChannelThread mRunnable = new DataChannelThread(); + mThread = new Thread(null, mRunnable, AnalyzerConstants.COMMUNICATOR_RECEIVE_THREAD); + mThread.start(); + + synchronized (mRunnable.waitObject) { + try { + if (mRunnable.state == STATE.INITIALIZED) { + mRunnable.waitObject.wait(); + } + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + + if (mRunnable.state == STATE.ACTIVATED) { + return DAResult.SUCCESS; + } else { + return DAResult.ERR_START_DATA_CHANNEL; + } + } + + public static DAResult stopNormal() { + // do nothing to stop thread + // just wait the thread is terminated by itself + if (mThread != null && mThread.isAlive()) { + // wait until data channel thread is terminated + try { + mThread.join(); // wait forever + mThread = null; + } catch (InterruptedException e) { + e.printStackTrace(); + return DAResult.ERR_STOP_DATA_CHANNEL; + } + } + + return DAResult.SUCCESS; + } + + public static DAResult stopForced() { + // if thread is not terminated, interrupt it and wait to terminate + if (mThread != null && mThread.isAlive()) { + // wait until data channel thread is terminated + try { + mThread.interrupt(); + mThread.join(); // wait forever + mThread = null; + } catch (InterruptedException e) { + e.printStackTrace(); + return DAResult.ERR_STOP_DATA_CHANNEL; + } + } + + clearSocketReceiveBuffer(DACommunicator.getDataSocket()); + + return DAResult.SUCCESS; + } + + private void changeToThroughMode() { + Socket dataSocket = DACommunicator.getDataSocket(); + try { + dataSocket.setSoTimeout(AnalyzerConstants.DATA_SOCKET_TIMEOUT_TERMINATE); + } catch (SocketException e) { + e.printStackTrace(); + } + + throughMode = true; + } + + public static void clearSocketReceiveBuffer(Socket socket) { + try { + socket.setSoTimeout(AnalyzerConstants.DATA_SOCKET_TIMEOUT_CLEAR); + InputStream inputStream = socket.getInputStream(); + + byte[] buffer = new byte[LOCAL_BUF_SIZE]; + int readSize; + while (true) { + readSize = inputStream.read(buffer, 0, LOCAL_BUF_SIZE); + if (readSize == -1) { + break; + } + } + } catch (SocketTimeoutException e) { + // expected result + // do nothing + Logger.debug("data socket cleared"); + } catch (SocketException e) { + e.printStackTrace(); + } catch (IOException e) { + e.printStackTrace(); + } + } @Override public void run() { - MessageParser.getInstance().startMessageParsing( - DACommunicator.getDataSocket()); + try { + Socket dataSocket = DACommunicator.getDataSocket(); + clearSocketReceiveBuffer(dataSocket); + + BufferedInputStream inputStream = null; + byte[] header = new byte[DataChannelConstants.HEADER_SIZE]; + byte[] buffer = new byte[LOCAL_BUF_SIZE]; + long curSeq, prevSeq = -1; + Thread curThread = Thread.currentThread(); + + try { + dataSocket.setSoTimeout(AnalyzerConstants.DATA_SOCKET_TIMEOUT_NORMAL); + dataSocket.setReceiveBufferSize(RECEIVE_BUF_SIZE); + inputStream = new BufferedInputStream(dataSocket.getInputStream()); + + // notify that data channel thread is activated and ready to read + synchronized (waitObject) { + state = STATE.ACTIVATED; + waitObject.notifyAll(); + } + + while (curThread == mThread) { + if (!throughMode) { + // read data message header + if (!getByte(inputStream, header, DataChannelConstants.HEADER_SIZE)) { + break; + } + + LogData log = LogDataFactory.createInstance(header); + + // check for continuity of sequence number + curSeq = log.getSeq(); + boolean continuity = checkContinuity(prevSeq, curSeq); + if (prevSeq > curSeq) { // sequence number exceed MAX_SEQ_NUMBER + Global.getProject().incSeqRotation(); + } + prevSeq = curSeq; + log.adjustSeq(Global.getProject().getSeqRotation()); + + if (!continuity) { + // if sequence continuity is broken, then send stop work to side worker + notifyStopWork(DAResult.ERR_CONTINUITY_BROKEN); + } + + // check for payload size + int payloadsize = log.getPayloadSize(); + if (payloadsize < 0 || payloadsize > DALimit.MAX_PAYLOAD_SIZE) { + // wrong message format, stop profiling + notifyStopWork(DAResult.ERR_WRONG_MESSAGE_FORMAT); + changeToThroughMode(); + + // this means there is no more data to parse, so push EOQ + pushEOQ(); + } else { + // read payload from socket + if (!getByte(inputStream, log.getPayload(), payloadsize)) { + break; + } + + try { + MessageParser.pushLog(log); + } catch (InterruptedException e) { + e.printStackTrace(); + break; + } + + // check for msg id MSG_DATA_TERMINATE + int msgID = log.getMsgID(); + if (checkMsgID(msgID)) { + break; + } + } + } else { // through mode + int readSize = inputStream.read(buffer, 0, LOCAL_BUF_SIZE); + if (readSize == -1) { + // reached end of stream (never happened I guess) + AnalyzerManager.setDataSocketClosed(true); + break; + } + } + } + } catch (SocketTimeoutException e) { + // timeout to read (there is no more data to read) + // do nothing + e.printStackTrace(); + } catch (InterruptedIOException e) { + // thread is interrupted by other thread during reading from socket + e.printStackTrace(); + } catch (IOException e) { + // data socket is closed + AnalyzerManager.setDataSocketClosed(true); + e.printStackTrace(); + } + } finally { + pushEOQ(); + + if (AnalyzerManager.isDataSocketClosed()) { + notifyStopWork(DAResult.ERR_DATA_SOCKET_CLOSED); + } + + synchronized (waitObject) { + state = STATE.TERMINATED; + waitObject.notifyAll(); + } + } + } + + private boolean getByte(InputStream input, byte[] buffer, int length) throws IOException { + // read data message header + int toRead = length; + int readSize; + while (toRead > 0) { + readSize = input.read(buffer, length - toRead, toRead); + toRead -= readSize; + if (readSize == -1) { + // reached end of stream (never happened I guess) + AnalyzerManager.setDataSocketClosed(true); + break; + } + } + + if (AnalyzerManager.isDataSocketClosed()) { + return false; + } else { + return true; + } + } + + private boolean checkContinuity(long prevSeq, long curSeq) { + if (curSeq != prevSeq + 1) { + // continuity of seq number is broken + Logger.error("Contunuity failed (%d) (%d)", prevSeq, curSeq); + return false; + } else { + return true; + } } + private boolean pushEOQ() { + try { + MessageParser.pushLog(LogData.END_OF_QUEUE); + return true; + } catch (InterruptedException e) { + e.printStackTrace(); + return false; + } + } + + // return true if last log is arrived + // return false otherwise + private boolean checkMsgID(int msgID) { + if (msgID == DataChannelConstants.MSG_DATA_PROCESS_INFO) { + Global.getProject().incActiveProcessCount(); + } else if (msgID == DataChannelConstants.MSG_DATA_TERMINATE) { + Global.getProject().descActiveProcessCount(); + if (Global.getProject().getActiveProcessCount() == 0) { + // if there is no active process, no more message from target + AnalyzerManager.setTerminateMsgArrived(true); + // exit data channel thread + return true; + } + } + + return false; + } + + private void notifyStopWork(DAResult result) { + final DAResult fresult = result; + SideWorker.INSTANCE.offerWork(new Runnable() { + @Override + public void run() { + CommandAction.stopTrace(fresult, false); + } + }); + } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/DataManagerRegistry.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/DataManagerRegistry.java index 93bb98e..d93aa82 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/DataManagerRegistry.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/DataManagerRegistry.java @@ -54,9 +54,15 @@ public class DataManagerRegistry { } } - public static void stopThreads() { + public static void stopThreadsNormal() { for (Map.Entry entry : dataManagers.entrySet()) { - entry.getValue().stopThread(); + entry.getValue().stopNormal(); + } + } + + public static void stopThreadsForced() { + for (Map.Entry entry : dataManagers.entrySet()) { + entry.getValue().stopForced(); } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/LogList.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/LogList.java new file mode 100644 index 0000000..27d851b --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/LogList.java @@ -0,0 +1,16 @@ +package org.tizen.dynamicanalyzer.swap.logparser; + +import java.util.ArrayList; + +import org.tizen.dynamicanalyzer.swap.model.data.LogData; + +public class LogList extends ArrayList { + + public static final LogList END_OF_QUEUE = new LogList(); + + /** + * default serial number + */ + private static final long serialVersionUID = 1L; + +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/LogPackage.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/LogPackage.java index 1b9658d..2ebb0d6 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/LogPackage.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/LogPackage.java @@ -31,10 +31,11 @@ import java.util.ArrayList; import java.util.HashMap; import java.util.List; -import org.tizen.dynamicanalyzer.model.StreamElement; import org.tizen.dynamicanalyzer.swap.model.data.LogData; -public class LogPackage extends StreamElement { +public class LogPackage { + public static final LogPackage END_OF_QUEUE = new LogPackage(); + private HashMap logMap; public void clear() { diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/SWAPLogParser.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/LogParser.java similarity index 50% rename from org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/SWAPLogParser.java rename to org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/LogParser.java index deb83eb..2ef7dc0 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/SWAPLogParser.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/LogParser.java @@ -27,26 +27,35 @@ */ package org.tizen.dynamicanalyzer.swap.logparser; +import static org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants.MSG_CONTEXT_SWITCH_ENTRY; +import static org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants.MSG_CONTEXT_SWITCH_EXIT; +import static org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants.MSG_DATA_RECORD; +import static org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants.MSG_DATA_SAMPLE; +import static org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants.MSG_DATA_SYSTEM; +import static org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants.MSG_FUNCTION_ENTRY; +import static org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants.MSG_FUNCTION_EXIT; +import static org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants.MSG_PROBE_SCREENSHOT; + import java.io.File; -import java.util.ArrayList; +import java.util.ArrayDeque; +import java.util.Deque; import java.util.HashMap; -import java.util.List; import java.util.Map; +import java.util.concurrent.BlockingQueue; +import java.util.concurrent.LinkedBlockingQueue; import org.tizen.dynamicanalyzer.common.AnalyzerConstants; import org.tizen.dynamicanalyzer.common.AnalyzerManager; +import org.tizen.dynamicanalyzer.common.DAResult; import org.tizen.dynamicanalyzer.common.Global; import org.tizen.dynamicanalyzer.common.SymbolManager; import org.tizen.dynamicanalyzer.communicator.CommunicatorUtils; import org.tizen.dynamicanalyzer.communicator.DACommunicator; import org.tizen.dynamicanalyzer.constant.CommonConstants; import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants; -import org.tizen.dynamicanalyzer.swap.model.data.ContextSwitchData; import org.tizen.dynamicanalyzer.swap.model.data.LogData; import org.tizen.dynamicanalyzer.swap.model.data.ProfileData; -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.info.screenshot.SocketClient; import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler; import org.tizen.dynamicanalyzer.util.Logger; @@ -54,15 +63,14 @@ import org.tizen.dynamicanalyzer.utils.ImageUtil; import org.tizen.dynamicanalyzer.utils.ImageUtilSWT; import org.tizen.sdblib.service.SyncResult; -public class SWAPLogParser implements Runnable { - private static Thread logParser = null; - // default false, turn on when Tizen C++ app - // private static boolean dropCallTraceLog = true; - // private static boolean dropCallTraceLog = false; - private static LogQueue logQueue = null; +public class LogParser implements Runnable { + private static LogParser instance = null; + private static Thread thread = null; + + private BlockingQueue queue = new LinkedBlockingQueue(); // map for matching exit log with entry log - private static Map> functionEntryStackByTidMap = new HashMap>(); + private Map> functionEntryStackByTidMap = new HashMap>(); private int SMALL_IMG_WIDTH = 40; private int SMALL_IMG_HEIGHT = 66; @@ -70,185 +78,208 @@ public class SWAPLogParser implements Runnable { private int DEFAULT_IMG_WIDTH = 480; private int DEFAULT_IMG_HEIGHT = 800; - public static synchronized LogQueue getLogQueue() { - if (null == logQueue) { - logQueue = new LogQueue(); + public static DAResult start() { + if (thread != null && thread.isAlive()) { + try { + thread.interrupt(); + thread.join(); + thread = null; + } catch (InterruptedException e) { + e.printStackTrace(); + return DAResult.ERR_START_LOG_PARSER; + } } - return logQueue; + + instance = new LogParser(); + thread = new Thread(null, instance, AnalyzerConstants.LOG_QUEUE_OBSERVING_THREAD); + thread.start(); + + return DAResult.SUCCESS; } - public List getFunctionEntryStack(int tid) { - List functionEntryStack = functionEntryStackByTidMap.get(tid); - if (null == functionEntryStack) { - functionEntryStack = new ArrayList(); - functionEntryStackByTidMap.put(tid, functionEntryStack); + public static DAResult stopNormal() { + // do nothing to stop thread + // just wait the thread is terminated by itself + if (thread != null && thread.isAlive()) { + // wait until data channel thread is terminated + try { + thread.join(); // wait forever + thread = null; + } catch (InterruptedException e) { + e.printStackTrace(); + return DAResult.ERR_START_LOG_PARSER; + } } - return functionEntryStack; - } - public static synchronized void startLogParser() { - getLogQueue().clear(); - // why here? - // dropCallTraceLog = true; - if (null == logParser || !logParser.isAlive()) { - logParser = new Thread(null, new SWAPLogParser(), - AnalyzerConstants.LOG_QUEUE_OBSERVING_THREAD); - logParser.start(); + if (instance != null) { + instance.clear(); } + instance = null; + + return DAResult.SUCCESS; } - public static void stopLogParser() { - if (null != logParser && logParser.isAlive()) { - LogQueue logQueue = getLogQueue(); - synchronized (logQueue) { - logQueue.notifyAll(); - } + public static DAResult stopForced() { + if (thread != null && thread.isAlive()) { + // wait until data channel thread is terminated try { - Logger.debug("wait for log parser join");//$NON-NLS-1$ - logParser.join(AnalyzerConstants.THREAD_JOIN_WAIT_TIME); + thread.interrupt(); + thread.join(); // wait forever + thread = null; } catch (InterruptedException e) { e.printStackTrace(); + return DAResult.ERR_START_LOG_PARSER; } } + + if (instance != null) { + instance.clear(); + } + instance = null; + + return DAResult.SUCCESS; + } + + public static void pushLog(LogList loglist) throws InterruptedException { + if (instance != null) { + instance.queue.put(loglist); + } + } + + private void clear() { + queue.clear(); functionEntryStackByTidMap.clear(); - DataManagerRegistry.stopThreads(); + } + + public Deque getFunctionEntryStack(int tid) { + Deque functionEntryStack = functionEntryStackByTidMap.get(tid); + if (null == functionEntryStack) { + functionEntryStack = new ArrayDeque(); + functionEntryStackByTidMap.put(tid, functionEntryStack); + } + return functionEntryStack; } /*** log parsing thread ***/ @Override public void run() { - AnalyzerManager.setLogParsingComplete(false); - LogQueue logQueue = getLogQueue(); - while (!AnalyzerManager.isExit()) { - List logs = logQueue.getFirst(); - if (null == logs) { - break; + try { + LogList loglist; + while (true) { + try { + loglist = queue.take(); + } catch (InterruptedException e) { + e.printStackTrace(); + break; + } + + if (loglist == LogList.END_OF_QUEUE) { + break; + } + + logParsing(loglist); } - logSlicing(logs); + } finally { + DataManagerRegistry.updateLog(LogPackage.END_OF_QUEUE); } - /* log for debug */ Logger.debug("log parsing thread end!!"); //$NON-NLS-1$ - AnalyzerManager.setLogParsingComplete(true); } - private void logSlicing(List logLumb) { - int size = logLumb.size(); + private void logParsing(LogList loglist) { + int size = loglist.size(); LogPackage logPack = new LogPackage(); for (int i = 0; i < size; i++) { - if (null == logLumb.get(i)) { + LogData log = loglist.get(i); + if (null == log) { continue; } - LogData log = logLumb.get(i); - int id = log.getId(); - long seqNum = log.getSeq(); - if (log instanceof SystemData) { - // System.out - // .println("=========systemData is slicing===========\n"); - pushLog(log, logPack); - } else if (log instanceof ProfileData) { + + int id = log.getMsgID(); + boolean ret; + switch (id) { + case MSG_DATA_SAMPLE: if (!AnalyzerManager.isProcessInfoArrived()) { - continue; + break; } - - if (id != DataChannelConstants.MSG_DATA_SAMPLE) { - ProfileData pData = (ProfileData) log; - - List functionStack = getFunctionEntryStack(pData.getTid()); - // entry / exit pair matching - if (id == DataChannelConstants.MSG_FUNCTION_ENTRY) { - functionStack.add(seqNum); - } else { // msg_function_exit - int stackSize = functionStack.size(); - if (stackSize > 0) { - pData.setEntrySeq(functionStack.get(stackSize - 1)); - functionStack.remove(stackSize - 1); - } else { // size <= 0 : bug (exit without entry) - Logger.error("function exit log without entry log"); - } - } - - // function_exit log doesn't have probe type yet - // if (pData.getProbeType() - // == AnalyzerConstants.FUNCTION_TYPE_APPINST) { - - // ProcessInformation process = Global.getProject() - // .getProcessInformation(pData.getPid()); - if (pData.getProbeType() != AnalyzerConstants.FUNCTION_TYPE_FILE) { - int apiId = SymbolManager.getFuncId(pData, pData.getPcAddr(), - pData.getPid(), pData.getTime()); - String apiName = Global.getFunctionName(apiId); - // TODO : check with apiId - if (apiId == -1 || apiName.equals("")) { - continue; - } else { - pData.setApiId(apiId); - } - - // if (process.isDropLog()) { - // if (apiName.contains("main")) { - // process.setDropLog(false); - // } else { - // continue; - // } - // } - - pushLog(log, logPack); - AnalyzerManager.getCallstackManager().makeUserCallstack( - pData, - FunctionUsageProfiler.getInstance().getProfileDataMakerByPid( - pData.getPid())); - // } else { // system call enter/exit : not used yet - // pushLog(log, logPack); - // } - } else { - pushLog(log, logPack); - } - } else { // sample log - pushLog(log, logPack); + packLog(log, logPack); + break; + case MSG_FUNCTION_ENTRY: + case MSG_FUNCTION_EXIT: + if (!AnalyzerManager.isProcessInfoArrived()) { + break; } - } else if (log instanceof ReplayData) { - pushLog(log, logPack); - } else if (log instanceof ContextSwitchData) { - pushLog(log, logPack); - } else { - if (log instanceof ScreenShotData) { - // get image file from target or ecs - boolean bECS = false; - String remoteImgPath; - if (DACommunicator.isTargetEmulator() - && SocketClient.getInstance().isConnected()) { - Global.getCurrentDeviceInfo().emulatorScreenshot.send(); - remoteImgPath = Global.getCurrentDeviceInfo().emulatorScreenshot - .getFilePath(); - bECS = true; - } else { - remoteImgPath = ((ScreenShotData) log).getImageFilePath(); - } - - int rotate = ((ScreenShotData) log).getOrientation(); - // TODO : fix - if (bECS) { - processImagefromECS(remoteImgPath, rotate); - } else { - processImage(remoteImgPath, rotate); - } + ret = processFunctionData((ProfileData) log); + if (ret) { + packLog(log, logPack); } - pushLog(log, logPack); + break; + case MSG_DATA_SYSTEM: + case MSG_DATA_RECORD: + case MSG_CONTEXT_SWITCH_ENTRY: + case MSG_CONTEXT_SWITCH_EXIT: + packLog(log, logPack); + break; + case MSG_PROBE_SCREENSHOT: + processScreenshotData((ScreenShotData) log); + packLog(log, logPack); AnalyzerManager.getCallstackManager().makeCallstackWithoutBacktrace(log); - // if (id == DataChannelConstants.MSG_PROBE_FILE - // || id == DataChannelConstants.MSG_PROBE_MEMORY) { - // AnalyzerManager.getLeakDetector().runLeakDectect(log); - // } - // - // AnalyzerManager.getFailedChecker().check(log); + break; + default: + packLog(log, logPack); + AnalyzerManager.getCallstackManager().makeCallstackWithoutBacktrace(log); + break; } } - // Logger.debug("update logs"); updateLog(logPack); } + private boolean processFunctionData(ProfileData pData) { + int msgID = pData.getMsgID(); + Deque functionStack = getFunctionEntryStack(pData.getTid()); + + // entry / exit pair matching + if (msgID == DataChannelConstants.MSG_FUNCTION_ENTRY) { + functionStack.addLast(pData.getSeq()); + } else { // msg_function_exit + if (!functionStack.isEmpty()) { + pData.setEntrySeq(functionStack.removeLast()); + } else { // size <= 0 : bug (exit without entry) + Logger.error("function exit log without entry log"); + } + } + + if (pData.getProbeType() != AnalyzerConstants.FUNCTION_TYPE_FILE) { + int apiID = SymbolManager.getFuncId(pData, pData.getPcAddr(), pData.getPid(), + pData.getTime()); + String apiName = Global.getFunctionName(apiID); + + // TODO : check with apiId + if (apiID == AnalyzerConstants.INVALID_INDEX || apiName.equals("")) { + return false; + } else { + pData.setApiId(apiID); + } + + AnalyzerManager.getCallstackManager().makeUserCallstack(pData, + FunctionUsageProfiler.getInstance().getProfileDataMakerByPid(pData.getPid())); + } + + return true; + } + + private void processScreenshotData(ScreenShotData log) { + // get image file from target or ecs + if (DACommunicator.isTargetEmulator() && SocketClient.getInstance().isConnected()) { + Global.getCurrentDeviceInfo().emulatorScreenshot.send(); + String remoteImgPath = Global.getCurrentDeviceInfo().emulatorScreenshot.getFilePath(); + processImagefromECS(remoteImgPath, log.getOrientation()); + } else { + processImage(log.getImageFilePath(), log.getOrientation()); + } + } + private void processImage(final String from, final int angle) { final String fileName = getImageName(from); final String to = Global.getProject().getSavePath() + File.separator @@ -347,26 +378,21 @@ public class SWAPLogParser implements Runnable { } private void updateLog(LogPackage logPack) { - if (null == logPack || logPack.isEmpty()) { - return; + if (logPack != null && !logPack.isEmpty()) { + DataManagerRegistry.updateLog(logPack); } - - DataManagerRegistry.updateLog(logPack); - // Logger.debug("view update!!"); } - private void pushLog(LogData logData, LogPackage logPack) { - // TODO consider this routine when refactoring Log Parser - + private void packLog(LogData logData, LogPackage logPack) { // a special case for file analysis - if (logData.getId() == DataChannelConstants.MSG_FUNCTION_ENTRY - || logData.getId() == DataChannelConstants.MSG_FUNCTION_EXIT) { + if (logData.getMsgID() == DataChannelConstants.MSG_FUNCTION_ENTRY + || logData.getMsgID() == DataChannelConstants.MSG_FUNCTION_EXIT) { ProfileData data = (ProfileData) logData; if (data.getProbeType() == AnalyzerConstants.FUNCTION_TYPE_FILE) { logPack.setLogs(DataChannelConstants.MSG_FUCNTION_ENTRY_EXIT, logData); return; } } - logPack.setLogs(logData.getId(), logData); + logPack.setLogs(logData.getMsgID(), logData); } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/LogQueue.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/LogQueue.java deleted file mode 100755 index 15c5b6c..0000000 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/LogQueue.java +++ /dev/null @@ -1,105 +0,0 @@ -/* - * Dynamic Analyzer - * - * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. - * - * Contact: - * Jaewon Lim - * 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.logparser; - -import java.util.ArrayList; -import java.util.List; - -import org.tizen.dynamicanalyzer.common.AnalyzerManager; -import org.tizen.dynamicanalyzer.swap.model.data.LogData; -import org.tizen.dynamicanalyzer.util.Logger; - -/** log queue model **/ -public class LogQueue { - private static final int FULL_COUNT = 10000; - private static final int HALF_COUNT = 5000; - private List> data = null; - private static boolean isFull = false; - - public LogQueue() { - data = new ArrayList>(); - } - - public synchronized List getFirst() { - while (isEmpty()) { - try { - if (!AnalyzerManager.isRunning()) { - return null; - } - wait(); - } catch (InterruptedException e) { - Logger.debug("log queue interrupt!!"); //$NON-NLS-1$ - continue; - } - } - - List output = data.get(0); - data.remove(0); - if (data.size() < HALF_COUNT) { - isFull = false; - notifyAll(); - } - return output; - } - - public synchronized void putLog(List input) { - while (isFull()) { - try { - wait(); - } catch (InterruptedException e) { - // never reach here! - e.printStackTrace(); - break; - } - } - data.add(input); - if (data.size() >= FULL_COUNT) { - isFull = true; - } - notifyAll(); - } - - public boolean isEmpty() { - if (null == data) { - data = new ArrayList>(); - } - return data.isEmpty(); - } - - public boolean isFull() { - return isFull; - } - - public synchronized int size() { - return data.size(); - } - - public void clear() { - data.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 6bdc26a..98c3f15 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 @@ -33,167 +33,363 @@ import java.io.BufferedWriter; import java.io.File; import java.io.FileWriter; import java.io.IOException; -import java.io.InputStream; import java.io.PrintWriter; -import java.net.Socket; -import java.util.ArrayList; -import java.util.List; import java.util.Timer; import java.util.TimerTask; +import java.util.concurrent.BlockingQueue; +import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; -import org.eclipse.swt.SWT; -import org.eclipse.swt.widgets.Display; -import org.eclipse.swt.widgets.Shell; import org.tizen.dynamicanalyzer.common.AnalyzerConstants; import org.tizen.dynamicanalyzer.common.AnalyzerManager; -import org.tizen.dynamicanalyzer.common.DALimit; +import org.tizen.dynamicanalyzer.common.DAResult; import org.tizen.dynamicanalyzer.common.Global; import org.tizen.dynamicanalyzer.common.path.PathManager; -import org.tizen.dynamicanalyzer.communicator.DACommunicator; -import org.tizen.dynamicanalyzer.database.DBInsertManager; -import org.tizen.dynamicanalyzer.handlers.ReplayTraceHandler; -import org.tizen.dynamicanalyzer.handlers.StopHandler; -import org.tizen.dynamicanalyzer.nl.AnalyzerLabels; -import org.tizen.dynamicanalyzer.nl.UserErrorWarningLabels; import org.tizen.dynamicanalyzer.project.BinaryInfo; import org.tizen.dynamicanalyzer.project.LibraryObject; import org.tizen.dynamicanalyzer.project.ProcessInformation; import org.tizen.dynamicanalyzer.project.ProcessMemoryMap; import org.tizen.dynamicanalyzer.project.Project; -import org.tizen.dynamicanalyzer.resources.ImageResources; import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants; import org.tizen.dynamicanalyzer.swap.model.DATime; import org.tizen.dynamicanalyzer.swap.model.data.LogData; -import org.tizen.dynamicanalyzer.swap.model.data.LogDataFactory; import org.tizen.dynamicanalyzer.swap.model.data.LogDataUtils; import org.tizen.dynamicanalyzer.ui.thread.data.ThreadDataManager; -import org.tizen.dynamicanalyzer.ui.toolbar.StartProcessManager; -import org.tizen.dynamicanalyzer.ui.toolbar.StopLogProcessor; -import org.tizen.dynamicanalyzer.ui.toolbar.StopProcessManager; -import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea; import org.tizen.dynamicanalyzer.util.ByteUtil; import org.tizen.dynamicanalyzer.util.CommonUtil; import org.tizen.dynamicanalyzer.util.Logger; -import org.tizen.dynamicanalyzer.util.WorkbenchUtil; -import org.tizen.dynamicanalyzer.utils.AnalyzerUtil; -import org.tizen.dynamicanalyzer.widgets.da.base.DADialog; -public class MessageParser { - static final boolean PRINT_DATA_LOG_TOFILE = false; - - static final int MSG_ID_INDEX = 0; - static final int MSG_LENGTH_INDEX = 1; - static final int MSG_PAYLOAD_INDEX = 2; - static final int MSG_SPLIT_SIZE = 3; +public class MessageParser implements Runnable { + private static boolean PRINT_DATA_LOG_TOFILE = false; /* Message Buffer max length */ - static final int MSG_BUFFER_MAX = 5000; - static final int MSG_BUFFER_TIMER_DELAY = 5; - static final int MSG_BUFFER_TIMER_PERIOD = 1000; // 1 second - static final int WAITING_TIME = 10; - - private static final int SOCKET_TIMEOUT_NORMAL = 5000; // 5 second - private static final int SOCKET_TIMEOUT_ABNORMAL = 1000; // 1 second - private static final int EMPTY_BUFFER_SIZE = 1024; - - public static final int MSG_HEADER_SIZE = 20; - final int MSG_PAYLOAD_SIZE_INDEX = 16; - boolean exit = false; - - class AddBufferTimerTask extends TimerTask { - private int count = 0; - - @Override - public void run() { - if (!buffer.isEmpty()) { - addBufferToList(); - count = 0; - } else { - count++; - if (count >= WAITING_TIME) { - ToolbarArea.getInstance().stopTrace(); - } + private static final int MSG_BUFFER_MAX = 5000; + private static final int MSG_BUFFER_TIMER_DELAY = 5; + private static final int MSG_BUFFER_TIMER_PERIOD = 1000; // 1 second + + private static Thread thread = null; + private static MessageParser instance = null; + + private BlockingQueue queue = new LinkedBlockingQueue(); + private LogList sendBuffer = new LogList(); + private Lock lock = new ReentrantLock(); + private Timer timer = null; + + public static DAResult start() { + if (thread != null && thread.isAlive()) { + try { + thread.interrupt(); + thread.join(); + thread = null; + } catch (InterruptedException e) { + e.printStackTrace(); + return DAResult.ERR_START_MESSAGE_PARSER; } } + + instance = new MessageParser(); + thread = new Thread(null, instance, AnalyzerConstants.MESSAGE_PARSER_THREAD); + thread.start(); + + return DAResult.SUCCESS; } - private List buffer = new ArrayList(); - private Lock lock = new ReentrantLock(); - private Timer timer = null; + public static DAResult stopNormal() { + // do nothing to stop thread + // just wait the thread is terminated by itself + if (thread != null && thread.isAlive()) { + // wait until data channel thread is terminated + try { + thread.join(); // wait forever + thread = null; + } catch (InterruptedException e) { + e.printStackTrace(); + return DAResult.ERR_STOP_MESSAGE_PARSER; + } + } + + if (instance != null) { + instance.clear(); + } + instance = null; + + return DAResult.SUCCESS; + } + + public static DAResult stopForced() { + if (thread != null && thread.isAlive()) { + // wait until data channel thread is terminated + try { + thread.interrupt(); + thread.join(); // wait forever + thread = null; + } catch (InterruptedException e) { + e.printStackTrace(); + return DAResult.ERR_STOP_MESSAGE_PARSER; + } + } - private static MessageParser receivedMessage = new MessageParser(); - private int messageCount = 0; + if (instance != null) { + instance.clear(); + } + instance = null; - public static MessageParser getInstance() { - return receivedMessage; + return DAResult.SUCCESS; } - public void startTimer() { + public static void pushLog(LogData data) throws InterruptedException { + if (instance != null) { + instance.queue.put(data); + } + } + + private void startTimer() { timer = new Timer(AnalyzerConstants.HANDOVER_TIMER); - timer.scheduleAtFixedRate(new AddBufferTimerTask(), MSG_BUFFER_TIMER_DELAY, - MSG_BUFFER_TIMER_PERIOD); + timer.scheduleAtFixedRate(new TimerTask() { + @Override + public void run() { + if (!sendBuffer.isEmpty()) { + sendDataToLogParser(); + } + } + }, MSG_BUFFER_TIMER_DELAY, MSG_BUFFER_TIMER_PERIOD); } - public void stopTimer() { + private void stopTimer() { if (null != timer) { timer.cancel(); timer = null; } } - private void addBufferToList() { + private void sendDataToLogParser() { lock.lock(); try { - if (null != buffer && 0 != buffer.size()) { - SWAPLogParser.getLogQueue().putLog(buffer); + try { + if (null != sendBuffer && 0 != sendBuffer.size()) { + LogParser.pushLog(sendBuffer); + } + + sendBuffer = new LogList(); + } catch (InterruptedException e) { + // do not reset send buffer + e.printStackTrace(); } - } catch (UnsupportedOperationException e) { - e.printStackTrace(); - } catch (ClassCastException e) { - e.printStackTrace(); - } catch (NullPointerException e) { - e.printStackTrace(); - } catch (IllegalArgumentException e) { - e.printStackTrace(); - } catch (IllegalMonitorStateException e) { - e.printStackTrace(); } finally { - buffer = new ArrayList(); lock.unlock(); } } - private void processProcessInfo(byte[] data) { + private boolean pushEOQ() { + try { + LogParser.pushLog(LogList.END_OF_QUEUE); + return true; + } catch (InterruptedException e) { + e.printStackTrace(); + return false; + } + } + + private void clear() { + stopTimer(); + queue.clear(); + sendBuffer.clear(); + } + + @Override + public void run() { + PrintWriter printWriter = getDebugWriter(); + + try { + synchronized (AnalyzerManager.waitStartAck) { + try { + while (Global.getProject().getProfilingStartTime() == null) { + AnalyzerManager.waitStartAck.wait(); + } + } catch (InterruptedException e) { + e.printStackTrace(); + return; + } + } + + startTimer(); + + LogData log; + while (true) { + try { + log = queue.take(); + } catch (InterruptedException e) { + e.printStackTrace(); + break; + } + + if (log == LogData.END_OF_QUEUE) { + break; + } + + printLog(printWriter, log); + + processMessage(log); + } + } finally { + stopTimer(); + sendDataToLogParser(); + pushEOQ(); + + if (printWriter != null) { + CommonUtil.tryClose(printWriter); + } + } + } + + private PrintWriter getDebugWriter() { + PrintWriter printWriter = null; + + if (PRINT_DATA_LOG_TOFILE) { + File logPath = new File(PathManager.DA_DEBUG_DATA_CHANNEL_LOG_FILE); + if (logPath.exists()) { + logPath.delete(); + } + + try { + printWriter = new PrintWriter(new BufferedWriter(new FileWriter(logPath)), true); + } catch (IOException e) { + e.printStackTrace(); + } + } + + return printWriter; + } + + private void printLog(PrintWriter printWriter, LogData log) { + if (printWriter != null) { + int payloadSize = log.getPayloadSize(); + byte[] payload = log.getPayload(); + printWriter.printf("%d %d %d %d :", log.getMsgID(), log.getSeq(), log.getTime(), + payloadSize); + for (int i = 0; i < payloadSize; i++) + printWriter.printf("%02x ", payload[i]); + printWriter.printf("\n"); + } + } + + // private void endingSteps() { + // Logger.debug("Ending steps!"); + // DACommunicator.setRunning(false); + // AnalyzerManager.setRunningState(false); + // Global.setCurrentState(STATE.PREPARE_END); + // + // ToolbarArea.getInstance().changeUIState(STATE.PREPARE_END); + // + // stopTimer(); + // Logger.performance("TEST", "DA end", "Stop timer"); + // sendDataToLogParser(); + // Logger.performance("TEST", "DA end", "Add buffer to list"); + // + // // stop DB insert thread + // DBInsertManager.stopInserters(); + // + // // if (!StartProcessManager.getInstance().isCancelled()) { + // // Logger.debug("start!! : stop log process");//$NON-NLS-1$ + // // StopLogProcessor.runStopLogProcessThread(); + // // } + // + // AnalyzerUtil.executeCommand(StopHandler.ID); + // Logger.performance("TEST", "DA end", "Execute command - StopHandler"); + // AnalyzerManager.setProcessInfoArrived(false); + // ReplayManager.reset(); + // } + + // return false if message id is unknown + private boolean processMessage(LogData log) { + boolean bret = true; + int id = log.getMsgID(); + switch (id) { + case DataChannelConstants.MSG_DATA_PROCESS_INFO: + // setting process info + processProcessInfo(log); + break; + case DataChannelConstants.MSG_PROCESS_MAP: + case DataChannelConstants.MSG_PROCESS_UNMAP: + memoryMapChanged(log); + break; + case DataChannelConstants.MSG_DATA_TERMINATE: + processTerminate(); + break; + case DataChannelConstants.MSG_DATA_ERROR: + // process error message + break; + case DataChannelConstants.MSG_DATA_SYSTEM: + case DataChannelConstants.MSG_FUNCTION_ENTRY: + case DataChannelConstants.MSG_FUNCTION_EXIT: + case DataChannelConstants.MSG_DATA_SAMPLE: + case DataChannelConstants.MSG_CONTEXT_SWITCH_ENTRY: + case DataChannelConstants.MSG_CONTEXT_SWITCH_EXIT: + case DataChannelConstants.MSG_DATA_RECORD: + if (AnalyzerManager.isProcessInfoArrived()) { + log.makeDataPublic(Global.getProject().getProfilingStartTime()); + sendBuffer.add(log); + } + break; + case DataChannelConstants.MSG_PROCESS_COMM: + processAddInfo(log); + break; + case DataChannelConstants.MSG_DATA_IMAGE: + // process image message + break; + default: + if (id >= DataChannelConstants.MSG_PROBE_MIN + && id <= DataChannelConstants.MSG_PROBE_MAX) { // MSG_PROBE + if (AnalyzerManager.isProcessInfoArrived()) { + log.makeDataPublic(Global.getProject().getProfilingStartTime()); + sendBuffer.add(log); + } + } else { + // unknown message id + bret = false; + } + break; + } + + if (MSG_BUFFER_MAX <= sendBuffer.size()) { + sendDataToLogParser(); + } + + return bret; + } + + private void processProcessInfo(LogData log) { Project project = Global.getProject(); - int pid = 0; - int ppid = 0; - long lowAddr = 0; - long highAddr = 0; - String targetBinaryPath = null; - int dependantLibCount = 0; - String commandLineName = null; + byte[] data = log.getPayload(); + int index = 0; - int index = MSG_HEADER_SIZE; - pid = ByteUtil.toInt(data, index); + int pid = ByteUtil.toInt(data, index); index += INT_SIZE; - commandLineName = ByteUtil.getString(data, index); - index += ByteUtil.getStringLength(data, index); - ppid = ByteUtil.toInt(data, index); + + int length = LogDataUtils.getStringLength(index, data); + String commandLineName = new String(data, index, length); + index += length; + + int ppid = ByteUtil.toInt(data, index); index += INT_SIZE; + int sec = ByteUtil.toInt(data, index); index += INT_SIZE; int nano = ByteUtil.toInt(data, index); index += INT_SIZE; - lowAddr = ByteUtil.toLong(data, index); + + long lowAddr = ByteUtil.toLong(data, index); index += LONG_SIZE; - highAddr = ByteUtil.toLong(data, index); + long highAddr = ByteUtil.toLong(data, index); index += LONG_SIZE; - targetBinaryPath = ByteUtil.getString(data, index); - index += ByteUtil.getStringLength(data, index); - dependantLibCount = ByteUtil.toInt(data, index); + + length = LogDataUtils.getStringLength(index, data); + String targetBinaryPath = new String(data, index, length); + index += length; + + int dependantLibCount = ByteUtil.toInt(data, index); index += INT_SIZE; DATime capturedTime = new DATime(sec, nano); @@ -221,13 +417,14 @@ public class MessageParser { index += LONG_SIZE; long highestAddr = ByteUtil.toLong(data, index); index += LONG_SIZE; - String libPath = ByteUtil.getString(data, index); + + length = LogDataUtils.getStringLength(index, data); + String libPath = new String(data, index, length); + index += length; LibraryObject libObj = new LibraryObject(project.getDeviceStatusInfo() .getBinaryInfo(libPath).getID(), lowestAddr, highestAddr); - index += ByteUtil.getStringLength(data, index); - pMap.addLibraryMap(libObj); } @@ -239,25 +436,19 @@ public class MessageParser { AnalyzerManager.setProcessInfoArrived(true); + // SEE : what is this ? ThreadDataManager.getInstance().getThreadDataMaker().createMainThreadItem(pid); } - private void memoryMapChanged(byte[] data) { + private void memoryMapChanged(LogData log) { Project project = Global.getProject(); - /** parsing */ + byte[] data = log.getPayload(); int index = 0; - int id = ByteUtil.toInt(data, index); - index += INT_SIZE; - // int seq = ByteUtils.toInt(data, index); - index += INT_SIZE; - int sec = ByteUtil.toInt(data, index); - index += INT_SIZE; - int nano = ByteUtil.toInt(data, index); - index += INT_SIZE; - // int length = ByteUtils.toInt(data, index); - index += INT_SIZE; + int msgID = log.getMsgID(); + + /** parsing */ int pid = ByteUtil.toInt(data, index); index += INT_SIZE; long lowAddr = ByteUtil.toLong(data, index); @@ -274,10 +465,11 @@ public class MessageParser { ProcessMemoryMap lastMap = pinfo.getLastProcessMemoryMap(); - if (id == DataChannelConstants.MSG_PROCESS_MAP) { + if (msgID == DataChannelConstants.MSG_PROCESS_MAP) { // update to last memory map - String libPath = LogDataUtils.getString(index, data); - index += LogDataUtils.getStringLength(index, data); + int length = LogDataUtils.getStringLength(index, data); + String libPath = new String(data, index, length); + index += length; BinaryInfo bininfo = project.getDeviceStatusInfo().getBinaryInfo(libPath); LibraryObject libObj = new LibraryObject(bininfo.getID(), lowAddr, highAddr); @@ -287,7 +479,7 @@ public class MessageParser { pinfo.setMappingState(true); } else { - DATime changeTime = new DATime(sec, nano); + DATime changeTime = new DATime(log.getSec(), log.getNano()); DATime profileStartTime = project.getProfilingStartTime(); DATime subTime = changeTime.subtract(profileStartTime); @@ -312,332 +504,28 @@ public class MessageParser { } } - private void processTerminate() { - AnalyzerManager.decreaseProcessCount(); - } - - public void startMessageParsing(Socket dataSocket) { - InputStream inputStream = null; - PrintWriter printWriter = null; - - if (PRINT_DATA_LOG_TOFILE) { - File logPath = new File(PathManager.DA_DEBUG_DATA_CHANNEL_LOG_FILE); - if (logPath.exists()) { - logPath.delete(); - } - - try { - printWriter = new PrintWriter(new BufferedWriter(new FileWriter(logPath)), true); - } catch (IOException e) { - e.printStackTrace(); - } - } - - startTimer(); - // start DB insert threads - DBInsertManager.startInserters(); - - try { - long prevSeq = -1; - byte[] header = new byte[MSG_HEADER_SIZE]; - boolean normalTerminate = true; - - dataSocket.setSoTimeout(SOCKET_TIMEOUT_NORMAL); - inputStream = dataSocket.getInputStream(); - - while (true) { - int readSize = 0; - int toRead = MSG_HEADER_SIZE; - while (toRead > 0) { - readSize = inputStream.read(header, MSG_HEADER_SIZE - toRead, toRead); - toRead -= readSize; - if (!DACommunicator.isRunning() && readSize == -1) { - // manager socket closed!! - exit = true; - break; - } - } - - if (exit) { - normalTerminate = false; - break; - } - - // LOG! - // Logger.debug("header log"); - // ByteUtils.printByteArrayForStart(header); - - boolean continuity = true; - int id = ByteUtil.toInt(header, 0); - long seq = ByteUtil.toUIntByLong(header, INT_SIZE); - if (seq == 0) { - Global.getProject().incSeqRotation(); - if (prevSeq != -1) { - // if continuity of seq number is broken - Logger.error("Contunuity failed (%d) (%d)", prevSeq, seq); - continuity = false; - } - } else { - if (seq != prevSeq + 1) { - // continuity of seq number is broken - Logger.error("Contunuity failed (%d) (%d)", prevSeq, seq); - continuity = false; - } - } - prevSeq = seq; - - if (!continuity) { - Display.getDefault().asyncExec(new Runnable() { - @Override - public void run() { - final Shell shell = WorkbenchUtil.getWorkbenchWindow().getShell(); - DADialog dialog = new DADialog(shell, SWT.NONE, 550, 153); - dialog.setIcon(ImageResources.DIALOG_WARNING_ICON); - dialog.setMessage(UserErrorWarningLabels.WARNING_OVERHEAD_EXPLODE); - dialog.open(); - } - }); - - normalTerminate = false; - break; - } - - int payloadSize = ByteUtil.toInt(header, MSG_PAYLOAD_SIZE_INDEX); - if (payloadSize < 0 || payloadSize > DALimit.MAX_PAYLOAD_SIZE) { - // wrong message format, stop profiling - normalTerminate = false; - break; - } - - byte[] payload = null; - - try { - payload = new byte[payloadSize]; - } catch (NegativeArraySizeException e) { - e.printStackTrace(); - } - - toRead = payloadSize; - while (toRead > 0) { - readSize = inputStream.read(payload, payloadSize - toRead, toRead); - toRead -= readSize; - if (!DACommunicator.isRunning() && readSize == -1) { - // manager socket closed!! - exit = true; - break; - } - } - - if (exit) { - normalTerminate = false; - break; - } + private void processAddInfo(LogData log) { + // process command line name is changed (/proc//cmdline) + Project project = Global.getProject(); - byte[] buffer = new byte[MSG_HEADER_SIZE + payloadSize]; - System.arraycopy(header, 0, buffer, 0, MSG_HEADER_SIZE); - System.arraycopy(payload, 0, buffer, MSG_HEADER_SIZE, payloadSize); + byte[] data = log.getPayload(); + int index = 0; - if (PRINT_DATA_LOG_TOFILE && printWriter != null) { - printWriter.printf("%d %d %d %d %d :", id, ByteUtil.toInt(header, 4), - ByteUtil.toInt(header, 8), ByteUtil.toInt(header, 12), payloadSize); - for (int k = 0; k < payloadSize; k++) - printWriter.printf("%02x ", payload[k]); - printWriter.printf("\n"); - } + int pid = ByteUtil.toInt(data, index); + index += INT_SIZE; - if (!processMessage(buffer)) { - // unknown message id - normalTerminate = false; - break; - } + int length = LogDataUtils.getStringLength(index, data); + String name = new String(data, index, length); + index += length; - if (id == DataChannelConstants.MSG_DATA_TERMINATE) { - Logger.debug("message data terminate arrived!!!"); - Logger.performance("TEST", "While tracing", "Terminate Application"); - if (AnalyzerManager.getProcessCount() == 0) { - normalTerminate = true; - break; - } - } - } // end while() - - if (!normalTerminate) { - // send stop message to swap manager - DACommunicator.stopTrace(); - - // wait until receive all remaining packet from data socket - int readSize = 0; - byte[] tempbuf = new byte[EMPTY_BUFFER_SIZE]; - - // exit if no data is receive in timeout - dataSocket.setSoTimeout(SOCKET_TIMEOUT_ABNORMAL); - while (true) { - try { - readSize = inputStream.read(tempbuf, 0, EMPTY_BUFFER_SIZE); - if (readSize <= 0) - break; - } catch (IOException e) { - break; - } - } - } - - Logger.debug("Receive thread end!!"); - Logger.performance("TEST", "DA end", "End receive thread"); - if (!StartProcessManager.getInstance().isCancelled()) { - Display.getDefault().asyncExec(new Runnable() { - @Override - public void run() { - StopProcessManager.getInstance().stopProcessStart( - AnalyzerLabels.DLG_SUMMARIZING_DATA); // socket - // timeout - } - }); - } - } catch (IOException e) { - Logger.debug("### socket timeout - TODO: show this as a dialog."); //$NON-NLS-1$ - - if (AnalyzerManager.isRunning()) { - Display.getDefault().asyncExec(new Runnable() { - @Override - public void run() { - StopProcessManager.getInstance().stopProcessStart( - AnalyzerLabels.DLG_DEVICE_DISCONNECTED); // socket - // timeout - } - }); - } - } finally { - endingSteps(); - if (printWriter != null) { - CommonUtil.tryClose(printWriter); - } + ProcessInformation process = project.getProcessInformation(pid); + if (null != process) { + process.setProcessName(name); } } - private void endingSteps() { - Logger.debug("Ending steps!"); - DACommunicator.setRunning(false); - AnalyzerManager.setRunningState(false); - Global.setCurrentState(Global.STATE.PREPARE_END); - Display.getDefault().syncExec(new Runnable() { - @Override - public void run() { - ToolbarArea.getInstance().setToolbarState(ToolbarArea.TOOLBAR_STATE_READY); - } - }); - stopTimer(); - Logger.performance("TEST", "DA end", "Stop timer"); - addBufferToList(); - Logger.performance("TEST", "DA end", "Add buffer to list"); - - // stop DB insert thread - DBInsertManager.stopInserters(); - - if (!StartProcessManager.getInstance().isCancelled()) { - Logger.debug("start!! : stop log process");//$NON-NLS-1$ - StopLogProcessor.runStopLogProcessThread(); - } - - AnalyzerUtil.executeCommand(StopHandler.ID); - Logger.performance("TEST", "DA end", "Execute command - StopHandler"); - AnalyzerManager.setProcessInfoArrived(false); - ReplayTraceHandler.isReplay = false; - ReplayTraceHandler.startTime = null; + private void processTerminate() { + // do nothing currently } - // return false if message id is unknown - private boolean processMessage(byte[] data) { - boolean bret = true; - int id = ByteUtil.toInt(data, 0); - LogData log = null; - switch (id) { - case DataChannelConstants.MSG_DATA_PROCESS_INFO: - // setting process info - AnalyzerManager.increaseProcessCount(); - processProcessInfo(data); - break; - case DataChannelConstants.MSG_PROCESS_MAP: - case DataChannelConstants.MSG_PROCESS_UNMAP: - memoryMapChanged(data); - break; - case DataChannelConstants.MSG_DATA_TERMINATE: - processTerminate(); - break; - case DataChannelConstants.MSG_DATA_ERROR: - // process error message - break; - - case DataChannelConstants.MSG_DATA_SYSTEM: - Runtime runtime = Runtime.getRuntime(); - if ((runtime.totalMemory() - runtime.freeMemory()) >= runtime.maxMemory() * 0.95) { - DALimit.stopTraceAndOpenWarningDialog(); - } - - if (AnalyzerManager.isProcessInfoArrived()) { - // make log - log = LogDataFactory.createInstance(data); - if (null != log) { - buffer.add(log); - messageCount += 1; - } - } - break; - case DataChannelConstants.MSG_FUNCTION_ENTRY: - case DataChannelConstants.MSG_FUNCTION_EXIT: - case DataChannelConstants.MSG_DATA_SAMPLE: - case DataChannelConstants.MSG_CONTEXT_SWITCH_ENTRY: - case DataChannelConstants.MSG_CONTEXT_SWITCH_EXIT: - case DataChannelConstants.MSG_DATA_RECORD: - if (AnalyzerManager.isProcessInfoArrived()) { - // make log - log = LogDataFactory.createInstance(data); - if (null != log) { - buffer.add(log); - messageCount += 1; - } - } - break; - case DataChannelConstants.MSG_PROCESS_COMM: { - // process command line name is changed (/proc//cmdline) - int index = MSG_HEADER_SIZE; - int pid = ByteUtil.toInt(data, index); - index += INT_SIZE; - String name = ByteUtil.getString(data, index); - index += ByteUtil.getStringLength(data, index); - - ProcessInformation process = Global.getProject().getProcessInformation(pid); - - if (null != process) { - process.setProcessName(name); - } - } - break; - case DataChannelConstants.MSG_DATA_IMAGE: - break; - default: - if (id >= DataChannelConstants.MSG_PROBE_MIN - && id <= DataChannelConstants.MSG_PROBE_MAX) { // MSG_PROBE - if (AnalyzerManager.isProcessInfoArrived()) { - log = LogDataFactory.createInstance(data); - if (null != log) { - buffer.add(log); - messageCount++; - } - } - } else { - // unknown message id - bret = false; - } - - break; - } - - if (MSG_BUFFER_MAX <= messageCount) { - addBufferToList(); - messageCount = 0; - } - - return bret; - } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/PageDataManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/PageDataManager.java index 3583435..f70e7f5 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/PageDataManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/PageDataManager.java @@ -25,25 +25,22 @@ */ package org.tizen.dynamicanalyzer.swap.logparser; +import java.util.HashMap; import java.util.Map; import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; -import org.tizen.dynamicanalyzer.common.AnalyzerConstants; import org.tizen.dynamicanalyzer.common.AnalyzerManager; import org.tizen.dynamicanalyzer.constant.CommonConstants; +import org.tizen.dynamicanalyzer.database.DBInserter; +import org.tizen.dynamicanalyzer.database.DBTable; import org.tizen.dynamicanalyzer.util.Logger; public abstract class PageDataManager implements Runnable { protected String name = null; private Thread thread = null; private BlockingQueue logPackQueue = new LinkedBlockingQueue(); - - private enum State { - NOT_RUNNING, RUNNING, TO_BE_STOPED - } - - private State state = State.NOT_RUNNING; + private Map insertThreads = new HashMap(); public final String getName() { if (name == null) { @@ -53,54 +50,55 @@ public abstract class PageDataManager implements Runnable { return name; } - public final void updateLog(LogPackage logPack) { - try { - logPackQueue.put(logPack); - } catch (InterruptedException e) { - e.printStackTrace(); + public synchronized final void startThread() { + if (thread != null && thread.isAlive()) { + try { + thread.interrupt(); + thread.join(); + thread = null; + } catch (InterruptedException e) { + e.printStackTrace(); + return; + } } - } - private final LogPackage pollPack() { - LogPackage pack = null; - try { - if (state == State.RUNNING) - pack = logPackQueue.take(); // wait if empty - else if (state == State.TO_BE_STOPED) - pack = logPackQueue.poll(); // return null if empty - } catch (InterruptedException e) { - e.printStackTrace(); - } + thread = new Thread(null, this, getName()); + thread.start(); - return pack; + startInserters(); } - public synchronized final void startThread() { - if (thread == null || !thread.isAlive()) { - thread = new Thread(null, this, getName()); - state = State.RUNNING; - thread.start(); + public synchronized final void stopNormal() { + if (thread != null && thread.isAlive()) { + try { + thread.join(); + thread = null; + Logger.debug(getName() + " thread joined!"); //$NON-NLS-1$ + } catch (InterruptedException e) { + e.printStackTrace(); + } } + + clearAll(); + + stopInsertersNormal(); } - // "called stopThread" means that there is no more data - // coming in this page data manager - // It means that this function should be called only in data offerer - // when all data offer is finished. - public synchronized final void stopThread() { + public synchronized final void stopForced() { if (thread != null && thread.isAlive()) { try { - state = State.TO_BE_STOPED; - sendNotify(); - thread.join(AnalyzerConstants.THREAD_JOIN_WAIT_TIME); - state = State.NOT_RUNNING; + thread.interrupt(); + thread.join(); thread = null; - logPackQueue.clear(); Logger.debug(getName() + " thread joined!"); //$NON-NLS-1$ } catch (InterruptedException e) { e.printStackTrace(); } } + + clearAll(); + + stopInsertersForced(); } public final boolean isThreadAlive() { @@ -110,22 +108,80 @@ public abstract class PageDataManager implements Runnable { return true; } - private void sendNotify() { - LogPackage endOfStream = new LogPackage(); - endOfStream.setEndOfStream(); + public final void updateLog(LogPackage logPack) { + try { + logPackQueue.put(logPack); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + private final LogPackage pollPack() { + LogPackage pack = null; try { - logPackQueue.put(endOfStream); + pack = logPackQueue.take(); // wait if empty } catch (InterruptedException e) { e.printStackTrace(); } + + return pack; + } + + private final void clearAll() { + logPackQueue.clear(); + } + + public final DBInserter makeInserter(DBTable table) { + DBInserter ret = null; + String tablename = table.getTableName(); + if (!insertThreads.containsKey(tablename)) { + DBInserter thread = new DBInserter(table); + table.setDBInserter(thread); + insertThreads.put(tablename, thread); + ret = thread; + } else { + ret = insertThreads.get(tablename); + } + return ret; + } + + public final DBInserter getInserter(String tablename) { + return insertThreads.get(tablename); + } + + private final void startInserters() { + for (Map.Entry entry : insertThreads.entrySet()) { + DBInserter inserter = entry.getValue(); + inserter.start(); + } + } + + private final void stopInsertersNormal() { + for (Map.Entry entry : insertThreads.entrySet()) { + DBInserter thread = entry.getValue(); + thread.stopNormal(); + } + } + + private final void stopInsertersForced() { + for (Map.Entry entry : insertThreads.entrySet()) { + DBInserter thread = entry.getValue(); + thread.stopForced(); + } + } + + private final void setToStopInserter() { + for (Map.Entry entry : insertThreads.entrySet()) { + DBInserter thread = entry.getValue(); + thread.setToStop(); + } } @Override public final void run() { while (!AnalyzerManager.isExit()) { LogPackage pack = pollPack(); - if (null == pack || pack.isEndOfStream()) // stop thread + if (pack == null || pack == LogPackage.END_OF_QUEUE) // stop thread break; makeData(pack); @@ -133,6 +189,10 @@ public abstract class PageDataManager implements Runnable { onThreadStop(); + setToStopInserter(); + + clearAll(); + /* log for debug */ Logger.debug(getName() + " thread end!!"); //$NON-NLS-1$ } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/RecordEventObject.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/RecordEventObject.java index cbbc5a4..4739575 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/RecordEventObject.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/RecordEventObject.java @@ -26,16 +26,42 @@ */ package org.tizen.dynamicanalyzer.swap.model; -import org.tizen.dynamicanalyzer.swap.model.data.LogData; import org.tizen.dynamicanalyzer.util.ByteUtil; -public class RecordEventObject extends LogData { - private DATime eventTime = new DATime(); +public class RecordEventObject { + private int msgID = 0; + private long seq = 0; + private long time = 0; + private DATime eventTime = null; private int eventId = 0; private int eventType = 0; private int eventCode = 0; private int eventValue = 0; + public int getMsgID() { + return msgID; + } + + public void setMsgID(int id) { + msgID = id; + } + + public long getSeq() { + return seq; + } + + public void setSeq(long seq) { + this.seq = seq; + } + + public long getTime() { + return time; + } + + public void setTime(long time) { + this.time = time; + } + public int getEventId() { return eventId; } @@ -77,14 +103,14 @@ public class RecordEventObject extends LogData { } public byte[] getByteValues() { - return ByteUtil.getByte(eventTime.getByteValues(), eventId, eventType, - eventCode, eventValue); - } - - @Override - public int getPid() { - // TODO Auto-generated method stub - return 0; + return ByteUtil.getByte(eventTime.getByteValues(), eventId, eventType, eventCode, + eventValue); } + // @Override + // public int getPid() { + // // TODO Auto-generated method stub + // return 0; + // } + // } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ContextSwitchData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ContextSwitchData.java index 9757462..02fa9d7 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ContextSwitchData.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ContextSwitchData.java @@ -29,19 +29,19 @@ package org.tizen.dynamicanalyzer.swap.model.data; import static org.tizen.dynamicanalyzer.constant.CommonConstants.INT_SIZE; import static org.tizen.dynamicanalyzer.constant.CommonConstants.LONG_SIZE; -import org.tizen.dynamicanalyzer.swap.logparser.MessageParser; +import org.tizen.dynamicanalyzer.swap.model.DATime; import org.tizen.dynamicanalyzer.util.ByteUtil; public class ContextSwitchData extends LogData { - - long pcAddr = 0; - int pid = 0; - int tid = 0; - int cpuNum = 0; + protected long pcAddr = 0; + protected int pid = 0; + protected int tid = 0; + protected int cpuNum = 0; public ContextSwitchData() { } + @Override public ContextSwitchData clone() throws CloneNotSupportedException { ContextSwitchData log = (ContextSwitchData) super.clone(); log.pcAddr = this.pcAddr; @@ -52,17 +52,17 @@ public class ContextSwitchData extends LogData { return log; } - public boolean makeData(byte[] data) { - super.makeData(data); - index = MessageParser.MSG_HEADER_SIZE; + @Override + protected boolean makeData(DATime startTime) { + super.makeData(startTime); - pcAddr = ByteUtil.toLong(data, index); + pcAddr = ByteUtil.toLong(payload, index); index += LONG_SIZE; - pid = ByteUtil.toInt(data, index); + pid = ByteUtil.toInt(payload, index); index += INT_SIZE; - tid = ByteUtil.toInt(data, index); + tid = ByteUtil.toInt(payload, index); index += INT_SIZE; - cpuNum = ByteUtil.toInt(data, index); + cpuNum = ByteUtil.toInt(payload, index); index += INT_SIZE; return true; diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ControlData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ControlData.java index 58b8b6c..dd9f275 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ControlData.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ControlData.java @@ -28,6 +28,7 @@ package org.tizen.dynamicanalyzer.swap.model.data; import static org.tizen.dynamicanalyzer.constant.CommonConstants.LONG_SIZE; +import org.tizen.dynamicanalyzer.swap.model.DATime; import org.tizen.dynamicanalyzer.util.ByteUtil; public class ControlData extends ProbeCommonData { @@ -40,38 +41,45 @@ public class ControlData extends ProbeCommonData { public ControlData() { } + + @Override + public ControlData clone() throws CloneNotSupportedException { + ControlData log = (ControlData) super.clone(); + log.parentName = this.parentName; + log.parentClassName = this.parentClassName; + log.parentPointer = this.parentPointer; + log.childName = this.childName; + log.childClassName = this.childClassName; + log.childPointer = this.childPointer; + + return log; + } - public boolean makeData(byte[] data) { - super.makeData(data); + @Override + protected boolean makeData(DATime startTime) { + super.makeData(startTime); - int length = LogDataUtils.getStringLength(index, data); - byte[] temp = new byte[length]; - System.arraycopy(data, index, temp, 0, length); - parentName = new String(temp); + int length = LogDataUtils.getStringLength(index, payload); + parentName = new String(payload, index, length); index += length; - length = LogDataUtils.getStringLength(index, data); - temp = new byte[length]; - System.arraycopy(data, index, temp, 0, length); - parentClassName = new String(temp); + length = LogDataUtils.getStringLength(index, payload); + parentClassName = new String(payload, index, length); index += length; - parentPointer = ByteUtil.toLong(data, index); + parentPointer = ByteUtil.toLong(payload, index); index += LONG_SIZE; - length = LogDataUtils.getStringLength(index, data); - temp = new byte[length]; - System.arraycopy(data, index, temp, 0, length); - childName = new String(temp); + length = LogDataUtils.getStringLength(index, payload); + childName = new String(payload, index, length); index += length; - length = LogDataUtils.getStringLength(index, data); - temp = new byte[length]; - System.arraycopy(data, index, temp, 0, length); - childClassName = new String(temp); + length = LogDataUtils.getStringLength(index, payload); + childClassName = new String(payload, index, length); index += length; - childPointer = ByteUtil.toLong(data, index); + childPointer = ByteUtil.toLong(payload, index); + index += LONG_SIZE; return true; } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/CustomData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/CustomData.java index a49d5de..6feb688 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/CustomData.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/CustomData.java @@ -26,39 +26,54 @@ */ package org.tizen.dynamicanalyzer.swap.model.data; +import static org.tizen.dynamicanalyzer.constant.CommonConstants.DOUBLE_SIZE; import static org.tizen.dynamicanalyzer.constant.CommonConstants.INT_SIZE; +import org.tizen.dynamicanalyzer.swap.model.DATime; import org.tizen.dynamicanalyzer.util.ByteUtil; public class CustomData extends ProbeCommonData { - int handle = 0; - int type = 0; - String name = null; - int color = 0; - double value = 0; + protected int handle = 0; + protected int type = 0; + protected String name = null; + protected int color = 0; + protected double value = 0; - public CustomData(){} + public CustomData(){ + } + + @Override + public CustomData clone() throws CloneNotSupportedException { + CustomData log = (CustomData) super.clone(); + log.handle = this.handle; + log.type = this.type; + log.name = this.name; + log.color = this.color; + log.value = this.value; + + return log; + } - public boolean makeData(byte[] data) { - super.makeData(data); + @Override + protected boolean makeData(DATime startTime) { + super.makeData(startTime); - handle = ByteUtil.toInt(data, index); + handle = ByteUtil.toInt(payload, index); index += INT_SIZE; - type = ByteUtil.toInt(data, index); + type = ByteUtil.toInt(payload, index); index += INT_SIZE; - int length = LogDataUtils.getStringLength(index, data); - byte[] temp = new byte[length]; - System.arraycopy(data, index, temp, 0, length); - name = new String(temp); + int length = LogDataUtils.getStringLength(index, payload); + name = new String(payload, index, length); index += length; - color = ByteUtil.toInt(data, index); + color = ByteUtil.toInt(payload, index); index += INT_SIZE; - value = ByteUtil.toDouble(data, index); + value = ByteUtil.toDouble(payload, index); + index += DOUBLE_SIZE; return true; } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/FileData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/FileData.java index 27f4d02..0130b39 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/FileData.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/FileData.java @@ -29,6 +29,7 @@ package org.tizen.dynamicanalyzer.swap.model.data; import static org.tizen.dynamicanalyzer.constant.CommonConstants.INT_SIZE; import static org.tizen.dynamicanalyzer.constant.CommonConstants.LONG_SIZE; +import org.tizen.dynamicanalyzer.swap.model.DATime; import org.tizen.dynamicanalyzer.util.ByteUtil; public class FileData extends ProbeCommonData { @@ -38,7 +39,45 @@ public class FileData extends ProbeCommonData { protected int fdApiType = 0; // TODO: short protected long fileSize = 0; protected String filePath = null; - + + public FileData() { + } + + @Override + public FileData clone() throws CloneNotSupportedException { + FileData log = (FileData) super.clone(); + log.size = this.size; + log.fdValue = this.fdValue; + log.fdApiType = this.fdApiType; + log.fileSize = this.fileSize; + log.filePath = this.filePath; + + return log; + } + + @Override + protected boolean makeData(DATime startTime) { + super.makeData(startTime); + + size = ByteUtil.toLong(payload, index); + index += LONG_SIZE; + + fdValue = ByteUtil.toLong(payload, index); + index += LONG_SIZE; + + fdApiType = ByteUtil.toInt(payload, index); + index += INT_SIZE; + + fileSize = ByteUtil.toLong(payload, index); + index += LONG_SIZE; + + int length = LogDataUtils.getStringLength(index, payload); + filePath = new String(payload, index, length); + index += length; + + return true; + } + public long getSize() { return size; } @@ -79,32 +118,8 @@ public class FileData extends ProbeCommonData { this.filePath = filePath; } - public FileData() { - } - - public boolean makeData(byte[] data) { - super.makeData(data); - - size = ByteUtil.toLong(data, index); - index += LONG_SIZE; - - fdValue = ByteUtil.toLong(data, index); - index += LONG_SIZE; - - fdApiType = ByteUtil.toInt(data, index); - index += INT_SIZE; - - fileSize = ByteUtil.toLong(data, index); - index += LONG_SIZE; - - filePath = LogDataUtils.getString(index, data); - - return true; - } - @Override public int getKey() { - Long key = getFdValue(); - return key.hashCode(); + return (int) (fdValue ^ (fdValue >>> 32)); } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/GLES20LogData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/GLES20LogData.java index 977fb74..54af846 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/GLES20LogData.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/GLES20LogData.java @@ -29,31 +29,43 @@ package org.tizen.dynamicanalyzer.swap.model.data; import org.tizen.dynamicanalyzer.constant.CommonConstants; +import org.tizen.dynamicanalyzer.swap.model.DATime; import org.tizen.dynamicanalyzer.util.ByteUtil; public class GLES20LogData extends ProbeCommonData { protected long glCurrentContextName = 0; - int apiType = 0; - long elapsedTime = 0; - String contextValue = ""; + protected int apiType = 0; + protected long elapsedTime = 0; + protected String contextValue = null; @Override - public boolean makeData(byte[] data) { - super.makeData(data); - glCurrentContextName = ByteUtil.toLong(data, index); + public GLES20LogData clone() throws CloneNotSupportedException { + GLES20LogData log = (GLES20LogData) super.clone(); + log.glCurrentContextName = this.glCurrentContextName; + log.apiType = this.apiType; + log.elapsedTime = this.elapsedTime; + log.contextValue = this.contextValue; + + return log; + } + + @Override + protected boolean makeData(DATime startTime) { + super.makeData(startTime); + + glCurrentContextName = ByteUtil.toLong(payload, index); index += CommonConstants.LONG_SIZE; - apiType = ByteUtil.toInt(data, index); + apiType = ByteUtil.toInt(payload, index); index += CommonConstants.INT_SIZE; - elapsedTime = ByteUtil.toLong(data, index)/1000; + elapsedTime = ByteUtil.toLong(payload, index) / 1000L; index += CommonConstants.LONG_SIZE; - int length = LogDataUtils.getStringLength(index, data); - byte[] temp = new byte[length]; - System.arraycopy(data, index, temp, 0, length); - contextValue = new String(temp); - + int length = LogDataUtils.getStringLength(index, payload); + contextValue = new String(payload, index, length); + index += length; + return true; } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LifeCycleData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LifeCycleData.java deleted file mode 100644 index 4cea51a..0000000 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LifeCycleData.java +++ /dev/null @@ -1,33 +0,0 @@ -/* - * Dynamic Analyzer - * - * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved. - * - * Contact: - * Jungwook Ryu - * 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.model.data; - -public class LifeCycleData extends ProbeCommonData { - - public LifeCycleData() { - } -} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LogData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LogData.java index c750a3c..279ffdc 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LogData.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LogData.java @@ -26,27 +26,25 @@ */ package org.tizen.dynamicanalyzer.swap.model.data; -import static org.tizen.dynamicanalyzer.constant.CommonConstants.INT_SIZE; - -import org.tizen.dynamicanalyzer.common.Global; -import org.tizen.dynamicanalyzer.communicator.DACommunicator; +import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants; import org.tizen.dynamicanalyzer.swap.model.DATime; import org.tizen.dynamicanalyzer.util.ByteUtil; import org.tizen.dynamicanalyzer.util.Logger; -import org.tizen.dynamicanalyzer.util.UnsignedInt; import org.tizen.dynamicanalyzer.utils.AnalyzerUtil; -public abstract class LogData implements Cloneable { - public static boolean isSWAP = false; - public static int STATE_COUNT = 4; +public class LogData implements Cloneable { + public static final LogData END_OF_QUEUE = new LogData(); protected int index = 0; - int id = -1; + protected int msgID = -1; protected long seq = -1; + protected int sec = 0; + protected int nano = 0; protected long time = 0; - protected String libName = null; + private int payloadSize = 0; + protected byte[] payload = null; public LogData() { } @@ -54,92 +52,98 @@ public abstract class LogData implements Cloneable { public LogData clone() throws CloneNotSupportedException { LogData log = (LogData) super.clone(); log.index = this.index; - log.id = this.id; + log.msgID = this.msgID; log.seq = this.seq; + log.sec = this.sec; + log.nano = this.nano; log.time = this.time; - log.libName = this.libName; return log; } - public boolean makeData(byte[] data) { - isSWAP = DACommunicator.isSWAPVersion(); - - id = ByteUtil.toInt(data, index); - index += INT_SIZE; - - int seqRot = Global.getProject().getSeqRotation(); - UnsignedInt subSeq = ByteUtil.toUnsignedInt(data, index); - index += INT_SIZE; - - seq = (((long)seqRot) << 32 | subSeq.getValue()); + public final void init(byte[] header) { + msgID = ByteUtil.toInt(header, DataChannelConstants.MSGID_INDEX); + seq = ByteUtil.toUIntByLong(header, DataChannelConstants.SEQNUM_INDEX); + sec = ByteUtil.toInt(header, DataChannelConstants.TIME_SEC_INDEX); + nano = ByteUtil.toInt(header, DataChannelConstants.TIME_NANO_INDEX); - long sec = ByteUtil.toInt(data, index); - index += INT_SIZE; - long nano = ByteUtil.toInt(data, index); - index += INT_SIZE; + payloadSize = ByteUtil.toInt(header, DataChannelConstants.PAYLOADLEN_INDEX); + if (payloadSize > 0) { + payload = new byte[payloadSize]; + } + } - DATime startTime = Global.getProject().getProfilingStartTime(); - long startSec = startTime.getSec(); - long startNano = startTime.getNano(); - long resultSec = sec - startSec; - long resultNano = nano - startNano; + protected boolean makeData(DATime startTime) { + long resultSec = sec - startTime.getSec(); + long resultNano = nano - startTime.getNano(); time = resultSec * 1000000 + resultNano / 1000; - if (time <= 0) { - Logger.warning("id : " + AnalyzerUtil.toHexdecimal(id) - + " time : " + time); - Logger.warning("profile start time : " - + startTime.toString() + " time : " + sec + "," + if (time < 0) { + Logger.warning("id : " + AnalyzerUtil.toHexdecimal(msgID) + " time : " + time); + Logger.warning("profile start time : " + startTime.toString() + " time : " + sec + "," + nano); } - index += INT_SIZE; // payload length field offset - return true; } - public int getKey() { - Long key = getSeq(); - return key.hashCode(); + public boolean makeDataPublic(DATime startTime) { + boolean result = makeData(startTime); + // release payload buffer for GC + payload = null; + + return result; } - // indicate DB row number - public int getLogNum() { - return 0; + public int getPayloadSize() { + return payloadSize; } - public int getId() { - return id; + public int getKey() { + return (int) (seq ^ (seq >>> 32)); + } + + public final int getMsgID() { + return msgID; } - public void setId(int id) { - this.id = id; + public final void setMsgID(int id) { + this.msgID = id; } - public long getSeq() { + public final long getSeq() { return seq; } - public void setSeq(long seq) { + public final void setSeq(long seq) { this.seq = seq; } - public long getTime() { + public final void adjustSeq(int seqRot) { + seq = (((long) seqRot) << 32 | seq); + } + + public final long getTime() { return time; } - public void setTime(long time) { + public final void setTime(long time) { this.time = time; } - public abstract int getPid(); + public final byte[] getPayload() { + return payload; + } + + public int getPid() { + return 0; + } - public String getLibName() { - return libName; + public int getSec() { + return sec; } - public void setLibName(String libName) { - this.libName = libName; + public int getNano() { + return nano; } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LogDataFactory.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LogDataFactory.java index 41c74aa..420eff8 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LogDataFactory.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LogDataFactory.java @@ -50,15 +50,12 @@ import static org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants.M import java.util.ArrayList; import java.util.List; +import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants; import org.tizen.dynamicanalyzer.util.ByteUtil; public class LogDataFactory { private static List logIDList = new ArrayList(); - private LogDataFactory() { - // is static class - } - public static List getLogIDList() { if (logIDList.isEmpty()) { initLogIDList(); @@ -89,9 +86,8 @@ public class LogDataFactory { logIDList.add(MSG_CONTEXT_SWITCH_EXIT); } - public static LogData createInstance(byte[] data) { - boolean result; - int id = ByteUtil.toInt(data, 0); + public static LogData createInstance(byte[] header) { + int id = ByteUtil.toInt(header, DataChannelConstants.MSGID_INDEX); LogData output = null; switch (id) { @@ -159,14 +155,13 @@ public class LogDataFactory { output = new ContextSwitchData(); break; default: - return null; - } - result = output.makeData(data); - if (result == true) { - return output; - } else { // error occurred during parse LogData - return null; + output = new LogData(); + break; } + + output.init(header); + + return output; } public static String getLogFormatName(int id) { @@ -231,7 +226,4 @@ public class LogDataFactory { } return formatName; } - - public static void clean() { - } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LogDataSeqNoComparator.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LogDataSeqComparator.java similarity index 93% rename from org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LogDataSeqNoComparator.java rename to org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LogDataSeqComparator.java index b707c02..98cf427 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LogDataSeqNoComparator.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LogDataSeqComparator.java @@ -27,7 +27,7 @@ package org.tizen.dynamicanalyzer.swap.model.data; import java.util.Comparator; -public class LogDataSeqNoComparator implements Comparator { +public class LogDataSeqComparator implements Comparator { @Override public int compare(LogData arg0, LogData arg1) { diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LogDataUtils.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LogDataUtils.java index 8338715..be59a71 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LogDataUtils.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LogDataUtils.java @@ -216,13 +216,4 @@ public class LogDataUtils { } return length; } - - public static String getString(int start, byte[] payload) { - int length = LogDataUtils.getStringLength(start, payload); - byte[] temp = new byte[length]; - System.arraycopy(payload, start, temp, 0, length); - String str = new String(temp); - str = str.substring(0, str.length() - 1); - return str; - } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/MemoryData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/MemoryData.java index 3a2345b..7975155 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/MemoryData.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/MemoryData.java @@ -29,26 +29,40 @@ package org.tizen.dynamicanalyzer.swap.model.data; import static org.tizen.dynamicanalyzer.constant.CommonConstants.INT_SIZE; import static org.tizen.dynamicanalyzer.constant.CommonConstants.LONG_SIZE; +import org.tizen.dynamicanalyzer.swap.model.DATime; import org.tizen.dynamicanalyzer.util.ByteUtil; public class MemoryData extends ProbeCommonData { - long size = 0; - int apiType = 0; // TODO: short - long address = 0; + protected long size = 0; + protected int apiType = 0; // TODO: short + protected long address = 0; public MemoryData() { } - public boolean makeData(byte[] data) { - super.makeData(data); - size = ByteUtil.toInt(data, index); + @Override + public MemoryData clone() throws CloneNotSupportedException { + MemoryData log = (MemoryData) super.clone(); + log.size = this.size; + log.apiType = this.apiType; + log.address = this.address; + + return log; + } + + @Override + protected boolean makeData(DATime startTime) { + super.makeData(startTime); + size = ByteUtil.toInt(payload, index); index += LONG_SIZE; - apiType = ByteUtil.toInt(data, index); + + apiType = ByteUtil.toInt(payload, index); index += INT_SIZE; - address = ByteUtil.toLong(data, index); - + address = ByteUtil.toLong(payload, index); + index += LONG_SIZE; + return true; } @@ -78,7 +92,6 @@ public class MemoryData extends ProbeCommonData { @Override public int getKey() { - Long key = getAddress(); - return key.hashCode(); + return (int) (address ^ (address >>> 32)); } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/NetworkData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/NetworkData.java index 305077e..6250e95 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/NetworkData.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/NetworkData.java @@ -31,17 +31,61 @@ import static org.tizen.dynamicanalyzer.constant.CommonConstants.INT_SIZE; import static org.tizen.dynamicanalyzer.constant.CommonConstants.LONG_SIZE; import org.tizen.dynamicanalyzer.constant.CommonConstants; +import org.tizen.dynamicanalyzer.swap.model.DATime; import org.tizen.dynamicanalyzer.util.ByteUtil; public class NetworkData extends ProbeCommonData { - long objectAddress = 0; - long fdValue = 0; + protected long objectAddress = 0; + protected long fdValue = 0; protected int fdApiType = 0; - int destinationIPAddress = 0; - int destinationPortAddress = 0; - protected String packetMessage = CommonConstants.EMPTY; + protected int destinationIPAddress = 0; + protected int destinationPortAddress = 0; protected int messageSize = 0; + protected String packetMessage = null; + + @Override + public NetworkData clone() throws CloneNotSupportedException { + NetworkData log = (NetworkData) super.clone(); + log.objectAddress = this.objectAddress; + log.fdValue = this.fdValue; + log.fdApiType = this.fdApiType; + log.destinationIPAddress = this.destinationIPAddress; + log.destinationPortAddress = this.destinationPortAddress; + log.packetMessage = this.packetMessage; + log.messageSize = this.messageSize; + + return log; + } + + @Override + protected boolean makeData(DATime startTime) { + super.makeData(startTime); + + objectAddress = ByteUtil.toLong(payload, index); + index += LONG_SIZE; + + fdValue = ByteUtil.toLong(payload, index); + index += LONG_SIZE; + + fdApiType = ByteUtil.toInt(payload, index); + index += INT_SIZE; + + destinationIPAddress = ByteUtil.toInt(payload, index); + index += INT_SIZE; + + destinationPortAddress = ByteUtil.toInt(payload, index); + index += INT_SIZE; + + // TODO : may data loss by messageSize cast to int + messageSize = (int) ByteUtil.toLong(payload, index); + index += LONG_SIZE; + if (messageSize > 0) { + packetMessage = new String(payload, index, messageSize); + } + + return true; + } public long getObjectAddress() { return objectAddress; @@ -76,8 +120,7 @@ public class NetworkData extends ProbeCommonData { } public String getDestinationAddress() { - return getdestinationIPAddress() + CommonConstants.NEW_LINE - + getDestinationPortAddress(); + return getdestinationIPAddress() + CommonConstants.NEW_LINE + getDestinationPortAddress(); } public void setFdApiType(int fdApiType) { @@ -87,43 +130,14 @@ public class NetworkData extends ProbeCommonData { public NetworkData() { } - public boolean makeData(byte[] data) { - super.makeData(data); - - objectAddress = ByteUtil.toLong(data, index); - index += LONG_SIZE; - - fdValue = ByteUtil.toLong(data, index); - index += LONG_SIZE; - - fdApiType = ByteUtil.toInt(data, index); - index += INT_SIZE; - - destinationIPAddress = ByteUtil.toInt(data, index); - index += INT_SIZE; - - destinationPortAddress = ByteUtil.toInt(data, index); - index += INT_SIZE; - - messageSize = ByteUtil.toInt(data, index); - index += LONG_SIZE; - if (messageSize > 0) { - packetMessage = LogDataUtils.getString(index, data); - } - - return true; - } - public static String intToIp(int integerIP) { - return (integerIP & 0xFF) + CommonConstants.DOT - + ((integerIP >> 8) & 0xFF) + CommonConstants.DOT - + ((integerIP >> 16) & 0xFF) + CommonConstants.DOT + return (integerIP & 0xFF) + CommonConstants.DOT + ((integerIP >> 8) & 0xFF) + + CommonConstants.DOT + ((integerIP >> 16) & 0xFF) + CommonConstants.DOT + ((integerIP >> 24) & 0xFF); } @Override public int getKey() { - Long key = getFdValue(); - return key.hashCode(); + return (int)(fdValue ^ (fdValue >>> 32)); } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ProbeCommonData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ProbeCommonData.java index 7c20ead..9553f0e 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ProbeCommonData.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ProbeCommonData.java @@ -32,18 +32,11 @@ import static org.tizen.dynamicanalyzer.constant.CommonConstants.LONG_SIZE; import org.tizen.dynamicanalyzer.common.AnalyzerConstants; import org.tizen.dynamicanalyzer.common.DALimit; import org.tizen.dynamicanalyzer.common.Global; -import org.tizen.dynamicanalyzer.project.BinaryInfo; -import org.tizen.dynamicanalyzer.project.LibraryObject; -import org.tizen.dynamicanalyzer.project.ProcessInformation; -import org.tizen.dynamicanalyzer.project.ProcessMemoryMap; -import org.tizen.dynamicanalyzer.swap.logparser.MessageParser; +import org.tizen.dynamicanalyzer.swap.model.DATime; import org.tizen.dynamicanalyzer.util.ByteUtil; public class ProbeCommonData extends LogData { - - public static int STATE_COUNT = LogData.STATE_COUNT + 11; - - protected int apiId = 0; + protected int apiID = 0; protected int pid = 0; protected int tid = 0; protected String args = null; @@ -54,6 +47,7 @@ public class ProbeCommonData extends LogData { protected int reserved1 = 0; protected int reserved2 = 0; + protected String libName = null; private String apiName = null; public ProbeCommonData() { @@ -64,7 +58,7 @@ public class ProbeCommonData extends LogData { String ret, int errno) { this.seq = seq; this.time = time; - this.apiId = apiId; + this.apiID = apiId; this.pid = pid; this.tid = tid; this.args = args; @@ -72,9 +66,10 @@ public class ProbeCommonData extends LogData { this.errno = errno; } + @Override public ProbeCommonData clone() throws CloneNotSupportedException { ProbeCommonData log = (ProbeCommonData) super.clone(); - log.apiId = this.apiId; + log.apiID = this.apiID; log.pid = this.pid; log.tid = this.tid; log.args = this.args; @@ -84,76 +79,66 @@ public class ProbeCommonData extends LogData { log.callerAddress = this.callerAddress; log.reserved1 = this.reserved1; log.reserved2 = this.reserved2; + log.libName = this.libName; + log.apiName = this.apiName; return log; } @Override - public boolean makeData(byte[] data) { - super.makeData(data); - index = MessageParser.MSG_HEADER_SIZE; + protected boolean makeData(DATime startTime) { + super.makeData(startTime); - apiId = ByteUtil.toInt(data, index); + apiID = ByteUtil.toInt(payload, index); index += INT_SIZE; - pid = ByteUtil.toInt(data, index); + pid = ByteUtil.toInt(payload, index); index += INT_SIZE; - tid = ByteUtil.toInt(data, index); + tid = ByteUtil.toInt(payload, index); index += INT_SIZE; - ArgsInfo argInfo = LogDataUtils.parseArgs(data, index); + ArgsInfo argInfo = LogDataUtils.parseArgs(payload, index); args = argInfo.getArgs(); index = argInfo.getLastIndex(); if (args.length() > DALimit.FUNCTION_ARGUMENTS_VALUE_LENGTH) { args = args.substring(0, DALimit.FUNCTION_ARGUMENTS_VALUE_LENGTH); } - ArgsInfo retInfo = LogDataUtils.parseReturn(data, index); + ArgsInfo retInfo = LogDataUtils.parseReturn(payload, index); ret = retInfo.getArgs(); index = retInfo.getLastIndex(); if (ret.length() > DALimit.FUNCTION_RETURN_VALUE_LENGTH) { ret = ret.substring(0, DALimit.FUNCTION_RETURN_VALUE_LENGTH); } - errno = ByteUtil.toLong(data, index); + errno = ByteUtil.toLong(payload, index); index += LONG_SIZE; - internalCall = ByteUtil.toInt(data, index); + internalCall = ByteUtil.toInt(payload, index); index += INT_SIZE; - callerAddress = ByteUtil.toLong(data, index); + callerAddress = ByteUtil.toLong(payload, index); index += LONG_SIZE; - reserved1 = ByteUtil.toInt(data, index); + reserved1 = ByteUtil.toInt(payload, index); index += INT_SIZE; - reserved2 = ByteUtil.toInt(data, index); + reserved2 = ByteUtil.toInt(payload, index); index += INT_SIZE; - ProcessInformation process = Global.getProject().getProcessInformation(pid); - if (time > 0) { - LibraryObject obj = null; - ProcessMemoryMap pmap = process.getProcessMemoryMap(time); - if (pmap == null || (obj = pmap.getLibraryByAddress(callerAddress)) == null) { - libName = "unknown"; - } else { - BinaryInfo binInfo = Global.getProject().getDeviceStatusInfo() - .getBinaryInfo(obj.getBinaryID()); - libName = binInfo.getTargetBinaryPath(); - } - // Logger.debug("lib name : " + libName); - } + int binID = Global.getBinaryID(pid, time, callerAddress); + libName = Global.getLibraryName(binID); return true; } public int getApiId() { - return apiId; + return apiID; } public void setApiId(int apiId) { - this.apiId = apiId; + this.apiID = apiId; } public int getPid() { @@ -230,7 +215,7 @@ public class ProbeCommonData extends LogData { public String getApiName() { if (null == apiName) { - apiName = Global.getFunctionName(apiId); + apiName = Global.getFunctionName(apiID); } return apiName; } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ProfileData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ProfileData.java index 25be027..c0b7e84 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ProfileData.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ProfileData.java @@ -36,38 +36,36 @@ import static org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants.M import org.tizen.dynamicanalyzer.common.AnalyzerConstants; import org.tizen.dynamicanalyzer.common.Global; -import org.tizen.dynamicanalyzer.project.LibraryObject; -import org.tizen.dynamicanalyzer.project.ProcessInformation; -import org.tizen.dynamicanalyzer.project.ProcessMemoryMap; +import org.tizen.dynamicanalyzer.swap.model.DATime; import org.tizen.dynamicanalyzer.util.ByteUtil; -import org.tizen.dynamicanalyzer.util.Logger; public class ProfileData extends LogData { public static int logCount = 0; - long pcAddr = 0; // profiling common - long callerPcAddr = 0; // function entry specific - int probeType = 0;// function entry specific - int probeSubType = 0;// function entry specific - int pid = 0; // profiling common - int tid = 0; // profiling common - int cpuNum = 0; // profiling common - String args = null; // function entry specific - String ret = null; - int apiId = -1; - long entrySeq = -1; // for entry/exit log matching - - int buildType = -1; - int binaryId = -1; - - String callstack = null; + + protected int pid = 0; // profiling common + protected int tid = 0; // profiling common + protected int probeType = 0;// function entry specific + protected int probeSubType = 0;// function entry specific + protected long pcAddr = 0; // profiling common + protected long callerPcAddr = 0; // function entry specific + protected int cpuNum = 0; // profiling common + protected String args = null; // function entry specific + protected String ret = null; + protected int apiId = -1; + protected long entrySeq = -1; // for entry/exit log matching + + protected int buildType = -1; + protected int binaryId = -1; + + protected String callstack = null; public ProfileData() { } /** make function entry/exit from Database **/ - public ProfileData(int id, long seq, int pid, int tid, int apiId, - int binaryId, long time, long callerPcAddr, long pcAddr) { - this.id = id; + public ProfileData(int id, long seq, int pid, int tid, int apiId, int binaryId, long time, + long callerPcAddr, long pcAddr) { + this.msgID = id; this.seq = seq; this.pid = pid; this.tid = tid; @@ -80,13 +78,14 @@ public class ProfileData extends LogData { /** make function sample from Database **/ public ProfileData(long time, int pid, int tid, long pcAddr) { - this.id = MSG_DATA_SAMPLE; + this.msgID = MSG_DATA_SAMPLE; this.time = time; this.pid = pid; this.tid = tid; this.pcAddr = pcAddr; } + @Override public ProfileData clone() throws CloneNotSupportedException { ProfileData log = (ProfileData) super.clone(); log.pcAddr = this.pcAddr; @@ -107,107 +106,91 @@ public class ProfileData extends LogData { return log; } - public boolean makeData(byte[] data) { - super.makeData(data); - + @Override + protected boolean makeData(DATime startTime) { + super.makeData(startTime); + byte[] temp = new byte[4]; - switch (id) { + switch (msgID) { case MSG_FUNCTION_ENTRY: logCount++; - pid = ByteUtil.toInt(data, index); + pid = ByteUtil.toInt(payload, index); index += INT_SIZE; - tid = ByteUtil.toInt(data, index); + tid = ByteUtil.toInt(payload, index); index += INT_SIZE; - System.arraycopy(data, index, temp, 0, 2); + System.arraycopy(payload, index, temp, 0, 2); probeType = ByteUtil.toInt(temp, 0); index += 2; - System.arraycopy(data, index, temp, 0, 2); + System.arraycopy(payload, index, temp, 0, 2); probeSubType = ByteUtil.toInt(temp, 0); index += 2; - pcAddr = ByteUtil.toLong(data, index); + pcAddr = ByteUtil.toLong(payload, index); index += LONG_SIZE; - callerPcAddr = ByteUtil.toLong(data, index); + callerPcAddr = ByteUtil.toLong(payload, index); index += LONG_SIZE; - cpuNum = ByteUtil.toInt(data, index); + cpuNum = ByteUtil.toInt(payload, index); index += INT_SIZE; - ArgsInfo info = LogDataUtils.parseArgs(data, index); + ArgsInfo info = LogDataUtils.parseArgs(payload, index); args = info.getArgs(); index = info.getLastIndex(); break; case MSG_FUNCTION_EXIT: logCount++; - pid = ByteUtil.toInt(data, index); + pid = ByteUtil.toInt(payload, index); index += INT_SIZE; - tid = ByteUtil.toInt(data, index); + tid = ByteUtil.toInt(payload, index); index += INT_SIZE; - - System.arraycopy(data, index, temp, 0, 2); + + System.arraycopy(payload, index, temp, 0, 2); probeType = ByteUtil.toInt(temp, 0); index += 2; - System.arraycopy(data, index, temp, 0, 2); + System.arraycopy(payload, index, temp, 0, 2); probeSubType = ByteUtil.toInt(temp, 0); index += 2; - - pcAddr = ByteUtil.toLong(data, index); + + pcAddr = ByteUtil.toLong(payload, index); index += LONG_SIZE; - callerPcAddr = ByteUtil.toLong(data, index); + callerPcAddr = ByteUtil.toLong(payload, index); index += LONG_SIZE; - cpuNum = ByteUtil.toInt(data, index); + + cpuNum = ByteUtil.toInt(payload, index); index += INT_SIZE; - ArgsInfo retInfo = LogDataUtils.parseReturn(data, index); + ArgsInfo retInfo = LogDataUtils.parseReturn(payload, index); ret = retInfo.getArgs(); index = retInfo.getLastIndex(); break; case MSG_CONTEXT_SWITCH_ENTRY: case MSG_CONTEXT_SWITCH_EXIT: - pcAddr = ByteUtil.toLong(data, index); + pcAddr = ByteUtil.toLong(payload, index); index += LONG_SIZE; - pid = ByteUtil.toInt(data, index); + pid = ByteUtil.toInt(payload, index); index += INT_SIZE; - tid = ByteUtil.toInt(data, index); + tid = ByteUtil.toInt(payload, index); index += INT_SIZE; - cpuNum = ByteUtil.toInt(data, index); + cpuNum = ByteUtil.toInt(payload, index); index += INT_SIZE; break; case MSG_DATA_SAMPLE: - pid = ByteUtil.toInt(data, index); + pid = ByteUtil.toInt(payload, index); index += INT_SIZE; - pcAddr = ByteUtil.toLong(data, index); + pcAddr = ByteUtil.toLong(payload, index); index += LONG_SIZE; - tid = ByteUtil.toInt(data, index); + tid = ByteUtil.toInt(payload, index); index += INT_SIZE; - cpuNum = ByteUtil.toInt(data, index); + cpuNum = ByteUtil.toInt(payload, index); index += INT_SIZE; break; - default: break; } if (probeType != AnalyzerConstants.FUNCTION_TYPE_FILE) { - ProcessInformation process = Global.getProject().getProcessInformation( - pid); - if (null == process) { - Logger.error("ProfileData of type: " + id + " is from wrong process: " + pid - + "\n"); - return false; - } - - // TODO: handling negative time value in LogData.makeData - if (time > 0) { - LibraryObject obj = null; - ProcessMemoryMap pmap = process.getProcessMemoryMap(time); - if (pmap == null || (obj = pmap.getLibraryByAddress(pcAddr)) == null) { - Logger.warning("cannot find library for the pid and address : " + pid + ", " + pcAddr); - binaryId = -1; - } else { - binaryId = obj.getBinaryID(); - } - } + binaryId = Global.getBinaryID(pid, time, pcAddr); } + return true; } @@ -306,7 +289,7 @@ public class ProfileData extends LogData { public void setEntrySeq(long seq) { this.entrySeq = seq; } - + public int getBuildType() { return buildType; } @@ -316,10 +299,7 @@ public class ProfileData extends LogData { } public boolean isPieBuild() { - if (buildType == 1) { - return true; - } - return false; + return (buildType == 1); } public int getBinaryId() { @@ -329,13 +309,4 @@ public class ProfileData extends LogData { public void setBinaryPath(int binaryId) { this.binaryId = binaryId; } - - public String getLibName() { - return libName; - } - - public void setLibName(String libName) { - this.libName = libName; - } - } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ReplayData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ReplayData.java index 18bab5d..1dccd77 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ReplayData.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ReplayData.java @@ -34,71 +34,62 @@ import java.util.List; import org.tizen.dynamicanalyzer.swap.model.DATime; import org.tizen.dynamicanalyzer.swap.model.RecordEventObject; import org.tizen.dynamicanalyzer.util.ByteUtil; -import org.tizen.dynamicanalyzer.util.Logger; public class ReplayData extends LogData { private int objectCount = 0; private List recordEvent = new ArrayList(); - public ReplayData() { } - public boolean makeData(byte[] data) { - super.makeData(data); + @Override + public ReplayData clone() throws CloneNotSupportedException { + throw new CloneNotSupportedException(); + } + + @Override + protected boolean makeData(DATime startTime) { + super.makeData(startTime); - int internalIndex = INT_SIZE * 2; - - int sec = ByteUtil.toInt(data, internalIndex); - internalIndex += INT_SIZE; - int nano = ByteUtil.toInt(data, internalIndex); - internalIndex += INT_SIZE; DATime eventTime = new DATime(); eventTime.setSec(sec); eventTime.setNano(nano); - int count = ByteUtil.toInt(data, index); + int count = ByteUtil.toInt(payload, index); index += INT_SIZE; - setObjectCount(count); + objectCount = count; for (int i = 0; i < count; i++) { RecordEventObject recordObj = new RecordEventObject(); - - recordObj.setId(id); - recordObj.setSeq(seq); + recordObj.setMsgID(msgID); +// recordObj.setSeq(seq); recordObj.setTime(time); // event time recordObj.setEventTime(eventTime); // event id - int value = ByteUtil.toInt(data, index); + int value = ByteUtil.toInt(payload, index); recordObj.setEventId(value); index += INT_SIZE; // event type - value = ByteUtil.toInt(data, index); + value = ByteUtil.toInt(payload, index); recordObj.setEventType(value); index += INT_SIZE; // eventy code - value = ByteUtil.toInt(data, index); + value = ByteUtil.toInt(payload, index); recordObj.setEventCode(value); index += INT_SIZE; - value = ByteUtil.toInt(data, index); + value = ByteUtil.toInt(payload, index); recordObj.setEventValue(value); index += INT_SIZE; - Logger.debug( - "Sec : " + recordObj.getEventTime().getSec()+ - " Nano : " + recordObj.getEventTime().getNano() + - " ID : "+ recordObj.getEventId() + - " TYPE : "+ recordObj.getEventType() + - " CODE : "+ recordObj.getEventCode() + - " VALUE : "+ recordObj.getEventValue()); - getRecordEvent().add(recordObj); + + recordEvent.add(recordObj); } return true; @@ -120,5 +111,4 @@ public class ReplayData extends LogData { public int getPid() { return 0; } - } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/SceneData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/SceneData.java index 2214e35..dd0ca49 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/SceneData.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/SceneData.java @@ -29,51 +29,63 @@ package org.tizen.dynamicanalyzer.swap.model.data; import static org.tizen.dynamicanalyzer.constant.CommonConstants.INT_SIZE; import static org.tizen.dynamicanalyzer.constant.CommonConstants.LONG_SIZE; +import org.tizen.dynamicanalyzer.swap.model.DATime; import org.tizen.dynamicanalyzer.util.ByteUtil; public class SceneData extends ProbeCommonData { - String sceneName = null; - String formName = null; - long formPointer = 0; - String panelName = null; - long panelPointer = 0; - int transitionTime = 0; - int userTransitionTime = 0; - - public SceneData(){} - - public boolean makeData(byte[] data) { - super.makeData(data); - - int length = LogDataUtils.getStringLength(index, data); - byte[] temp = new byte[length]; - System.arraycopy(data, index, temp, 0, length); - sceneName = new String(temp); + protected String sceneName = null; + protected String formName = null; + protected long formPointer = 0; + protected String panelName = null; + protected long panelPointer = 0; + protected int transitionTime = 0; + protected int userTransitionTime = 0; + + public SceneData() { + } + + @Override + public SceneData clone() throws CloneNotSupportedException { + SceneData log = (SceneData) super.clone(); + log.sceneName = this.sceneName; + log.formName = this.formName; + log.formPointer = this.formPointer; + log.panelName = this.panelName; + log.panelPointer = this.panelPointer; + log.transitionTime = this.transitionTime; + log.userTransitionTime = this.userTransitionTime; + + return log; + } + + @Override + protected boolean makeData(DATime startTime) { + super.makeData(startTime); + + int length = LogDataUtils.getStringLength(index, payload); + sceneName = new String(payload, index, length); index += length; - length = LogDataUtils.getStringLength(index, data); - temp = new byte[length]; - System.arraycopy(data, index, temp, 0, length); - formName = new String(temp); + length = LogDataUtils.getStringLength(index, payload); + formName = new String(payload, index, length); index += length; - formPointer = ByteUtil.toLong(data, index); + formPointer = ByteUtil.toLong(payload, index); index += LONG_SIZE; - length = LogDataUtils.getStringLength(index, data); - temp = new byte[length]; - System.arraycopy(data, index, temp, 0, length); - panelName = new String(temp); + length = LogDataUtils.getStringLength(index, payload); + panelName = new String(payload, index, length); index += length; - panelPointer = ByteUtil.toLong(data, index); + panelPointer = ByteUtil.toLong(payload, index); index += LONG_SIZE; - transitionTime = ByteUtil.toInt(data, index); + transitionTime = ByteUtil.toInt(payload, index); + index += INT_SIZE; + + userTransitionTime = ByteUtil.toInt(payload, index); index += INT_SIZE; - userTransitionTime = ByteUtil.toInt(data, index); - return true; } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ScreenShotData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ScreenShotData.java index 716182b..3bbdcce 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ScreenShotData.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ScreenShotData.java @@ -26,21 +26,38 @@ */ package org.tizen.dynamicanalyzer.swap.model.data; +import static org.tizen.dynamicanalyzer.constant.CommonConstants.INT_SIZE; + +import org.tizen.dynamicanalyzer.swap.model.DATime; import org.tizen.dynamicanalyzer.util.ByteUtil; public class ScreenShotData extends ProbeCommonData { - String imageFilePath = null; - int orientation = 0; + protected String imageFilePath = null; + protected int orientation = 0; + + public ScreenShotData() { + } + + @Override + public ScreenShotData clone() throws CloneNotSupportedException { + ScreenShotData log = (ScreenShotData) super.clone(); + log.imageFilePath = this.imageFilePath; + log.orientation = this.orientation; + + return log; + } + + @Override + protected boolean makeData(DATime startTime) { + super.makeData(startTime); - public ScreenShotData(){} - public boolean makeData(byte[] data) { - super.makeData(data); + int length = LogDataUtils.getStringLength(index, payload); + imageFilePath = new String(payload, index, length); + index += length; - imageFilePath = ByteUtil.getString(data, index); - index += ByteUtil.getStringLength(data, index); + orientation = ByteUtil.toInt(payload, index); + index += INT_SIZE; - orientation = ByteUtil.toInt(data, index); - return true; } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/SyncData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/SyncData.java index b5b06fd..6a9052a 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/SyncData.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/SyncData.java @@ -29,26 +29,41 @@ package org.tizen.dynamicanalyzer.swap.model.data; import static org.tizen.dynamicanalyzer.constant.CommonConstants.INT_SIZE; import static org.tizen.dynamicanalyzer.constant.CommonConstants.LONG_SIZE; +import org.tizen.dynamicanalyzer.swap.model.DATime; import org.tizen.dynamicanalyzer.util.ByteUtil; public class SyncData extends ProbeCommonData { - long syncValue = 0; - int syncType = 0; - int apiType = 0; + protected long syncValue = 0; + protected int syncType = 0; + protected int apiType = 0; - public SyncData(){} - - public boolean makeData(byte[] data) { - super.makeData(data); + public SyncData() { - syncValue = ByteUtil.toLong(data, index); + } + + @Override + public SyncData clone() throws CloneNotSupportedException { + SyncData log = (SyncData) super.clone(); + log.syncValue = this.syncValue; + log.syncType = this.syncType; + log.apiType = this.apiType; + + return log; + } + + @Override + protected boolean makeData(DATime startTime) { + super.makeData(startTime); + + syncValue = ByteUtil.toLong(payload, index); index += LONG_SIZE; - syncType = ByteUtil.toInt(data, index); + syncType = ByteUtil.toInt(payload, index); + index += INT_SIZE; + + apiType = ByteUtil.toInt(payload, index); index += INT_SIZE; - apiType = ByteUtil.toInt(data, index); - return true; } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/SystemData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/SystemData.java index bfc3cb9..c4aeacc 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/SystemData.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/SystemData.java @@ -32,12 +32,13 @@ import static org.tizen.dynamicanalyzer.constant.CommonConstants.LONG_SIZE; import org.tizen.dynamicanalyzer.common.Global; import org.tizen.dynamicanalyzer.constant.CommonConstants; +import org.tizen.dynamicanalyzer.swap.model.DATime; import org.tizen.dynamicanalyzer.util.ByteUtil; import org.tizen.dynamicanalyzer.util.UnsignedInt; public class SystemData extends LogData { - public static enum DEVICE_STATUS { // order is important. Do not change randomly. - WIFI, + public static enum DEVICE_STATUS { // order is important. Do not change randomly. + WIFI, BLUETOOTH, GPS, BRIGHTNESS, @@ -51,7 +52,7 @@ public class SystemData extends LogData { VIDEO, CALL } - + String cpuFrequency = null; String cpuLoad = null; long systemMemoryUsed = 0; @@ -83,125 +84,117 @@ public class SystemData extends LogData { String deviceEnergyUsage = null; String applicationEnergyUsage = null; - // int callAlpha = 0; - // int rssiAlpha = 0; - public SystemData() { } - public boolean makeData(byte[] data) { - super.makeData(data); - // index = MessageParser.MSG_HEADER_SIZE; - int coreCount = Global.getProject().getDeviceStatusInfo() - .getCpuCount(); - int deviceCount = Global.getProject().getDeviceStatusInfo() - .getDeviceCount(); + @Override + public SystemData clone() throws CloneNotSupportedException { + throw new CloneNotSupportedException(); + } + + @Override + protected boolean makeData(DATime startTime) { + super.makeData(startTime); - cpuFrequency = parseCpu(index, data); - index += (FLOAT_SIZE * coreCount); + cpuFrequency = parseCpu(payload); - cpuLoad = parseCpu(index, data); - index += (FLOAT_SIZE * coreCount); + cpuLoad = parseCpu(payload); - systemMemoryUsed = ByteUtil.toLong(data, index); + systemMemoryUsed = ByteUtil.toLong(payload, index); index += LONG_SIZE; - targetProcessCount = ByteUtil.toInt(data, index); + targetProcessCount = ByteUtil.toInt(payload, index); index += INT_SIZE; - parseTargetProcessInfo(data, targetProcessCount); + parseTargetProcessInfo(payload, targetProcessCount); - otherProcessCount = ByteUtil.toInt(data, index); + otherProcessCount = ByteUtil.toInt(payload, index); index += INT_SIZE; - otherProcessLoad = parseLoad(index, data); - index += (otherProcessCount * (INT_SIZE + FLOAT_SIZE)); + otherProcessLoad = parseLoad(otherProcessCount, payload); - totalUsedDrive = ByteUtil.toUnsignedInt(data, index); + totalUsedDrive = ByteUtil.toUnsignedInt(payload, index); index += INT_SIZE; - diskReadOpCount = ByteUtil.toUnsignedInt(data, index); + diskReadOpCount = ByteUtil.toUnsignedInt(payload, index); index += INT_SIZE; - diskReadByteSize = ByteUtil.toUnsignedInt(data, index); + diskReadByteSize = ByteUtil.toUnsignedInt(payload, index); index += INT_SIZE; - diskWriteOpCount = ByteUtil.toUnsignedInt(data, index); + diskWriteOpCount = ByteUtil.toUnsignedInt(payload, index); index += INT_SIZE; - diskWrittenByteSize = ByteUtil.toUnsignedInt(data, index); + diskWrittenByteSize = ByteUtil.toUnsignedInt(payload, index); index += INT_SIZE; - networkSendSize = ByteUtil.toUnsignedInt(data, index); + networkSendSize = ByteUtil.toUnsignedInt(payload, index); index += INT_SIZE; - networkReceiveSize = ByteUtil.toUnsignedInt(data, index); + networkReceiveSize = ByteUtil.toUnsignedInt(payload, index); index += INT_SIZE; - wifi = ByteUtil.toInt(data, index); + wifi = ByteUtil.toInt(payload, index); index += INT_SIZE; - btStatus = ByteUtil.toInt(data, index); + btStatus = ByteUtil.toInt(payload, index); index += INT_SIZE; - gpsStatus = ByteUtil.toInt(data, index); + gpsStatus = ByteUtil.toInt(payload, index); index += INT_SIZE; - brightness = ByteUtil.toInt(data, index); + brightness = ByteUtil.toInt(payload, index); index += INT_SIZE; - camera = ByteUtil.toInt(data, index); + camera = ByteUtil.toInt(payload, index); index += INT_SIZE; - sound = ByteUtil.toInt(data, index); + sound = ByteUtil.toInt(payload, index); index += INT_SIZE; - audio = ByteUtil.toInt(data, index); + audio = ByteUtil.toInt(payload, index); index += INT_SIZE; - vibration = ByteUtil.toInt(data, index); + vibration = ByteUtil.toInt(payload, index); index += INT_SIZE; - voltage = ByteUtil.toInt(data, index); + voltage = ByteUtil.toInt(payload, index); index += INT_SIZE; - rssi = ByteUtil.toInt(data, index); + rssi = ByteUtil.toInt(payload, index); index += INT_SIZE; - video = ByteUtil.toInt(data, index); + video = ByteUtil.toInt(payload, index); index += INT_SIZE; - call = ByteUtil.toInt(data, index); + call = ByteUtil.toInt(payload, index); index += INT_SIZE; - dnet = ByteUtil.toInt(data, index); + dnet = ByteUtil.toInt(payload, index); index += INT_SIZE; - energyUsage = ByteUtil.toUnsignedInt(data, index); + energyUsage = ByteUtil.toUnsignedInt(payload, index); index += INT_SIZE; - deviceEnergyUsage = parseUsage(index, data); - index += (INT_SIZE * deviceCount); + deviceEnergyUsage = parseUsage(payload); + + applicationEnergyUsage = parseUsage(payload); - applicationEnergyUsage = parseUsage(index, data); - index += (INT_SIZE * deviceCount); - return true; } - private static String parseLoad(int start, byte[] payload) { - int pos = start; - int backPos = start - INT_SIZE; - int count = ByteUtil.toInt(payload, backPos); + private String parseLoad(int count, byte[] payload) { StringBuffer outBuf = new StringBuffer(); for (int ii = 0; ii < count; ii++) { try { - int tid = ByteUtil.toInt(payload, pos); - pos += INT_SIZE; + int tid = ByteUtil.toInt(payload, index); + index += INT_SIZE; outBuf.append(tid).append(CommonConstants.COMMA); - float f = ByteUtil.toFloat(payload, pos); + + float f = ByteUtil.toFloat(payload, index); + index += FLOAT_SIZE; outBuf.append(f); - pos += FLOAT_SIZE; + if (ii + 1 != count) { outBuf.append(CommonConstants.COMMA); } @@ -214,13 +207,12 @@ public class SystemData extends LogData { return outBuf.toString(); } - private static String parseCpu(int start, byte[] payload) { - int coreCount = Global.getProject().getDeviceStatusInfo() - .getCpuCount(); + private String parseCpu(byte[] payload) { + int coreCount = Global.getProject().getDeviceStatusInfo().getCpuCount(); StringBuffer buffer = new StringBuffer(); for (int i = 0; i < coreCount; i++) { - float value = ByteUtil.toFloat(payload, start); - start += FLOAT_SIZE; + float value = ByteUtil.toFloat(payload, index); + index += FLOAT_SIZE; buffer.append(value); if (i + 1 != coreCount) { buffer.append(','); @@ -229,13 +221,12 @@ public class SystemData extends LogData { return buffer.toString(); } - private static String parseUsage(int start, byte[] payload) { - int count = Global.getProject().getDeviceStatusInfo() - .getDeviceCount(); + private String parseUsage(byte[] payload) { + int count = Global.getProject().getDeviceStatusInfo().getDeviceCount(); StringBuffer buffer = new StringBuffer(); for (int i = 0; i < count; i++) { - UnsignedInt value = ByteUtil.toUnsignedInt(payload, start); - start += INT_SIZE; + UnsignedInt value = ByteUtil.toUnsignedInt(payload, index); + index += INT_SIZE; buffer.append(value.getValue()); if (i + 1 != count) { buffer.append(','); @@ -264,8 +255,7 @@ public class SystemData extends LogData { index += LONG_SIZE; processData.setThreadCount(ByteUtil.toInt(payload, index)); index += INT_SIZE; - processData.setThreadLoad(parseLoad(index, payload)); - index += (processData.getThreadCount() * (INT_SIZE + FLOAT_SIZE)); + processData.setThreadLoad(parseLoad(processData.getThreadCount(), payload)); processProfileDataList[i] = processData; } } @@ -498,8 +488,7 @@ public class SystemData extends LogData { return processProfileDataList; } - public void setProcessProfileDataList( - ProcessProfileData[] processProfileDataList) { + public void setProcessProfileDataList(ProcessProfileData[] processProfileDataList) { this.processProfileDataList = processProfileDataList; } @@ -518,7 +507,7 @@ public class SystemData extends LogData { public void setOtherProcessLoad(String otherProcessLoad) { this.otherProcessLoad = otherProcessLoad; } - + @Override public int getPid() { return 0; diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ThreadData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ThreadData.java index 1979cea..a051880 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ThreadData.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ThreadData.java @@ -29,34 +29,52 @@ package org.tizen.dynamicanalyzer.swap.model.data; import static org.tizen.dynamicanalyzer.constant.CommonConstants.INT_SIZE; import static org.tizen.dynamicanalyzer.constant.CommonConstants.LONG_SIZE; +import org.tizen.dynamicanalyzer.swap.model.DATime; import org.tizen.dynamicanalyzer.util.ByteUtil; public class ThreadData extends ProbeCommonData { - long pThreadId = 0; - long ospThreadId = 0; - int threadType = 0; // TODO: short - int apiType = 0;// TODO: short - String className = null; - - public ThreadData(){} - - public boolean makeData(byte[] data) { - super.makeData(data); - - pThreadId = ByteUtil.toLong(data, index); + protected long pThreadId = 0; + protected long ospThreadId = 0; + protected int threadType = 0; // TODO: short + protected int apiType = 0;// TODO: short + protected String className = null; + + public ThreadData() { + + } + + @Override + public ThreadData clone() throws CloneNotSupportedException { + ThreadData log = (ThreadData) super.clone(); + log.pThreadId = this.pThreadId; + log.ospThreadId = this.ospThreadId; + log.threadType = this.threadType; + log.apiType = this.apiType; + log.className = this.className; + + return log; + } + + @Override + protected boolean makeData(DATime startTime) { + super.makeData(startTime); + + pThreadId = ByteUtil.toLong(payload, index); index += LONG_SIZE; - ospThreadId = ByteUtil.toLong(data, index); + ospThreadId = ByteUtil.toLong(payload, index); index += LONG_SIZE; - threadType = ByteUtil.toInt(data, index); + threadType = ByteUtil.toInt(payload, index); index += INT_SIZE; - apiType = ByteUtil.toInt(data, index); + apiType = ByteUtil.toInt(payload, index); index += INT_SIZE; - - className = ByteUtil.getString(data, index); - + + int length = LogDataUtils.getStringLength(index, payload); + className = new String(payload, index, length); + index += length; + return true; } @@ -95,7 +113,7 @@ public class ThreadData extends ProbeCommonData { public String getClassName() { return className; } - + public void setClassName(String className) { this.className = className; } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/UIEventData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/UIEventData.java index 9d1f394..e5e24b5 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/UIEventData.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/UIEventData.java @@ -28,39 +28,58 @@ package org.tizen.dynamicanalyzer.swap.model.data; import static org.tizen.dynamicanalyzer.constant.CommonConstants.INT_SIZE; +import org.tizen.dynamicanalyzer.swap.model.DATime; import org.tizen.dynamicanalyzer.util.ByteUtil; public class UIEventData extends ProbeCommonData { - int eventType = 0; - int detailType = 0; - int x = 0; - int y = 0; - String info1 = null; - int info2 = 0; + protected int eventType = 0; + protected int detailType = 0; + protected int x = 0; + protected int y = 0; + protected String info1 = null; + protected int info2 = 0; - public UIEventData(){} - - public boolean makeData(byte[] data) { - super.makeData(data); + public UIEventData() { - eventType = ByteUtil.toInt(data, index); + } + + @Override + public UIEventData clone() throws CloneNotSupportedException { + UIEventData log = (UIEventData) super.clone(); + log.eventType = this.eventType; + log.detailType = this.detailType; + log.x = this.x; + log.y = this.y; + log.info1 = this.info1; + log.info2 = this.info2; + + return log; + } + + @Override + protected boolean makeData(DATime startTime) { + super.makeData(startTime); + + eventType = ByteUtil.toInt(payload, index); index += INT_SIZE; - detailType = ByteUtil.toInt(data, index); + detailType = ByteUtil.toInt(payload, index); index += INT_SIZE; - x = ByteUtil.toInt(data, index); + x = ByteUtil.toInt(payload, index); index += INT_SIZE; - y = ByteUtil.toInt(data, index); + y = ByteUtil.toInt(payload, index); index += INT_SIZE; - info1 = ByteUtil.getString(data, index); - index += ByteUtil.getStringLength(data, index); + int length = LogDataUtils.getStringLength(index, payload); + info1 = new String(payload, index, length); + index += length; + + info2 = ByteUtil.toInt(payload, index); + index += INT_SIZE; - info2 = ByteUtil.toInt(data, index); - return true; } @@ -111,11 +130,4 @@ public class UIEventData extends ProbeCommonData { public void setInfo2(int info2) { this.info2 = info2; } - - private int logNum = 0; - - @Override - public int getLogNum() { - return logNum++; - } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/WindowingTableData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/WindowingTableData.java deleted file mode 100644 index c5bb48d..0000000 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/WindowingTableData.java +++ /dev/null @@ -1,37 +0,0 @@ -/* - * Dynamic Analyzer - * - * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved. - * - * Contact: - * Jungwook Ryu - * 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.model.data; - -public class WindowingTableData extends LogData { - public WindowingTableData() { - } - @Override - public int getPid() { - return 0; - } - -} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/FileChartView.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/FileChartView.java index b9d196f..b6f3f23 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/FileChartView.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/FileChartView.java @@ -28,6 +28,7 @@ package org.tizen.dynamicanalyzer.ui.file; import java.sql.ResultSet; import java.sql.SQLException; + import org.eclipse.swt.custom.StackLayout; import org.eclipse.swt.layout.FillLayout; import org.eclipse.swt.widgets.Composite; diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/FileDetailInfoView.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/FileDetailInfoView.java index d5543da..8025a9e 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/FileDetailInfoView.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/FileDetailInfoView.java @@ -30,10 +30,6 @@ import java.sql.ResultSet; import java.sql.SQLException; import org.eclipse.swt.SWT; -import org.eclipse.swt.events.PaintEvent; -import org.eclipse.swt.events.PaintListener; -import org.eclipse.swt.graphics.Point; -import org.eclipse.swt.graphics.Rectangle; import org.eclipse.swt.layout.FillLayout; import org.eclipse.swt.layout.FormAttachment; import org.eclipse.swt.layout.FormData; diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/manager/FileDataMaker.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/manager/FileDataMaker.java index b71dc4b..bcdc736 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/manager/FileDataMaker.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/manager/FileDataMaker.java @@ -202,7 +202,7 @@ public class FileDataMaker { long time = profileData.getTime(); int eventType = profileData.getProbeSubType(); - switch (profileData.getId()) { + switch (profileData.getMsgID()) { case DataChannelConstants.MSG_FUNCTION_ENTRY: // get file path and FD from args : string of "file_path,fd" String args = profileData.getArgs(); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/manager/FileDataManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/manager/FileDataManager.java index 6d449d5..7a27382 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/manager/FileDataManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/manager/FileDataManager.java @@ -29,7 +29,6 @@ package org.tizen.dynamicanalyzer.ui.file.manager; import java.util.List; import java.util.Map; -import org.tizen.dynamicanalyzer.database.DBInsertManager; import org.tizen.dynamicanalyzer.database.DBInserter; import org.tizen.dynamicanalyzer.swap.logparser.LogPackage; import org.tizen.dynamicanalyzer.swap.logparser.PageDataManager; @@ -76,10 +75,10 @@ public class FileDataManager extends PageDataManager { statusDB = new FileStatusDB(); accessorDB = new FileAccessorDB(); - apiDBInserter = DBInsertManager.makeInserter(apiDB); - accessDBInserter = DBInsertManager.makeInserter(accessDB); - accessorDBInserter = DBInsertManager.makeInserter(accessorDB); - satatusDBInserter = DBInsertManager.makeInserter(statusDB); + apiDBInserter = makeInserter(apiDB); + accessDBInserter = makeInserter(accessDB); + accessorDBInserter = makeInserter(accessorDB); + satatusDBInserter = makeInserter(statusDB); } public void clear() { diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/model/FileEvent.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/model/FileEvent.java index 9ab496e..5cd5895 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/model/FileEvent.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/file/model/FileEvent.java @@ -153,10 +153,6 @@ public class FileEvent extends FileData{ return tid; } - public void setSeq(long seqNo) { - this.seq = seqNo; - } - public long getFileSize() { return fileSize; } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/screenshot/ScreenshotDataManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/screenshot/ScreenshotDataManager.java index ddc6006..16a96d6 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/screenshot/ScreenshotDataManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/screenshot/ScreenshotDataManager.java @@ -37,7 +37,6 @@ import org.tizen.dynamicanalyzer.common.Global; import org.tizen.dynamicanalyzer.communicator.DACommunicator; import org.tizen.dynamicanalyzer.constant.CommonConstants; import org.tizen.dynamicanalyzer.database.DBColumn; -import org.tizen.dynamicanalyzer.database.DBInsertManager; import org.tizen.dynamicanalyzer.database.DBInserter; import org.tizen.dynamicanalyzer.database.DBTable; import org.tizen.dynamicanalyzer.database.SqlConnectionManager; @@ -67,7 +66,7 @@ public class ScreenshotDataManager extends PageDataManager { private ScreenshotDataManager() { lastCpuRate = new ArrayList(); screenShotDBTable = new ScreenShotDBTable(); - screenShotDBInserter = DBInsertManager.makeInserter(screenShotDBTable); + screenShotDBInserter = makeInserter(screenShotDBTable); } public synchronized static ScreenshotDataManager getInstance() { diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/screenshot/ScreenshotTimer.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/screenshot/ScreenshotTimer.java new file mode 100644 index 0000000..7a66a49 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/screenshot/ScreenshotTimer.java @@ -0,0 +1,56 @@ +/* + * Dynamic Analyzer + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * Jungwook Ryu + * 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.screenshot; + +import java.util.Timer; +import java.util.TimerTask; + +import org.tizen.dynamicanalyzer.common.AnalyzerConstants; +import org.tizen.dynamicanalyzer.communicator.DACommunicator; + +public class ScreenshotTimer extends TimerTask { + private static Timer screenshotTimer = null; + + public static synchronized void start(int sec) { + stop(); + + screenshotTimer = new Timer(AnalyzerConstants.SCREENSHOT_TIMER); + screenshotTimer.scheduleAtFixedRate(new ScreenshotTimer(), 1000, sec * 1000); + } + + public static synchronized void stop() { + if (null != screenshotTimer) { + screenshotTimer.cancel(); + screenshotTimer = null; + } + } + + @Override + public void run() { + DACommunicator.sendScreenShotMessage(); + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/screenshot/ScreenshotView.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/screenshot/ScreenshotView.java index 4b8fb73..d35ebda 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/screenshot/ScreenshotView.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/screenshot/ScreenshotView.java @@ -59,7 +59,6 @@ import org.tizen.dynamicanalyzer.swap.logparser.DataManagerRegistry; import org.tizen.dynamicanalyzer.swap.model.data.LogData; import org.tizen.dynamicanalyzer.ui.opengl.GLPage; import org.tizen.dynamicanalyzer.ui.page.ScreenshotTabComposite; -import org.tizen.dynamicanalyzer.ui.timeline.SystemDataDBTable; import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineChartManager; import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea; import org.tizen.dynamicanalyzer.ui.widgets.table.DATableComposite; diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataMaker.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataMaker.java index 4aa6064..fa02e2f 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataMaker.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataMaker.java @@ -93,7 +93,7 @@ public class KernelDataMaker { for (int i = 0; i < size; i++) { LogData input = (LogData) inputs.get(i); - switch (input.getId()) { + switch (input.getMsgID()) { case DataChannelConstants.MSG_CONTEXT_SWITCH_EXIT: { ContextSwitchData csdata = (ContextSwitchData) input; int tid = csdata.getTid(); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataManager.java index 5f66ab2..ea5b7d9 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataManager.java @@ -33,7 +33,6 @@ import java.util.List; import java.util.Map; import java.util.PriorityQueue; -import org.tizen.dynamicanalyzer.database.DBInsertManager; import org.tizen.dynamicanalyzer.database.DBInserter; import org.tizen.dynamicanalyzer.database.DBTable; import org.tizen.dynamicanalyzer.database.SqlConnectionManager; @@ -68,8 +67,8 @@ public class KernelDataManager extends PageDataManager { private KernelDataManager() { contextDataTable = new ContextDataDBTable(); functionDataTable = new FunctionDataDBTable(); - DBInserter cDBInserter = DBInsertManager.makeInserter(contextDataTable); - DBInserter fDBInserter = DBInsertManager.makeInserter(functionDataTable); + DBInserter cDBInserter = makeInserter(contextDataTable); + DBInserter fDBInserter = makeInserter(functionDataTable); kdataMaker = new KernelDataMaker(cDBInserter, fDBInserter); } @@ -138,7 +137,7 @@ public class KernelDataManager extends PageDataManager { if (top == null) break; - switch (top.getId()) { + switch (top.getMsgID()) { case DataChannelConstants.MSG_CONTEXT_SWITCH_ENTRY: if (centryiter != null && centryiter.hasNext()) pqueue.offer(centryiter.next()); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/opengl/data/GLDataManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/opengl/data/GLDataManager.java index 60bcef8..5abb548 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/opengl/data/GLDataManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/opengl/data/GLDataManager.java @@ -40,6 +40,7 @@ import org.tizen.dynamicanalyzer.swap.model.data.GLES20LogData; import org.tizen.dynamicanalyzer.swap.model.data.LogData; import org.tizen.dynamicanalyzer.ui.opengl.GLUtil; import org.tizen.dynamicanalyzer.ui.opengl.data.DB.GLAPIDBTableManager; +import org.tizen.dynamicanalyzer.ui.opengl.data.DB.GLBufferSizeDBTableManager; import org.tizen.dynamicanalyzer.ui.opengl.data.DB.GLCommonStateDBTableManager; import org.tizen.dynamicanalyzer.ui.opengl.data.DB.GLFrameRateDBTableManager; import org.tizen.dynamicanalyzer.ui.opengl.data.DB.GLFrameTimeDBTableManager; @@ -48,7 +49,6 @@ import org.tizen.dynamicanalyzer.ui.opengl.data.DB.GLStateHistoryDBTableManager; import org.tizen.dynamicanalyzer.ui.opengl.data.DB.GLStateProgramDBTableManager; import org.tizen.dynamicanalyzer.ui.opengl.data.DB.GLStateSharingDBTableManager; import org.tizen.dynamicanalyzer.ui.opengl.data.DB.GLStateTextureDBTableManager; -import org.tizen.dynamicanalyzer.ui.opengl.data.DB.GLBufferSizeDBTableManager; import org.tizen.dynamicanalyzer.ui.opengl.data.type.GLAPIData; import org.tizen.dynamicanalyzer.ui.opengl.data.type.GLCurrentFrameDataManger; import org.tizen.dynamicanalyzer.ui.opengl.data.type.GLES20ErrorDefine; diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/page/BaseView.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/page/BaseView.java index df55b1e..6c4993f 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/page/BaseView.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/page/BaseView.java @@ -35,6 +35,7 @@ import org.eclipse.swt.SWT; import org.eclipse.swt.widgets.Composite; import org.eclipse.swt.widgets.Display; import org.eclipse.ui.part.ViewPart; +import org.tizen.dynamicanalyzer.annotation.UIMethod; import org.tizen.dynamicanalyzer.common.AnalyzerConstants; import org.tizen.dynamicanalyzer.nl.ConfigureLabels; import org.tizen.dynamicanalyzer.resources.ColorResources; @@ -282,6 +283,7 @@ public class BaseView extends ViewPart { return topComposite; } + @UIMethod public void clear() { tabView.clear(); } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/page/UpdateViewTimer.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/page/UpdateViewTimer.java index 0daf36d..60f9188 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/page/UpdateViewTimer.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/page/UpdateViewTimer.java @@ -58,18 +58,15 @@ public class UpdateViewTimer { stop(); timer = new Timer(AnalyzerConstants.UPDATE_VIEW_TIMER); - timer.schedule(new UpdateTimerTask(), - AnalyzerConstants.TIMER_START_TIME_DEFAULT, + timer.schedule(new UpdateTimerTask(), AnalyzerConstants.TIMER_START_TIME_DEFAULT, AnalyzerConstants.TIMER_INTERVAL_DEFAULT); } - public static void stop() { + public static synchronized void stop() { if (null != timer) { - synchronized (timer) { - timer.cancel(); - timer = null; - Logger.debug("update timer stop"); //$NON-NLS-1$ - } + timer.cancel(); + timer = null; + Logger.debug("update timer stop"); //$NON-NLS-1$ } } } \ No newline at end of file diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/range/RangeDataManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/range/RangeDataManager.java index 454f0bf..9598a9d 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/range/RangeDataManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/range/RangeDataManager.java @@ -321,7 +321,7 @@ public class RangeDataManager implements Runnable { } ProfileDataMaker profileDataMaker = getProfileDataMakerByPid(top.getPid()); - switch (top.getId()) { + switch (top.getMsgID()) { case DataChannelConstants.MSG_FUNCTION_ENTRY: if (rsEntry.next()) { ProfileData pEntry = makeFunctionProfileData( diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/SummaryDataManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/SummaryDataManager.java index daff1c1..b295759 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/SummaryDataManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/SummaryDataManager.java @@ -30,7 +30,6 @@ import java.util.List; import java.util.Map; import org.tizen.dynamicanalyzer.common.AnalyzerManager; -import org.tizen.dynamicanalyzer.database.DBInsertManager; import org.tizen.dynamicanalyzer.database.DBTable; import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants; import org.tizen.dynamicanalyzer.swap.logparser.LogPackage; @@ -67,10 +66,10 @@ public class SummaryDataManager extends PageDataManager { failedApiDataTable = new FailedApiDataDBTable(); warningDataDBTable = new WarningDataDBTable(); - leakDataMaker = new LeakDataMaker(DBInsertManager.makeInserter(memoryAllocationDataTable), - DBInsertManager.makeInserter(freeDataTable)); + leakDataMaker = new LeakDataMaker(makeInserter(memoryAllocationDataTable), + makeInserter(freeDataTable)); failedApiDataMaker = new FailedApiDataMaker( - DBInsertManager.makeInserter(failedApiDataTable)); + makeInserter(failedApiDataTable)); warningDataMaker = new WarningDataMaker(warningDataDBTable); } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedApiDataMaker.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedApiDataMaker.java index 1f6b6a4..3d7825e 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedApiDataMaker.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedApiDataMaker.java @@ -68,7 +68,7 @@ public class FailedApiDataMaker { dbFailedData.add(Long.valueOf(pData.getErrno())); dbFailedData.add(Long.valueOf(pData.getCallerPcAddr())); dbFailedData.add(String.valueOf(pData.getLibName())); - dbFailedData.add(Integer.valueOf(pData.getId())); + dbFailedData.add(Integer.valueOf(pData.getMsgID())); failedApiDataList.add(dbFailedData); } @@ -98,7 +98,7 @@ public class FailedApiDataMaker { dbFailedData.add(Long.valueOf(pData.getErrno())); dbFailedData.add(Long.valueOf(pData.getCallerPcAddr())); dbFailedData.add(String.valueOf(pData.getLibName())); - dbFailedData.add(Integer.valueOf(pData.getId())); + dbFailedData.add(Integer.valueOf(pData.getMsgID())); failedApiDataList.add(dbFailedData); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedApiTable.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedApiTable.java index 47369e3..fe3b7fe 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedApiTable.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedApiTable.java @@ -283,7 +283,7 @@ public class FailedApiTable extends DATableComposite { probeData.setErrNo(errNum); probeData.setCallerAddress(callerPcAddr); probeData.setLibName(libName); - probeData.setId((Integer) idata.get(FailedApiDataDBTable.COLUMN_INDEX_MESSAGE_ID)); + probeData.setMsgID((Integer) idata.get(FailedApiDataDBTable.COLUMN_INDEX_MESSAGE_ID)); tableData.setLogData(probeData); // tableData.setLogData(failedData.getData()); tableData.getData().addAll(data); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedData.java index 76d598f..33ceafd 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedData.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/failed/FailedData.java @@ -59,7 +59,7 @@ public class FailedData { private String libName = null; public FailedData(LogData log) { - id = log.getId(); + id = log.getMsgID(); seq = log.getSeq(); time = log.getTime(); ProbeCommonData plog = ((ProbeCommonData) log); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakData.java index eac358e..c330fc6 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakData.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakData.java @@ -71,7 +71,7 @@ public class LeakData { leakDetector.increaseLeakSeq(); this.key = log.getKey(); this.seq = log.getSeq(); - this.id = log.getId(); + this.id = log.getMsgID(); this.time = log.getTime(); // TODO : name field ProbeCommonData pcd = (ProbeCommonData) log; diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakDataMaker.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakDataMaker.java index c3c0bc3..7b99fda 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakDataMaker.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakDataMaker.java @@ -132,7 +132,7 @@ public class LeakDataMaker { public void makeAllocData(LogData log) { ArrayList dbAllocData = new ArrayList(); - switch (log.getId()) { + switch (log.getMsgID()) { case DataChannelConstants.MSG_PROBE_MEMORY: { MemoryData mData = (MemoryData) log; @@ -146,7 +146,7 @@ public class LeakDataMaker { dbAllocData.add(String.valueOf(mData.getArgs())); dbAllocData.add(String.valueOf(mData.getReturn())); dbAllocData.add(String.valueOf(mData.getLibName())); - dbAllocData.add(Integer.valueOf(mData.getId())); + dbAllocData.add(Integer.valueOf(mData.getMsgID())); dbAllocData.add(Integer.valueOf(mData.getTid())); dbAllocData.add(Long.valueOf(mData.getSize())); break; @@ -161,13 +161,13 @@ public class LeakDataMaker { public void makeFreeData(LogData log) { ArrayList dbFreeData = new ArrayList(); - switch (log.getId()) { + switch (log.getMsgID()) { case DataChannelConstants.MSG_PROBE_MEMORY: { MemoryData mData = (MemoryData) log; dbFreeData.add(Long.valueOf(mData.getSeq())); dbFreeData.add(Integer.valueOf(mData.getPid())); - dbFreeData.add(Integer.valueOf(mData.getId())); + dbFreeData.add(Integer.valueOf(mData.getMsgID())); dbFreeData.add(Long.valueOf(mData.getTime())); dbFreeData.add(Long.valueOf(mData.getAddress())); break; diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakDetector.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakDetector.java index 4bf9b29..49b785e 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakDetector.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakDetector.java @@ -90,7 +90,7 @@ public class LeakDetector { private boolean isDropLog(LogData logData) { TargetData target = SettingDataManager.getInstance().getConnectedTarget(); - int id = logData.getId(); + int id = logData.getMsgID(); switch (id) { case DataChannelConstants.MSG_PROBE_FILE: if (target.isSelectedFeature(SettingConstants.FEATURE_NAME_INDEX_INSIDE_THE_PLATFORM_FILE)) { diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakTable.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakTable.java index 0d79849..ae27a23 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakTable.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/leaks/LeakTable.java @@ -272,7 +272,7 @@ public class LeakTable extends DATreeComposite { ProbeCommonData probeData = new ProbeCommonData(); probeData.setSeq(seq); probeData.setApiName(apiName); - probeData.setId(id); + probeData.setMsgID(id); probeData.setPid(pid); probeData.setTime(time); probeData.setArgs(args); @@ -376,7 +376,7 @@ public class LeakTable extends DATreeComposite { ProbeCommonData probeData = new ProbeCommonData(); probeData.setSeq(seq); probeData.setApiName(apiName); - probeData.setId(id); + probeData.setMsgID(id); probeData.setPid(pid); probeData.setTime(time); probeData.setArgs(args); 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 3734512..419a387 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 @@ -615,7 +615,7 @@ public class ProfileDataMaker { public void makeFupDataForCallTrace(CallStackUnit inputCallstackApiData, ProfileData log) { long exeTime = 0; - int type = log.getId(); + int type = log.getMsgID(); int tid = log.getTid(); long time = log.getTime(); long startTime; diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningData.java index c47dae2..1822e38 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningData.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningData.java @@ -49,7 +49,7 @@ public class WarningData { public WarningData(int wCase, LogData data, String key) { seq = uNum++; - category = data.getId(); + category = data.getMsgID(); warningCase = wCase; this.key = key; callerPc = ((ProbeCommonData) data).getCallerPcAddr(); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningDataMaker.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningDataMaker.java index d494ef3..b93d02e 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningDataMaker.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningDataMaker.java @@ -99,7 +99,7 @@ public class WarningDataMaker { dbWarningData.add(Integer.valueOf(warningSeq++)); dbWarningData.add(Long.valueOf(pData.getSeq())); - dbWarningData.add(Integer.valueOf(pData.getId())); + dbWarningData.add(Integer.valueOf(pData.getMsgID())); dbWarningData.add(Integer.valueOf(pData.getPid())); dbWarningData.add(Integer.valueOf(pData.getTid())); dbWarningData.add(Long.valueOf(pData.getTime())); @@ -123,7 +123,7 @@ public class WarningDataMaker { dbWarningData.add(Integer.valueOf(warningSeq++)); dbWarningData.add(Long.valueOf(pData.getSeq())); - dbWarningData.add(Integer.valueOf(pData.getId())); + dbWarningData.add(Integer.valueOf(pData.getMsgID())); dbWarningData.add(Integer.valueOf(pData.getPid())); dbWarningData.add(Integer.valueOf(pData.getTid())); dbWarningData.add(Long.valueOf(pData.getTime())); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningTable.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningTable.java index 0e3822f..ca3b1ce 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningTable.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/summary/warning/WarningTable.java @@ -178,7 +178,7 @@ public class WarningTable extends DATableComposite { ProbeCommonData probeData = new ProbeCommonData(); probeData.setSeq(seq); - probeData.setId(msgID); + probeData.setMsgID(msgID); probeData.setPid(pid); probeData.setTid((Integer)idata.get(WarningDataDBTable.COLUMN_INDEX_THREAD_ID)); probeData.setTime((Long)idata.get(WarningDataDBTable.COLUMN_INDEX_START_TIME)); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/chart/ThreadChartView.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/chart/ThreadChartView.java index 11f9deb..ebf4506 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/chart/ThreadChartView.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/chart/ThreadChartView.java @@ -289,7 +289,7 @@ public class ThreadChartView extends DAViewComposite { private void selectionFromSummary(DASelectionData selData) { Object odata = selData.getData(); - String category = LogDataFactory.getLogFormatName(((ProbeCommonData) odata).getId()); + String category = LogDataFactory.getLogFormatName(((ProbeCommonData) odata).getMsgID()); if (null == category) { return; } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/data/ThreadDataManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/data/ThreadDataManager.java index 3c52e0b..d43aa77 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/data/ThreadDataManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/data/ThreadDataManager.java @@ -77,6 +77,12 @@ public class ThreadDataManager extends PageDataManager { syncEventTable = new SyncEventDBTable(); syncAPITable = new SyncAPIDBTable(); + makeInserter(threadEventTable); + makeInserter(threadAPITable); + makeInserter(syncDataTable); + makeInserter(syncEventTable); + makeInserter(syncAPITable); + loadManager = new ThreadLoadDataMaker(); tManager = new ThreadThreadDataMaker(); sManager = new ThreadSyncDataMaker(); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/db/SyncAPIDBTable.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/db/SyncAPIDBTable.java index 0e48c67..29d8e3e 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/db/SyncAPIDBTable.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/db/SyncAPIDBTable.java @@ -37,14 +37,11 @@ import org.tizen.dynamicanalyzer.common.DALimit; import org.tizen.dynamicanalyzer.constant.CommonConstants; import org.tizen.dynamicanalyzer.database.DBColumn; import org.tizen.dynamicanalyzer.database.DBConstants; -import org.tizen.dynamicanalyzer.database.DBInsertManager; -import org.tizen.dynamicanalyzer.database.DBInserter; import org.tizen.dynamicanalyzer.database.DBTable; import org.tizen.dynamicanalyzer.swap.model.data.SyncData; public class SyncAPIDBTable extends DBTable { public static final String TABLENAME = "SYNCAPI"; - private DBInserter dbInserter = null; private static final String SELECT_COLUMN = COLUMN.SEQ.name + CommonConstants.COMMA + COLUMN.APICALLTIME.name + CommonConstants.COMMA + COLUMN.APIID.name @@ -57,10 +54,15 @@ public class SyncAPIDBTable extends DBTable { + SyncEventDBTable.COLUMN.API_SEQNUMBER.name + " = " + COLUMN.SEQ.name; public enum COLUMN { - SEQ(0, "SEQNUMBER"), APICALLTIME(1, "APICallTime"), APIID(2, "APIID"), PID(3, "PID"), TID( - 4, "TID"), ARGUMENT(5, DBConstants.DBCOLUMN_ARGUMENT), RETURN(6, - DBConstants.DBCOLUMN_RETURN_VALUE), ERRORNO(7, DBConstants.DBCOLUMN_ERROR_NUMBER), SYNCVALUE( - 8, "SyncValue"); + SEQ(0, "SEQNUMBER"), + APICALLTIME(1, "APICallTime"), + APIID(2, "APIID"), + PID(3, "PID"), + TID(4, "TID"), + ARGUMENT(5, DBConstants.DBCOLUMN_ARGUMENT), + RETURN(6, DBConstants.DBCOLUMN_RETURN_VALUE), + ERRORNO(7, DBConstants.DBCOLUMN_ERROR_NUMBER), + SYNCVALUE(8, "SyncValue"); public final int index; public final String name; @@ -89,7 +91,6 @@ public class SyncAPIDBTable extends DBTable { DALimit.FUNCTION_RETURN_VALUE_LENGTH)); addColumn(new DBColumn(COLUMN.ERRORNO.name, DBConstants.EMPTY, DBConstants.DBTYPE_LONG)); addColumn(new DBColumn(COLUMN.SYNCVALUE.name, DBConstants.EMPTY, DBConstants.DBTYPE_LONG)); - dbInserter = DBInsertManager.makeInserter(this); } public void insertSyncAPIData(List insertSyncAPIList) { @@ -114,7 +115,7 @@ public class SyncAPIDBTable extends DBTable { } insertData.add(insertRowData); } - if (insertData.size() > 0) { + if (insertData.size() > 0 && dbInserter != null) { dbInserter.pushData(insertData); } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/db/SyncDataDBTable.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/db/SyncDataDBTable.java index bcba12f..fc8e784 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/db/SyncDataDBTable.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/db/SyncDataDBTable.java @@ -36,8 +36,6 @@ import java.util.List; import org.tizen.dynamicanalyzer.constant.CommonConstants; import org.tizen.dynamicanalyzer.database.DBColumn; import org.tizen.dynamicanalyzer.database.DBConstants; -import org.tizen.dynamicanalyzer.database.DBInsertManager; -import org.tizen.dynamicanalyzer.database.DBInserter; import org.tizen.dynamicanalyzer.database.DBTable; import org.tizen.dynamicanalyzer.nl.ThreadPageLabels; import org.tizen.dynamicanalyzer.ui.thread.data.ThreadSyncDataMaker; @@ -48,8 +46,6 @@ public class SyncDataDBTable extends DBTable { public static final String QUERY_OPTION = "order by " + COLUMN.SYNCDATAID.name; - private DBInserter dbInserter = null; - private static final String SELECT_COLUMN = COLUMN.SYNCDATAID.name + CommonConstants.COMMA + COLUMN.PID.name + CommonConstants.COMMA + COLUMN.TID.name + CommonConstants.COMMA + COLUMN.SYNCTYPE.name + CommonConstants.COMMA + COLUMN.SYNCVALUE.name @@ -59,9 +55,14 @@ public class SyncDataDBTable extends DBTable { + " order by " + COLUMN.SYNCDATAID.name; public enum COLUMN { - SYNCDATAID(0, "SyncDataID"), PID(1, "PID"), TID(2, "TID"), SYNCTYPE(3, "SyncType"), SYNCVALUE( - 4, "SyncValue"), ATTRIBUTETYPE(5, "AttributeType"), SYNCDATATYPE(6, "SyncDataType"), PARENTID( - 7, "ParentId"); + SYNCDATAID(0, "SyncDataID"), + PID(1, "PID"), + TID(2, "TID"), + SYNCTYPE(3, "SyncType"), + SYNCVALUE(4, "SyncValue"), + ATTRIBUTETYPE(5, "AttributeType"), + SYNCDATATYPE(6, "SyncDataType"), + PARENTID(7, "ParentId"); public final int index; public final String name; @@ -89,7 +90,6 @@ public class SyncDataDBTable extends DBTable { addColumn(new DBColumn(COLUMN.SYNCDATATYPE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT1)); addColumn(new DBColumn(COLUMN.PARENTID.name, DBConstants.EMPTY, DBConstants.DBTYPE_INT4)); - dbInserter = DBInsertManager.makeInserter(this); } public List> getSyncDataFromDB() { @@ -132,7 +132,7 @@ public class SyncDataDBTable extends DBTable { e.printStackTrace(); } } - if (insertData.size() > 0) { + if (insertData.size() > 0 && dbInserter != null) { dbInserter.pushData(insertData); } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/db/SyncEventDBTable.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/db/SyncEventDBTable.java index fe863f9..766e858 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/db/SyncEventDBTable.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/db/SyncEventDBTable.java @@ -38,15 +38,12 @@ import org.tizen.dynamicanalyzer.communicator.DACommunicator; import org.tizen.dynamicanalyzer.constant.CommonConstants; import org.tizen.dynamicanalyzer.database.DBColumn; import org.tizen.dynamicanalyzer.database.DBConstants; -import org.tizen.dynamicanalyzer.database.DBInsertManager; -import org.tizen.dynamicanalyzer.database.DBInserter; import org.tizen.dynamicanalyzer.database.DBTable; import org.tizen.dynamicanalyzer.logparser.LogCenterConstants; import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageSyncDataEvent; public class SyncEventDBTable extends DBTable { public static final String TABLENAME = "SYNCEVENT"; - private DBInserter dbInserter = null; private static final String SELECT_COLUMN = COLUMN.API_SEQNUMBER.name + CommonConstants.COMMA + COLUMN.SYNCDATAID.name + CommonConstants.COMMA + COLUMN.EVENTTIME.name @@ -55,26 +52,31 @@ public class SyncEventDBTable extends DBTable { + CommonConstants.COMMA + COLUMN.SYNCVALUE.name + CommonConstants.COMMA + COLUMN.BLOCKENDTIME.name; - public static final String SELECT_QUERY = "select " + SELECT_COLUMN + - " from " + TABLENAME + public static final String SELECT_QUERY = "select " + SELECT_COLUMN + " from " + TABLENAME + " where ((" + COLUMN.APITYPE.name + " = " + LogCenterConstants.SYNC_API_TYPE_NEW + " OR " + COLUMN.APITYPE.name + " = " + LogCenterConstants.SYNC_API_TYPE_NOTIFY + " OR " + COLUMN.APITYPE.name + " = " + LogCenterConstants.SYNC_API_TYPE_NOTIFY_ALL + " OR " + COLUMN.APITYPE.name + " = " + LogCenterConstants.SYNC_API_TYPE_OTHER - + " ) and " + COLUMN.EVENTTIME.name + " between %s and %s)" + - " OR " + " ((" - + COLUMN.APITYPE.name + " = " + LogCenterConstants.SYNC_API_TYPE_ACQUIRE_WAIT_START + " OR " - + COLUMN.APITYPE.name + " = " + LogCenterConstants.SYNC_API_TYPE_ACQUIRE_WAIT_END + " OR " - + COLUMN.APITYPE.name + " = " + LogCenterConstants.SYNC_API_TYPE_RELEASE + " OR " - + COLUMN.APITYPE.name + " = " + LogCenterConstants.SYNC_API_TYPE_TRY_ACQUIRE + " OR " - + COLUMN.APITYPE.name + " = " + LogCenterConstants.SYNC_API_TYPE_COND_WAIT_START + " OR " - + COLUMN.APITYPE.name + " = " + LogCenterConstants.SYNC_API_TYPE_COND_WAIT_END + ") AND (" - + COLUMN.BLOCKENDTIME.name + " >= %s AND " + COLUMN.EVENTTIME.name + " <= %s))"; + + " ) and " + COLUMN.EVENTTIME.name + " between %s and %s)" + " OR " + " ((" + + COLUMN.APITYPE.name + " = " + LogCenterConstants.SYNC_API_TYPE_ACQUIRE_WAIT_START + + " OR " + COLUMN.APITYPE.name + " = " + + LogCenterConstants.SYNC_API_TYPE_ACQUIRE_WAIT_END + " OR " + COLUMN.APITYPE.name + + " = " + LogCenterConstants.SYNC_API_TYPE_RELEASE + " OR " + COLUMN.APITYPE.name + + " = " + LogCenterConstants.SYNC_API_TYPE_TRY_ACQUIRE + " OR " + COLUMN.APITYPE.name + + " = " + LogCenterConstants.SYNC_API_TYPE_COND_WAIT_START + " OR " + + COLUMN.APITYPE.name + " = " + LogCenterConstants.SYNC_API_TYPE_COND_WAIT_END + + ") AND (" + COLUMN.BLOCKENDTIME.name + " >= %s AND " + COLUMN.EVENTTIME.name + + " <= %s))"; public enum COLUMN { - API_SEQNUMBER(0, "APISEQNUMBER"), SYNCDATAID(1, "SyncDataID"), EVENTTIME(2, "EventTime"), APITYPE( - 3, "APIType"), TOOLTIP(4, "Tooltip"), ERRORNO(5, DBConstants.DBCOLUMN_ERROR_NUMBER), SYNCVALUE( - 6, "SyncValue"), BLOCKENDTIME(7, "BlockEndTime"); + API_SEQNUMBER(0, "APISEQNUMBER"), + SYNCDATAID(1, "SyncDataID"), + EVENTTIME(2, "EventTime"), + APITYPE(3, "APIType"), + TOOLTIP(4, "Tooltip"), + ERRORNO(5, DBConstants.DBCOLUMN_ERROR_NUMBER), + SYNCVALUE(6, "SyncValue"), + BLOCKENDTIME(7, "BlockEndTime"); public final int index; public final String name; @@ -104,8 +106,6 @@ public class SyncEventDBTable extends DBTable { addColumn(new DBColumn(COLUMN.BLOCKENDTIME.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG)); setIndexColumn(COLUMN.SYNCDATAID.index); - - dbInserter = DBInsertManager.makeInserter(this); } public List> getSyncEventFromDB() { @@ -153,7 +153,7 @@ public class SyncEventDBTable extends DBTable { } insertData.add(insertRowData); } - if (DACommunicator.isRunning()) { + if (DACommunicator.isRunning() && dbInserter != null) { dbInserter.pushData(insertData); } else { insertData(insertData); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/db/ThreadAPIDBTable.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/db/ThreadAPIDBTable.java index fb82204..6a4a3bf 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/db/ThreadAPIDBTable.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/db/ThreadAPIDBTable.java @@ -38,15 +38,12 @@ import org.tizen.dynamicanalyzer.communicator.DACommunicator; import org.tizen.dynamicanalyzer.constant.CommonConstants; import org.tizen.dynamicanalyzer.database.DBColumn; import org.tizen.dynamicanalyzer.database.DBConstants; -import org.tizen.dynamicanalyzer.database.DBInsertManager; -import org.tizen.dynamicanalyzer.database.DBInserter; import org.tizen.dynamicanalyzer.database.DBTable; import org.tizen.dynamicanalyzer.swap.model.data.ThreadData; import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageThreadDataEvent; public class ThreadAPIDBTable extends DBTable { public static final String TABLENAME = "THREADAPI"; - private DBInserter dbInserter = null; private static final String SELECT_COLUMN = COLUMN.SEQ.name + CommonConstants.COMMA + COLUMN.APICALLTIME.name + CommonConstants.COMMA + COLUMN.APIID.name + CommonConstants.COMMA + COLUMN.PID.name + CommonConstants.COMMA + COLUMN.TID.name @@ -56,10 +53,15 @@ public class ThreadAPIDBTable extends DBTable { + " where " + COLUMN.THREADDATAID.name + " = %s"; public enum COLUMN { - SEQ(0, "SEQNUMBER"), THREADDATAID(1, "ThreadDataID"), APICALLTIME(2, "APICallTime"), APIID( - 3, "APIID"), PID(4, "PID"), TID(5, "TID"), ARGUMENT(6, - DBConstants.DBCOLUMN_ARGUMENT), RETURN(7, DBConstants.DBCOLUMN_RETURN_VALUE), ERRORNO( - 8, DBConstants.DBCOLUMN_ERROR_NUMBER); + SEQ(0, "SEQNUMBER"), + THREADDATAID(1, "ThreadDataID"), + APICALLTIME(2, "APICallTime"), + APIID(3, "APIID"), + PID(4, "PID"), + TID(5, "TID"), + ARGUMENT(6, DBConstants.DBCOLUMN_ARGUMENT), + RETURN(7, DBConstants.DBCOLUMN_RETURN_VALUE), + ERRORNO(8, DBConstants.DBCOLUMN_ERROR_NUMBER); public final int index; public final String name; @@ -90,7 +92,6 @@ public class ThreadAPIDBTable extends DBTable { DALimit.FUNCTION_RETURN_VALUE_LENGTH)); addColumn(new DBColumn(COLUMN.ERRORNO.name, DBConstants.EMPTY, DBConstants.DBTYPE_LONG)); setIndexColumn(COLUMN.THREADDATAID.index); - dbInserter = DBInsertManager.makeInserter(this); } public List> getThreadAPIFromDB() { @@ -123,7 +124,7 @@ public class ThreadAPIDBTable extends DBTable { if (apiData.size() == 0) { return; } - if (DACommunicator.isRunning()) { + if (DACommunicator.isRunning() && dbInserter != null) { dbInserter.pushData(apiData); } else { insertData(apiData); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/db/ThreadEventDBTable.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/db/ThreadEventDBTable.java index 74cd895..87e7844 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/db/ThreadEventDBTable.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/thread/db/ThreadEventDBTable.java @@ -38,14 +38,11 @@ import org.tizen.dynamicanalyzer.communicator.DACommunicator; import org.tizen.dynamicanalyzer.constant.CommonConstants; import org.tizen.dynamicanalyzer.database.DBColumn; import org.tizen.dynamicanalyzer.database.DBConstants; -import org.tizen.dynamicanalyzer.database.DBInsertManager; -import org.tizen.dynamicanalyzer.database.DBInserter; import org.tizen.dynamicanalyzer.database.DBTable; import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageThreadDataEvent; public class ThreadEventDBTable extends DBTable { public static final String TABLENAME = "THREADEVENT"; - private DBInserter dbInserter = null; private static final String SELECT_COLUMN = COLUMN.THREADDATAID.name + CommonConstants.COMMA + COLUMN.EVENTTIME.name + CommonConstants.COMMA + COLUMN.TID.name @@ -58,9 +55,15 @@ public class ThreadEventDBTable extends DBTable { + " where " + COLUMN.EVENTTIME.name + " BETWEEN %s and %s"; public enum COLUMN { - THREADDATAID(0, "ThreadDataID"), EVENTTIME(1, "EventTime"), TID(2, "TID"), APITYPE(3, - "APIType"), TOOLTIP(4, "Tooltip"), ERRORNO(5, DBConstants.DBCOLUMN_ERROR_NUMBER), EVENTTYPE( - 6, "EventType"), THREADTYPE(7, "ThreadType"), CALLERID(8, "CallerID"); + THREADDATAID(0, "ThreadDataID"), + EVENTTIME(1, "EventTime"), + TID(2, "TID"), + APITYPE(3, "APIType"), + TOOLTIP(4, "Tooltip"), + ERRORNO(5, DBConstants.DBCOLUMN_ERROR_NUMBER), + EVENTTYPE(6, "EventType"), + THREADTYPE(7, "ThreadType"), + CALLERID(8, "CallerID"); public final int index; public final String name; @@ -90,7 +93,6 @@ public class ThreadEventDBTable extends DBTable { DBConstants.DBTYPE_INT4)); addColumn(new DBColumn(COLUMN.CALLERID.name, DBConstants.EMPTY, DBConstants.DBTYPE_INT4)); setIndexColumn(COLUMN.THREADDATAID.index); - dbInserter = DBInsertManager.makeInserter(this); } public List> getThreadEventFromDB() { @@ -121,7 +123,7 @@ public class ThreadEventDBTable extends DBTable { if (insertData.size() == 0) { return; } - if (DACommunicator.isRunning()) { + if (DACommunicator.isRunning() && dbInserter != null) { dbInserter.pushData(insertData); } else { insertData(insertData); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/common/TimelineChartManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/common/TimelineChartManager.java index b47c6cd..511c4e6 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/common/TimelineChartManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/common/TimelineChartManager.java @@ -38,7 +38,6 @@ import java.util.Set; import org.tizen.dynamicanalyzer.common.Global; import org.tizen.dynamicanalyzer.constant.CommonConstants; -import org.tizen.dynamicanalyzer.database.DBInsertManager; import org.tizen.dynamicanalyzer.database.DBInserter; import org.tizen.dynamicanalyzer.database.SqlConnectionManager; import org.tizen.dynamicanalyzer.project.BinaryInfo; @@ -148,11 +147,11 @@ public class TimelineChartManager extends PageDataManager implements IDAChartSer targetProcessDBTable = new TargetProcessDBTable(); lifeCycleDBTable = new LifeCycleDBTable(); - customLogParser = new CustomLogParser(this, DBInsertManager.makeInserter(customDataDBTable)); - systemDBInserter = DBInsertManager.makeInserter(systemDataTable); - targetProcessDBInserter = DBInsertManager.makeInserter(targetProcessDBTable); - uiEventDBInserter = DBInsertManager.makeInserter(uiEventDBTable); - lifeCycleDBInserter = DBInsertManager.makeInserter(lifeCycleDBTable); + customLogParser = new CustomLogParser(this, makeInserter(customDataDBTable)); + systemDBInserter = makeInserter(systemDataTable); + targetProcessDBInserter = makeInserter(targetProcessDBTable); + uiEventDBInserter = makeInserter(uiEventDBTable); + lifeCycleDBInserter = makeInserter(lifeCycleDBTable); initChartMap(CPUChart.getInstance()); initChartMap(CPUCoreChart.getInstance()); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/common/TimelineEditItemsDialog.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/common/TimelineEditItemsDialog.java index c23c922..19bd44a 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/common/TimelineEditItemsDialog.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/common/TimelineEditItemsDialog.java @@ -79,7 +79,6 @@ import org.tizen.dynamicanalyzer.resources.FontResources; import org.tizen.dynamicanalyzer.resources.ImageResources; import org.tizen.dynamicanalyzer.ui.timeline.chart.TimelineChart; import org.tizen.dynamicanalyzer.ui.toolbar.setting.data.SettingDataManager; -import org.tizen.dynamicanalyzer.ui.toolbar.setting.data.TargetData; import org.tizen.dynamicanalyzer.util.Logger; import org.tizen.dynamicanalyzer.utils.AnalyzerUtil; import org.tizen.dynamicanalyzer.widgets.button.DACustomButton; diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/StartProcessManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/StartProcessManager.java deleted file mode 100644 index 28b293c..0000000 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/StartProcessManager.java +++ /dev/null @@ -1,146 +0,0 @@ -/* - * Dynamic Analyzer - * - * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. - * - * Contact: - * Jaewon Lim - * 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.toolbar; - -import org.eclipse.swt.SWT; -import org.eclipse.swt.widgets.Display; -import org.eclipse.swt.widgets.Shell; -import org.tizen.dynamicanalyzer.common.AnalyzerManager; -import org.tizen.dynamicanalyzer.nl.AnalyzerLabels; -import org.tizen.dynamicanalyzer.util.Logger; -import org.tizen.dynamicanalyzer.util.WorkbenchUtil; -import org.tizen.dynamicanalyzer.widgets.button.DACustomButton; -import org.tizen.dynamicanalyzer.widgets.button.DACustomButtonClickEventListener; -import org.tizen.dynamicanalyzer.widgets.da.base.ProgressDialog; -import org.tizen.dynamicanalyzer.widgets.progress.Progress; -import org.tizen.dynamicanalyzer.workbench.LayoutManager; - -public class StartProcessManager implements Runnable { - private static ProgressDialog dialog = null; - private static int count = 1; - private static boolean canceled = false; - - private static StartProcessManager instance = new StartProcessManager(); - - public static StartProcessManager getInstance() { - return instance; - } - - public void startProcessStart(String waitMessage) { - Shell shell = WorkbenchUtil.getWorkbenchWindow().getShell(); - dialog = new ProgressDialog(shell, LayoutManager.getBaseComposite()); - if (null != dialog) { - dialog.setStyle(SWT.ON_TOP); - dialog.setProgressStyle(Progress.PROGRESS_STYLE_CANCEL); - dialog.open(); -// AnalyzerManager.setExit(false); - canceled = false; - dialog.setProgressMessage(waitMessage); - dialog.setProgressInfo(AnalyzerLabels.DLG_PLEASE_WAIT); - dialog.setCancelListener(new DACustomButtonClickEventListener() { - - @Override - public void handleClickEvent(DACustomButton button) { -// AnalyzerManager.setExit(true); - canceled = true; - ToolbarArea.getInstance().stopTrace(); - } - }); - } - - Thread thread = new Thread(new StartProcessManager()); - thread.start(); - } - - - public void setValue(final int nSelect) { - - if (null != dialog) { - Display.getDefault().syncExec(new Runnable() { - @Override - public void run() { - dialog.setValue(nSelect); - } - }); - } - } - - public void stopProgress() { - if (null != dialog) { - Display.getDefault().syncExec(new Runnable() { - @Override - public void run() { - dialog.setValue(100); - dialog.close(); - } - }); - } - } - - @Override - public void run() { - count = 10; - Logger.debug("appinfo : " - + AnalyzerManager.isProcessInfoArrived() + "is exit :" - + AnalyzerManager.isExit()); - while ((!AnalyzerManager.isExit()) && (canceled == false)) { - if (AnalyzerManager.isRunning() - && AnalyzerManager.isProcessInfoArrived()) { - break; - } - count += 2; - - if (count > 50 && !AnalyzerManager.isRunning()) { - break; - } else if (count / 10 < 99) { - // time out - Display.getDefault().syncExec(new Runnable() { - @Override - public void run() { - dialog.setValue(count / 10); - } - }); - } - - try { - Thread.sleep(100); - } catch (InterruptedException e) { - e.printStackTrace(); - } - } - stopProgress(); - Logger.performance("TEST", "Start Trace", "Start Process Manager"); - } - - public boolean isCancelled() { - return canceled; - } - - public void setCancelDisable() { - dialog.setCancelEnabled(false); - } -} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/StopLogProcessor.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/StopLogProcessor.java deleted file mode 100644 index 0029094..0000000 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/StopLogProcessor.java +++ /dev/null @@ -1,141 +0,0 @@ -/* - * Dynamic Analyzer - * - * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. - * - * Contact: - * Jaewon Lim - * 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.ui.toolbar; - -import org.eclipse.swt.widgets.Display; -import org.tizen.dynamicanalyzer.common.AnalyzerConstants; -import org.tizen.dynamicanalyzer.common.AnalyzerManager; -import org.tizen.dynamicanalyzer.common.Global; -import org.tizen.dynamicanalyzer.communicator.DACommunicator; -import org.tizen.dynamicanalyzer.project.Project; -import org.tizen.dynamicanalyzer.swap.logparser.SWAPLogParser; -import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackInserter; -import org.tizen.dynamicanalyzer.ui.page.UpdateViewTimer; -import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler; -import org.tizen.dynamicanalyzer.util.Logger; - -public class StopLogProcessor implements Runnable { - private static Thread stopLogProcessThread = null; - - private static int count = 0; - - public static void runStopLogProcessThread() { - if (count <= 0) { - count = 1; - stopLogProcessThread = new Thread(null, new StopLogProcessor(), - AnalyzerConstants.STOP_LOG_THREAD); - stopLogProcessThread.start(); - } - } - - public static void stopStopLogProcessThread() { - if (null != stopLogProcessThread && stopLogProcessThread.isAlive()) { - stopLogProcessThread.interrupt(); - } - } - - public static void clear() { - count = 0; - stopStopLogProcessThread(); - } - - @Override - public void run() { - Logger.performanceSubThreadStart("TEST", "DA end", "Run stop log process thread"); - Project project = Global.getProject(); - int percent = 0; - - int exitCount = 0; - while (DACommunicator.isWaitToReceive() && exitCount < 1000) { - // Logger.debug("wait for STOP ACK message..."); - try { - Thread.sleep(10); - exitCount++; - if (exitCount % 20 == 0) { - StopProcessManager.getInstance().setValue(percent++); - } - } catch (InterruptedException e) { - e.printStackTrace(); - } - } - - if (DACommunicator.isSWAPVersion()) { - SWAPLogParser.stopLogParser(); - } - percent += 30; - StopProcessManager.getInstance().setValue(percent); - - UpdateViewTimer.stop(); - percent += 10; - StopProcessManager.getInstance().setValue(percent); - - StopProcessManager.getInstance().setValue(percent); - - /* save Project */ - Logger.debug(" save project and others..."); //$NON-NLS-1$ - - if (null == project || !project.isValid()) { - Logger.debug("project temp save is fail : project is not valid"); //$NON-NLS-1$ - } else { - project.setTotalStopTime(ToolbarArea.getInstance().getTime()); -// SqlManager.getInstance().saveLeakData(); -// SqlManager.getInstance().saveFailedData(); - CallStackInserter.getInstance().stopInserterThread(); - FunctionUsageProfiler.getInstance().saveProfilingData(); - FunctionUsageProfiler.getInstance().saveProfilingChildData(); - project.save(); - Logger.debug("insert to db complete..."); //$NON-NLS-1$ - percent += 10; - StopProcessManager.getInstance().setValue(percent); - } - - Display.getDefault().syncExec(new Runnable() { - @Override - public void run() { - StopProcessManager.getInstance().stopTrace(); - Logger.performanceSubThreadEnd("TEST", "DA end", "Run stop log process thread"); - } - }); - - if (!AnalyzerManager.isExit()) { - ToolbarArea.getInstance().stopTimer(); - } - - Display.getDefault().syncExec(new Runnable() { - @Override - public void run() { - ToolbarArea.getInstance().setStartButtonEnablement(true); - ToolbarArea.getInstance().setMainControlEnablement(true); - ToolbarArea.getInstance().setSettingsButtonEnablement(true); - } - }); - - Logger.performanceEnd("TEST"); - count--; - } -} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/StopProcessManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/StopProcessManager.java deleted file mode 100644 index 8adca2e..0000000 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/StopProcessManager.java +++ /dev/null @@ -1,101 +0,0 @@ -/* - * Dynamic Analyzer - * - * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. - * - * Contact: - * Jaewon Lim - * Jooyoul Lee - * 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.ui.toolbar; - -import org.eclipse.swt.widgets.Display; -import org.eclipse.swt.widgets.Shell; -import org.tizen.dynamicanalyzer.common.AnalyzerManager; -import org.tizen.dynamicanalyzer.common.Global; -import org.tizen.dynamicanalyzer.nl.AnalyzerLabels; -import org.tizen.dynamicanalyzer.shortcut.ShortCutManager; -import org.tizen.dynamicanalyzer.ui.summary.SummaryPage; -import org.tizen.dynamicanalyzer.util.WorkbenchUtil; -import org.tizen.dynamicanalyzer.utils.AnalyzerUtil; -import org.tizen.dynamicanalyzer.widgets.da.base.ProgressDialog; -import org.tizen.dynamicanalyzer.workbench.LayoutManager; - -public class StopProcessManager { - public static final int INIT = 0; - public static final int STOP_PROCESS_START = 1; - public static final int STOP_PROCESS_END = 2; - - private static int state = INIT; - private ProgressDialog dialog = null; - - private static StopProcessManager instance = new StopProcessManager(); - - public static StopProcessManager getInstance() { - return instance; - } - - public void stopProcessStart(String EndMessage) { - if (state == STOP_PROCESS_START || state == STOP_PROCESS_END) { - return; - } - state = STOP_PROCESS_START; - AnalyzerManager.setRunningState(false); - Global.setCurrentState(Global.STATE.PREPARE_END); - Shell shell = WorkbenchUtil.getWorkbenchWindow().getShell(); - dialog = new ProgressDialog(shell, LayoutManager.getBaseComposite()); - if (null != dialog) { - dialog.open(); - dialog.setProgressMessage(EndMessage); - dialog.setProgressInfo(AnalyzerLabels.DLG_PLEASE_WAIT); - } - } - - public void setValue(final int nSelect) { - - if (null != dialog) { - Display.getDefault().syncExec(new Runnable() { - @Override - public void run() { - dialog.setValue(nSelect); - } - }); - } - } - - public void stopTrace() { - if (null != dialog) { - dialog.setValue(100); - AnalyzerUtil.changePage(SummaryPage.pageID); - dialog.close(); - state = STOP_PROCESS_END; - } - ShortCutManager.getInstance().setEnabled(true); - } - - public int getState() { - return state; - } - - public static void clear() { - state = INIT; - } -} 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 399ee55..a97ffac 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 @@ -45,20 +45,20 @@ import org.eclipse.swt.widgets.Event; import org.eclipse.swt.widgets.Label; import org.eclipse.swt.widgets.Listener; import org.eclipse.swt.widgets.Shell; +import org.tizen.dynamicanalyzer.annotation.UIMethod; import org.tizen.dynamicanalyzer.appearance.DesignConstants; import org.tizen.dynamicanalyzer.common.AnalyzerConstants; import org.tizen.dynamicanalyzer.common.AnalyzerManager; +import org.tizen.dynamicanalyzer.common.DAResult; import org.tizen.dynamicanalyzer.common.Global; import org.tizen.dynamicanalyzer.common.Global.STATE; import org.tizen.dynamicanalyzer.communicator.DACommunicator; import org.tizen.dynamicanalyzer.constant.CommonConstants; import org.tizen.dynamicanalyzer.control.ApplistManager; import org.tizen.dynamicanalyzer.handlers.CommandAction; -import org.tizen.dynamicanalyzer.handlers.CommonAction; -import org.tizen.dynamicanalyzer.handlers.ReplayTraceHandler; +import org.tizen.dynamicanalyzer.handlers.ReplayManager; import org.tizen.dynamicanalyzer.model.DeviceInfo; import org.tizen.dynamicanalyzer.nl.AnalyzerLabels; -import org.tizen.dynamicanalyzer.nl.ConfigureLabels; import org.tizen.dynamicanalyzer.project.AppInfo; import org.tizen.dynamicanalyzer.project.PackageInfo; import org.tizen.dynamicanalyzer.project.ProcessInformation; @@ -69,14 +69,10 @@ import org.tizen.dynamicanalyzer.resources.ImageResources; import org.tizen.dynamicanalyzer.shortcut.ShortCutManager; import org.tizen.dynamicanalyzer.ui.common.explorer.DeviceExplorerDialog; import org.tizen.dynamicanalyzer.ui.page.BaseView; -import org.tizen.dynamicanalyzer.ui.timeline.TimelinePage; import org.tizen.dynamicanalyzer.ui.toolbar.opentrace.OpenTraceDialog; import org.tizen.dynamicanalyzer.ui.toolbar.replayEditor.ReplayEditDialog; import org.tizen.dynamicanalyzer.ui.toolbar.setting.SettingDialog; -import org.tizen.dynamicanalyzer.ui.toolbar.setting.SettingDialogManager; -import org.tizen.dynamicanalyzer.util.Logger; import org.tizen.dynamicanalyzer.util.WorkbenchUtil; -import org.tizen.dynamicanalyzer.utils.AnalyzerUtil; import org.tizen.dynamicanalyzer.widgets.button.DACustomButton; import org.tizen.dynamicanalyzer.widgets.button.DACustomButtonClickEventListener; import org.tizen.dynamicanalyzer.widgets.button.DACustomButtonRenderer; @@ -85,7 +81,9 @@ import org.tizen.dynamicanalyzer.widgets.combo.DACustomCombo; import org.tizen.dynamicanalyzer.widgets.combo.DACustomComboSelectionListener; import org.tizen.dynamicanalyzer.widgets.combo.DACustomComboTooltip; import org.tizen.dynamicanalyzer.widgets.da.base.DADialog; +import org.tizen.dynamicanalyzer.widgets.timer.IAlarm; import org.tizen.dynamicanalyzer.widgets.timer.TimerClock; +import org.tizen.dynamicanalyzer.workbench.LayoutManager; import org.tizen.sdblib.IDevice; import org.tizen.sdblib.service.FileEntry; @@ -107,14 +105,10 @@ public class ToolbarArea { private static ToolbarArea coolbarArea; - // Toolbar + // toolbar controls private DACustomCombo deviceCombo; private DACustomCombo appCombo; - private DACustomCombo processCombo; - - private HashMap buttons = new HashMap(); - private DACustomButton startButton; private TimerClock timerClock; private DACustomButton saveTraceButton; @@ -123,15 +117,13 @@ public class ToolbarArea { private DACustomButton replayEditButton; private DACustomButton configButton; private DACustomButton screenshotButton; - private DACustomButton aboutButton; - private DACustomToggleButton viewSourceButton; - private static final int TIMER_WIDTH = 122; + // toolbar buttons by id + private Map buttons = new HashMap(); - public static final int TOOLBAR_STATE_RECORDING = 0; - public static final int TOOLBAR_STATE_READY = 1; + private static final int TIMER_WIDTH = 122; public static void createInstance(Composite parent) { if (null == coolbarArea) { @@ -140,11 +132,11 @@ public class ToolbarArea { } public static ToolbarArea getInstance() { - if (null != coolbarArea) { - return coolbarArea; - } else { - return null; + if (null == coolbarArea) { + createInstance(LayoutManager.getToolbarComposite()); } + + return coolbarArea; } public DACustomCombo getDeviceCombo() { @@ -155,50 +147,12 @@ public class ToolbarArea { return appCombo; } - public DACustomCombo getProcessCombo() { - return processCombo; - } - private ToolbarArea(Composite parent) { parent.setBackground(ColorResources.COOLBAR_BG_COLOR); createToolbar(parent); parent.layout(true); } - public void setRepalyButtonEnable(final boolean enabled) { - Display.getDefault().syncExec(new Runnable() { - @Override - public void run() { - Project p = Global.getProject(); - if (null == p || !p.isValid() || !enabled) { - replayButton.setButtonEnabled(false); - replayEditButton.setButtonEnabled(false); - return; - } - - String sDeviceName = null; - DeviceInfo curDev = Global.getCurrentDeviceInfo(); - if (curDev != null) { - sDeviceName = curDev.getIDevice().getSerialNumber(); - } - String pDeviceName = p.getDevice(); - - String appName = p.getAppName(); - String text = appCombo.getText(); - if ((null != pDeviceName && !pDeviceName.isEmpty() && pDeviceName - .equals(sDeviceName)) - && (null != appName && !appName.isEmpty() && appName.equals(text))) { - replayButton.setButtonEnabled(true); - replayEditButton.setButtonEnabled(true); - // disable button until complete TV SDK - } else { - replayButton.setButtonEnabled(false); - replayEditButton.setButtonEnabled(false); - } - } - }); - } - private void addToolbarListeners() { deviceCombo.addSelectionListener(new DACustomComboSelectionListener() { @@ -243,7 +197,7 @@ public class ToolbarArea { if (newDevice != null && !newDevice.isEmpty()) { DACommunicator.setSelectedDeviceBySerial(serial); initAppCombo(); - setRepalyButtonEnable(true); + setReplayButtonState(true); } } }); @@ -251,7 +205,7 @@ public class ToolbarArea { } else if (!serial.equals(oldDeviceName)) { DACommunicator.setSelectedDeviceBySerial(serial); initAppCombo(); - setRepalyButtonEnable(true); + setReplayButtonState(true); } } } @@ -336,7 +290,7 @@ public class ToolbarArea { if (enablestart && null != Global.getCurrentDeviceInfo()) { setStartButtonState(true); - setRepalyButtonEnable(true); + setReplayButtonState(true); } } } @@ -446,7 +400,7 @@ public class ToolbarArea { @Override public void handleClickEvent(DACustomButton button) { if (!AnalyzerManager.isRunning()) { - if (AnalyzerUtil.executeCommand(ReplayTraceHandler.ID) != AnalyzerConstants.FAIL) { + if (ReplayManager.init()) { startTrace(); } } @@ -501,124 +455,13 @@ public class ToolbarArea { }); } - public void setStartButtonToolTipText(final String text) { - Display.getDefault().syncExec(new Runnable() { - @Override - public void run() { - startButton.setToolTipText(text); - } - }); - - } - - private void resetProcessCombo() { - processCombo.initCombo(); - processCombo.add(ALL_PROCESS); - processCombo.select(0); - } - - public void start() { - resetProcessCombo(); - CommandAction.startTrace(); - } - public void startTrace() { - ShortCutManager.getInstance().setEnabled(false); - if (!checkValidApplication()) { - // fail message box - Shell shell = WorkbenchUtil.getWorkbenchWindow().getShell(); - DADialog warning = new DADialog(shell, SWT.NONE); - warning.setMessage(AnalyzerLabels.INVALID_APPLICATION); - warning.setIcon(ImageResources.DIALOG_WARNING_ICON); - warning.open(); - - setToolbarStartStopState(true); - - // commented because REMOVE_DEVICE is added - // if (null == DACommunicator.getDevices() || DACommunicator.getDevices().isEmpty()) { - // deviceCombo.setEnabled(false); - // } - - if (!deviceCombo.isEnabled() || null == Global.getCurrentDeviceInfo()) { - appCombo.setEnabled(false); - } - - if (!appCombo.isEnabled() || null == Global.getCurrentApplication()) { - setStartButtonEnablement(false); - } - - setSaveButtonEnable(false); - - ShortCutManager.getInstance().setEnabled(true); - Logger.performance("TEST", "Start Trace", "Check valid application"); - return; - } - - // check setting status - if (checkSettingStatus() == false) { - return; - } - - Logger.performance("TEST", "Start Trace", "Check valid application"); - Display.getDefault().syncExec(new Runnable() { - - @Override - public void run() { - StartProcessManager.getInstance().startProcessStart("prepare for tracing"); - } - }); - - AnalyzerUtil.changePage(TimelinePage.pageID); - Logger.performance("TEST", "Start Trace", "Change to the Timeline page"); - AnalyzerManager.setRunningState(true); - Global.setCurrentState(STATE.PREPARE_START); resetProcessCombo(); - TraceStartStopThread.runStartStopThread(); - } - - private boolean checkSettingStatus() { - if (Global.getCurrentDeviceInfo().isConfigSuccess() == false) { - if (CommonAction.configure() == false) { - // fail message box - Shell shell = WorkbenchUtil.getWorkbenchWindow().getShell(); - DADialog dialog = new DADialog(shell, SWT.NONE, 550, 153); - dialog.setIcon(ImageResources.DIALOG_WARNING_ICON); - dialog.setMessage(ConfigureLabels.SETTING_WARNING_MESSAGE_SETTING_FAIL); - dialog.open(); - - setToolbarStartStopState(true); - - // commented because REMOVE_DEVICE is added - // if (null == DACommunicator.getDevices() || DACommunicator.getDevices().isEmpty()) - // { - // deviceCombo.setEnabled(false); - // } - - if (!deviceCombo.isEnabled() || null == Global.getCurrentDeviceInfo()) { - appCombo.setEnabled(false); - } - - if (!appCombo.isEnabled() || null == Global.getCurrentApplication()) { - setStartButtonEnablement(false); - } - - setSaveButtonEnable(false); - - ShortCutManager.getInstance().setEnabled(true); - // Logger.performance("TEST", "Start Trace", "Check setting information"); - return false; - } - } - return true; + CommandAction.startTrace(); } public void stopTrace() { - ShortCutManager.getInstance().setEnabled(false); - Global.getProject().setReplayStopTime(getTime()); - AnalyzerManager.setRunningState(false); - Global.setCurrentState(STATE.PREPARE_END); - AnalyzerManager.stopScreenshotTimer(); - TraceStartStopThread.runStartStopThread(); + CommandAction.stopTrace(DAResult.SUCCESS, false); } private void createToolbar(Composite parent) { @@ -882,10 +725,6 @@ public class ToolbarArea { }); } - public TimerClock getTimer() { - return timerClock; - } - private void initAppCombo() { String device = deviceCombo.getText(); if (device.isEmpty()) { @@ -930,9 +769,8 @@ public class ToolbarArea { appCombo.initCombo(); setStartButtonState(false); // startButton.setButtonEnabled(false); - replayButton.setButtonEnabled(false); - replayEditButton.setButtonEnabled(false); - saveTraceButton.setButtonEnabled(false); + setReplayButtonState(false); + setSaveButtonState(false); } public void setDeviceComboItems(String oldDevice, List items) { @@ -943,8 +781,8 @@ public class ToolbarArea { deviceCombo.select(0); appCombo.initCombo(); appCombo.setEnabled(false); - setRepalyButtonEnable(false); - setStartButtonEnablement(false); + setReplayButtonState(false); + setStartButtonState(false); return; } else { int size = items.size(); @@ -966,9 +804,9 @@ public class ToolbarArea { initAppCombo(); } appCombo.setEnabled(true); - setRepalyButtonEnable(true); - setStartButtonEnablement(true); - setSettingsButtonEnablement(true); + setReplayButtonState(true); + setStartButtonState(true); + configButton.setButtonEnabled(true); } } @@ -1153,74 +991,9 @@ public class ToolbarArea { } - public boolean isSourceViewEnabled() { - return viewSourceButton.isToggled(); - } - - public void setStartButtonEnablement(final boolean enabled) { - Display.getDefault().syncExec(new Runnable() { - - @Override - public void run() { - if (!enabled) { - // startButton.setButtonEnabled(false); - setStartButtonState(false); - return; - } - - DeviceInfo curDev = Global.getCurrentDeviceInfo(); - if (curDev == null) { - setStartButtonState(false); - return; - } - - String text = deviceCombo.getText(); - String device = curDev.getIDevice().getSerialNumber(); - if (!device.equals(text)) { - // startButton.setButtonEnabled(false); - setStartButtonState(false); - return; - } - - PackageInfo packInfo = Global.getCurrentApplication(); - if (packInfo == null) { - setStartButtonState(false); - return; - } - - setStartButtonState(true); - // startButton.setButtonEnabled(true); - } - }); - // startButton.setButtonEnabled(enabled); - } - - public void checkStartButtonAndAppListEnablement() { - Display.getDefault().syncExec(new Runnable() { - - @Override - public void run() { - String text = deviceCombo.getText(); - String device = null; - DeviceInfo curDev = Global.getCurrentDeviceInfo(); - if (curDev != null) - device = curDev.getIDevice().getSerialNumber(); - if (device == null || !device.equals(text)) { - // startButton.setButtonEnabled(false); - setStartButtonState(false); - appCombo.setEnabled(false); - return; - } - // startButton.setButtonEnabled(true); - setStartButtonState(true); - appCombo.setEnabled(true); - } - }); - } - - public void setSettingsButtonEnablement(boolean enabled) { - configButton.setButtonEnabled(enabled); - } + // ============================================================================================ + // SEE : refactored from below ( start at 15/01/22 ) + // ============================================================================================ public void startTimer() { timerClock.start(); @@ -1230,180 +1003,212 @@ public class ToolbarArea { timerClock.stop(); } + @UIMethod public void clearTimer() { timerClock.clear(); } - public void setSourceViewEnable(final boolean enabled) { - Display.getDefault().syncExec(new Runnable() { - @Override - public void run() { - viewSourceButton.setButtonEnabled(enabled); + public void setTimerAlarm(long time, IAlarm alarm) { + timerClock.setAlarm(time, alarm); + } + + public void removeTimerAlarm() { + timerClock.removeAlarm(); + } + + public int getSelectedPid() { + int ret = 0; + String pid = processCombo.getText(); + if (!pid.equals(ALL_PROCESS)) { + int index = pid.indexOf(PROCESS_SPLITER); + String str = pid.substring(0, index); + if (null != str && !str.isEmpty()) { + try { + ret = Integer.parseInt(str); + } catch (NumberFormatException e) { + e.printStackTrace(); + } } - }); + } + return ret; } - public void setSourceViewState(final boolean enabled) { + /************************************************************************************************* + * methods to change state of controls major controls : device / app combo, save / open / replay + * buttons minor controls : process combo, source view / screenshot / setting / about buttons + * special control : start button + *************************************************************************************************/ + + /** + * change the availability of toolbar UI controls by DA state + * + * @param state + * DA state + */ + public void changeUIState(STATE state) { + final STATE fState = state; Display.getDefault().syncExec(new Runnable() { @Override public void run() { - viewSourceButton.setToggled(enabled); + if (fState == STATE.PREPARE_START) { + setAllControlState(false); + } else if (fState == STATE.RUNNING) { + toggleStartButtonUI(true); + setStartButtonState(true); + setMajorControlState(false); + setMinorControlState(true); + } else if (fState == STATE.PREPARE_END) { + setAllControlState(false); + } else if (fState == STATE.PREPARE_CANCEL) { + setAllControlState(false); + } else if (fState == STATE.DONE || fState == STATE.INIT) { + toggleStartButtonUI(false); + setAllControlState(true); + } else { + // known state + setAllControlState(false); + } } }); } - public boolean getSourceViewState() { - return viewSourceButton.isToggled(); - } - - public boolean getSourceViewEnable() { - int state = viewSourceButton.getState(); - if (state == DACustomButton.STATE_DISABLE) { - return false; - } - return true; - } - - public void setSaveButtonEnable(boolean enabled) { - saveTraceButton.setButtonEnabled(enabled); - } - - public void setSourceViewTooltip(final String tooltip) { + /** + * set the availability of all toolbar UI controls + * + * @param enabled + * true if all controls to be enabled, false otherwise + */ + public void setAllControlState(boolean enabled) { + final boolean fEnabled = enabled; Display.getDefault().syncExec(new Runnable() { @Override public void run() { - viewSourceButton.setToolTipText(tooltip); + setStartButtonState(fEnabled); + setMajorControlState(fEnabled); + setMinorControlState(fEnabled); } }); } - public void setToolbarState(int state) { - if (state == TOOLBAR_STATE_RECORDING) { - toggleStartButtonUI(true); - setMainControlEnablement(false); - setStartButtonState(false); - // startButton.setButtonEnabled(false); + private void toggleStartButtonUI(boolean isStarted) { + if (isStarted) { + startButton.setImages(ImageResources.STOP, ImageResources.STOP_PUSH, + ImageResources.STOP_HOVER, ImageResources.START_DISABLE); + startButton.setToolTipText(ShortCutManager.STOP_TRACE); } else { - toggleStartButtonUI(false); - setMainControlEnablement(true); - setStartButtonState(true); - // startButton.setButtonEnabled(true); + startButton.setImages(ImageResources.START, ImageResources.START_PUSH, + ImageResources.START_HOVER, ImageResources.START_DISABLE); + startButton.setToolTipText(ShortCutManager.START_TRACE); } } - private boolean checkValidApplication() { - List devices = DACommunicator.getDevices(); - if (null == devices || devices.isEmpty()) { - Logger.debug("Device is empty"); - return false; - } - String selectedDevice = deviceCombo.getText(); - deviceCombo.initCombo(); - int size = devices.size(); - for (int i = 0; i < size; i++) { - deviceCombo.add(devices.get(i).getIDevice().getSerialNumber()); - } - deviceCombo.add(AnalyzerConstants.REMOTE_DEVICE); - - int index = deviceCombo.getItems().indexOf(selectedDevice); - if (index >= 0) { - deviceCombo.setText(selectedDevice); - } else { - deviceCombo.setText(CommonConstants.EMPTY); - return false; + private void setAppComboState(boolean enabled) { + if (enabled) { + DeviceInfo device = Global.getCurrentDeviceInfo(); + if (device != null) { + appCombo.setEnabled(true); + return; + } } - String selectedApp = appCombo.getText(); - addToAppComboFromTarget(); + appCombo.setEnabled(false); + } - index = appCombo.getItems().indexOf(selectedApp); - if (index >= 0) { - appCombo.setText(selectedApp); - return true; - } else { - appCombo.setText(CommonConstants.EMPTY); - return false; + private void setStartButtonState(boolean enabled) { + if (enabled) { + DeviceInfo device = Global.getCurrentDeviceInfo(); + if (device != null) { + String selDev = deviceCombo.getText(); + String curDev = device.getIDevice().getSerialNumber(); + if (curDev != null && !curDev.isEmpty() && curDev.equals(selDev)) { + PackageInfo curApp = Global.getCurrentApplication(); + if (curApp != null) { + startButton.setButtonEnabled(true); + return; + } + } + } } - } - public DACustomButton getButton(int id) { - return buttons.get(id); + startButton.setButtonEnabled(false); } - public void setToolbarStartStopState(final boolean isStop) { - Display.getDefault().syncExec(new Runnable() { - @Override - public void run() { - ToolbarArea.getInstance().setStartButtonEnablement(isStop); - ToolbarArea.getInstance().setMainControlEnablement(isStop); - ToolbarArea.getInstance().setSettingsButtonEnablement(isStop); + private void setSaveButtonState(boolean enabled) { + if (enabled) { + Project curProject = Global.getProject(); + if (curProject != null && curProject.isValid()) { + saveTraceButton.setButtonEnabled(true); + return; } - }); + } + + saveTraceButton.setButtonEnabled(false); } - public int getSelectedPid() { - int ret = 0; - String pid = processCombo.getText(); - if (!pid.equals(ALL_PROCESS)) { - int index = pid.indexOf(PROCESS_SPLITER); - String str = pid.substring(0, index); - if (null != str && !str.isEmpty()) { - try { - ret = Integer.parseInt(str); - } catch (NumberFormatException e) { - e.printStackTrace(); + private void setReplayButtonState(final boolean enabled) { + if (enabled) { + Project curProject = Global.getProject(); + if (curProject != null && curProject.isValid()) { + DeviceInfo curDev = Global.getCurrentDeviceInfo(); + if (curDev != null) { + String sDeviceName = curDev.getIDevice().getSerialNumber(); + String pDeviceName = curProject.getDevice(); + String appName = curProject.getAppName(); + String appComboText = appCombo.getText(); + + if (pDeviceName != null && !pDeviceName.isEmpty() + && pDeviceName.equals(sDeviceName) && appName != null + && !appName.isEmpty() && appName.equals(appComboText)) { + replayButton.setButtonEnabled(true); + replayEditButton.setButtonEnabled(true); + return; + } } } } - return ret; + + replayButton.setButtonEnabled(false); + replayEditButton.setButtonEnabled(false); } - private void setStartButtonState(boolean enabled) { - if (enabled) { - DeviceInfo device = Global.getCurrentDeviceInfo(); - // if (null != device && device.isConfigSuccess()) { - if (null != device) { - startButton.setButtonEnabled(true); - } - } else { - startButton.setButtonEnabled(false); - } + private void setMajorControlState(boolean enabled) { + deviceCombo.setEnabled(enabled); + setAppComboState(enabled); + setSaveButtonState(enabled); + openTraceButton.setButtonEnabled(enabled); + setReplayButtonState(enabled); } - // SEE : refactored from below ( start at 15/01/22 ) - public void changeUIState(STATE state) { - if (state == STATE.PREPARE_START) { - toggleStartButtonUI(true); - setMainControlEnablement(false); - setStartButtonState(false); - // startButton.setButtonEnabled(false); - } else if (state == STATE.RUNNING) { - toggleStartButtonUI(false); - setMainControlEnablement(true); - setStartButtonState(true); - // startButton.setButtonEnabled(true); - } else if (state == STATE.PREPARE_END) { + private void setMinorControlState(boolean enabled) { + processCombo.setEnabled(enabled); + viewSourceButton.setButtonEnabled(enabled); + screenshotButton.setButtonEnabled(enabled); + configButton.setButtonEnabled(enabled); + aboutButton.setButtonEnabled(enabled); + } - } + private void resetProcessCombo() { + processCombo.initCombo(); + processCombo.add(ALL_PROCESS); + processCombo.select(0); } - private void toggleStartButtonUI(boolean isStarted) { - if (isStarted) { - startButton.setImages(ImageResources.STOP, ImageResources.STOP_PUSH, - ImageResources.STOP_HOVER, ImageResources.START_DISABLE); - startButton.setToolTipText(ShortCutManager.STOP_TRACE); - } else { - startButton.setImages(ImageResources.START, ImageResources.START_PUSH, - ImageResources.START_HOVER, ImageResources.START_DISABLE); - startButton.setToolTipText(ShortCutManager.START_TRACE); - } + public boolean isSourceViewEnabled() { + return viewSourceButton.isToggled(); } - public void setMainControlEnablement(boolean enabled) { - deviceCombo.setEnabled(enabled); - appCombo.setEnabled(enabled); - saveTraceButton.setButtonEnabled(enabled); - openTraceButton.setButtonEnabled(enabled); - setRepalyButtonEnable(enabled); + public void toggleSourceView() { + Display.getDefault().syncExec(new Runnable() { + @Override + public void run() { + viewSourceButton.setToggled(!viewSourceButton.isToggled()); + } + }); + } + + public boolean getButtonEnabled(int id) { + DACustomButton button = buttons.get(id); + return button.isButtonEnabled(); } + } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/TraceStartStopThread.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/TraceStartStopThread.java deleted file mode 100644 index af1b99c..0000000 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/TraceStartStopThread.java +++ /dev/null @@ -1,155 +0,0 @@ -/* - * Dynamic Analyzer - * - * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. - * - * Contact: - * Jaewon Lim - * 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.ui.toolbar; - -import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.START_STOP_THREAD; - -import org.eclipse.swt.SWT; -import org.eclipse.swt.widgets.Display; -import org.eclipse.swt.widgets.Shell; -import org.tizen.dynamicanalyzer.common.AnalyzerManager; -import org.tizen.dynamicanalyzer.common.DAResult; -import org.tizen.dynamicanalyzer.common.Global; -import org.tizen.dynamicanalyzer.common.Global.STATE; -import org.tizen.dynamicanalyzer.communicator.DACommunicator; -import org.tizen.dynamicanalyzer.handlers.ReplayTraceHandler; -import org.tizen.dynamicanalyzer.nl.AnalyzerLabels; -import org.tizen.dynamicanalyzer.resources.ImageResources; -import org.tizen.dynamicanalyzer.shortcut.ShortCutManager; -import org.tizen.dynamicanalyzer.util.WorkbenchUtil; -import org.tizen.dynamicanalyzer.widgets.da.base.DADialog; - -public class TraceStartStopThread implements Runnable { - private static Thread startStopThread = null; - private static int count = 0; - - public static void runStartStopThread() { - if (count == 0) { - count++; - startStopThread = new Thread(null, new TraceStartStopThread(), START_STOP_THREAD); - startStopThread.start(); - } - } - - @Override - public void run() { - if (AnalyzerManager.isRunning()) { - DAResult isStarted = traceStart(); - - if (StartProcessManager.getInstance().isCancelled()) { // cancel - traceCancel(AnalyzerLabels.START_TRACE_ERROR); - } else if (isStarted.isSuccess()) { // start - if (ReplayTraceHandler.isReplay) { - ReplayTraceHandler.setStopAlarm(); - } - Display.getDefault().syncExec(new Runnable() { - @Override - public void run() { - ToolbarArea.getInstance().setStartButtonEnablement(true); - ToolbarArea.getInstance().setStartButtonToolTipText( - ShortCutManager.STOP_TRACE); - ToolbarArea.getInstance().setSettingsButtonEnablement(true); - } - }); - ShortCutManager.getInstance().setEnabled(true); - } else { // exception - traceCancel(isStarted.toString()); - } - } else if (StartProcessManager.getInstance().isCancelled()) { - traceCancel(AnalyzerLabels.START_TRACE_ERROR); - } else { - traceStop(); - } - count--; - } - - private void traceCancel(String message) { - AnalyzerManager.setRunningState(false); - Global.setCurrentState(STATE.PREPARE_CANCEL); - DACommunicator.stopTrace(); - final String msg = message; - Display.getDefault().syncExec(new Runnable() { - @Override - public void run() { - if (!AnalyzerManager.isExit()) { - ToolbarArea.getInstance().stopTimer(); - } - - final Shell shell = WorkbenchUtil.getWorkbenchWindow().getShell(); - DADialog dialog = new DADialog(shell, SWT.NONE); - dialog.setIcon(ImageResources.DIALOG_WARNING_ICON); - dialog.setMessage(msg); - dialog.open(); - - ToolbarArea.getInstance().setToolbarState(ToolbarArea.TOOLBAR_STATE_READY); - ToolbarArea.getInstance().setStartButtonEnablement(true); - ToolbarArea.getInstance().setSettingsButtonEnablement(true); - ShortCutManager.getInstance().setEnabled(true); - } - }); - } - - private DAResult traceStart() { - Display.getDefault().syncExec(new Runnable() { - @Override - public void run() { - ToolbarArea.getInstance().setToolbarState(ToolbarArea.TOOLBAR_STATE_RECORDING); - ToolbarArea.getInstance().setStartButtonEnablement(false); - ToolbarArea.getInstance().setSettingsButtonEnablement(false); - } - }); - - AnalyzerManager.initTraceStart(); - - DAResult ret = DACommunicator.startTrace(); - ret.printDebug(); - return ret; - } - - private void traceStop() { - AnalyzerManager.setRunningState(false); - Global.setCurrentState(STATE.PREPARE_END); - Display.getDefault().syncExec(new Runnable() { - @Override - public void run() { - if (!AnalyzerManager.isExit()) { - ToolbarArea.getInstance().stopTimer(); - } - - ToolbarArea.getInstance().setToolbarState(ToolbarArea.TOOLBAR_STATE_READY); - ToolbarArea.getInstance().setStartButtonEnablement(false); - ToolbarArea.getInstance().setSettingsButtonEnablement(false); - StopProcessManager.getInstance().stopProcessStart( - AnalyzerLabels.DLG_SUMMARIZING_DATA); - } - }); - - // DACommunicator.sendStopMessage(); - DACommunicator.stopTrace(); - } -} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/opentrace/OpenTraceInputReader.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/opentrace/OpenTraceInputReader.java deleted file mode 100644 index b3ad87f..0000000 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/opentrace/OpenTraceInputReader.java +++ /dev/null @@ -1,184 +0,0 @@ -/* - * Dynamic Analyzer - * - * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. - * - * Contact: - * Jaewon Lim - * 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.ui.toolbar.opentrace; - -import org.tizen.dynamicanalyzer.common.AnalyzerConstants; -import org.tizen.dynamicanalyzer.common.AnalyzerManager; -import org.tizen.dynamicanalyzer.common.Global; -import org.tizen.dynamicanalyzer.project.Project; -import org.tizen.dynamicanalyzer.swap.logparser.DataManagerRegistry; -import org.tizen.dynamicanalyzer.swap.logparser.LogPackage; -import org.tizen.dynamicanalyzer.util.Logger; - -public class OpenTraceInputReader implements Runnable { - private static Thread openTraceInputThread = null; - - public static synchronized void startOpenTraceInputReader() { - if (null == openTraceInputThread || !openTraceInputThread.isAlive()) { - openTraceInputThread = new Thread(null, new OpenTraceInputReader(), - AnalyzerConstants.OPEN_TRACE_THREAD); - openTraceInputThread.start(); - } - } - - public static void stopOpenTraceInputReader() { - if (null != openTraceInputThread && openTraceInputThread.isAlive()) { - try { - openTraceInputThread - .join(AnalyzerConstants.THREAD_JOIN_WAIT_TIME); - } catch (InterruptedException e) { - e.printStackTrace(); - } - } - } - - public static boolean isThreadAlive() { - if (null == openTraceInputThread || !openTraceInputThread.isAlive()) { - return false; - } - return true; - } - - public static void clear() { - stopOpenTraceInputReader(); - } - - @Override - public void run() { - AnalyzerManager.setLogParsingComplete(false); - Project p = Global.getProject(); - - // deprecated -// createPackage(p.getDeviceLogCount(), -// DataChannelConstants.DB_TYPE_SYSTEM); -// -// createPackage(p.getProfileLogCount(), -// DataChannelConstants.DB_TYPE_PROFILE); -// -// createPackage(p.getLogCount(), DataChannelConstants.DB_TYPE_PROBE); -// last = p.getProfileLogCount(); -// createPackage(last, DataChannelConstants.MSG_DATA_SAMPLE); - - // TODO : implement load process - - Logger.debug("input reader complete"); //$NON-NLS-1$ - AnalyzerManager.setLogParsingComplete(true); - // end - } - - // deprecated -/* - private void createPackage(long last, int type) { - List input = null; - long from = 0; - long to = AnalyzerConstants.DATABASE_READ_SIZE; - while (!Thread.interrupted()) { - if (to >= last) { - to = last; - } - - LogPackage logPackage = new LogPackage(); - switch (type) { - case DataChannelConstants.DB_TYPE_PROFILE: - input = SqlManager.getInstance().selectArea( - DataChannelConstants.MSG_FUNCTION_ENTRY, from, to); - if (null != input && !input.isEmpty()) { - for (int i = 0; i < input.size(); i++) { - int id = input.get(i).getId(); - logPackage.setLogs(id, input.get(i)); - } - } - break; - case DataChannelConstants.DB_TYPE_PROBE: - List ids = LogDataFactory.getLogList(); - int size = ids.size(); - for (int i = 0; i < size; i++) { - int id = ids.get(i); - if (id == DataChannelConstants.MSG_CONTEXT_SWITCH_ENTRY - || id == DataChannelConstants.MSG_CONTEXT_SWITCH_EXIT - || id == DataChannelConstants.MSG_FUNCTION_ENTRY - || id == DataChannelConstants.MSG_FUNCTION_EXIT - || id == DataChannelConstants.MSG_DATA_SAMPLE - || id == DataChannelConstants.MSG_DATA_SYSTEM - || id == DataChannelConstants.MSG_DATA_RECORD) { - continue; - } - Logs logs = new Logs(id); - input = SqlManager.getInstance().selectArea(id, from, to); - if (null != input && !input.isEmpty()) { - logs.setLogs(input); - logPackage.setLogs(id, logs); - for (LogData log : input) { - if (id == DataChannelConstants.MSG_PROBE_FILE - || id == DataChannelConstants.MSG_PROBE_MEMORY) { - AnalyzerManager.getLeakDetector() - .runLeakDectect(log); - } - - AnalyzerManager.getFailedChecker().check(log); - } - } - } // for - break; - case DataChannelConstants.DB_TYPE_SYSTEM: - input = SqlManager.getInstance().selectArea( - DataChannelConstants.MSG_DATA_SYSTEM, from, to); - Logs logs = new Logs(DataChannelConstants.MSG_DATA_SYSTEM); - if (null != input && !input.isEmpty()) { - logs.setLogs(input); - logPackage.setLogs(DataChannelConstants.MSG_DATA_SYSTEM, - logs); - } - break; - case DataChannelConstants.DB_TYPE_CONTEXTSWITCH: - // TODO: - break; - default: - break; - } - - if (!logPackage.isEmpty()) { - updateLog(logPackage); - } - if (to == last) { - break; - } - from += AnalyzerConstants.DATABASE_READ_SIZE + 1; - to = from + AnalyzerConstants.DATABASE_READ_SIZE; - } - } - */ - - private void updateLog(LogPackage logPack) { - if (null == logPack || logPack.isEmpty()) { - return; - } - - DataManagerRegistry.updateLog(logPack); - } -} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/opentrace/OpenTraceProgressManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/opentrace/OpenTraceProgressManager.java index c3c6aa1..119518e 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/opentrace/OpenTraceProgressManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/opentrace/OpenTraceProgressManager.java @@ -29,14 +29,12 @@ package org.tizen.dynamicanalyzer.ui.toolbar.opentrace; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Shell; import org.tizen.dynamicanalyzer.common.AnalyzerConstants; -import org.tizen.dynamicanalyzer.common.AnalyzerManager; import org.tizen.dynamicanalyzer.common.Global; -import org.tizen.dynamicanalyzer.handlers.ClearHandler; +import org.tizen.dynamicanalyzer.handlers.CommonAction; import org.tizen.dynamicanalyzer.handlers.OpenTraceCompleteHandler; import org.tizen.dynamicanalyzer.handlers.OpenTraceHandler; import org.tizen.dynamicanalyzer.nl.AnalyzerLabels; import org.tizen.dynamicanalyzer.project.Project; -import org.tizen.dynamicanalyzer.swap.logparser.DataManagerRegistry; import org.tizen.dynamicanalyzer.ui.timeline.TimelinePage; import org.tizen.dynamicanalyzer.util.WorkbenchUtil; import org.tizen.dynamicanalyzer.utils.AnalyzerUtil; @@ -183,31 +181,9 @@ public class OpenTraceProgressManager implements Runnable { return state; } - public void runThreads() { - OpenTraceInputReader.startOpenTraceInputReader(); - DataManagerRegistry.startThreads(); - } - - private void waitingThreads() { - while (!AnalyzerManager.isExit()) { - OpenTraceInputReader.stopOpenTraceInputReader(); - DataManagerRegistry.stopThreads(); - try { - if (!DataManagerRegistry.isAnyoneAlive()) { - break; - } else { - Thread.sleep(AnalyzerConstants.LOG_CHECK_INTERVAL); - } - } catch (InterruptedException e) { - /** thread stop by interrupt */ - break; - } - } - } - @Override public void run() { - AnalyzerUtil.executeCommand(ClearHandler.ID); + CommonAction.clear(); Project project = new Project(); Global.setProject(project); project.setSavePath(getInstance().getSavePath()); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/replay/data/ReplayDBManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/replay/data/ReplayDBManager.java index 0b775ce..1463cc9 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/replay/data/ReplayDBManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/replay/data/ReplayDBManager.java @@ -96,7 +96,7 @@ public class ReplayDBManager extends DBTable { List eventObjs = output.getRecordEvent(); for (List data : result) { RecordEventObject reObj = new RecordEventObject(); - reObj.setId((Integer) data.get(DB_RID_INDEX)); + reObj.setMsgID((Integer) data.get(DB_RID_INDEX)); reObj.setSeq((Long) data.get(DB_SEQ_INDEX)); reObj.setTime((Long) data.get(DB_TIME_INDEX)); DATime eventTime = new DATime(); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/replayEditor/data/ReplayEditTableDataMaker.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/replayEditor/data/ReplayEditTableDataMaker.java index 4abaac0..e083656 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/replayEditor/data/ReplayEditTableDataMaker.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/replayEditor/data/ReplayEditTableDataMaker.java @@ -107,7 +107,7 @@ public class ReplayEditTableDataMaker extends ReplayEditDataType { if (i == 0) { itemData.setEventMouseDownTime(reo.getTime()); itemData.setStrEventType(setEventType(reo.getEventType())); - itemData.setEventRid(reo.getId()); + itemData.setEventRid(reo.getMsgID()); } setItemDataValue(itemData, reo); } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/setting/SettingDialog.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/setting/SettingDialog.java index 95d6548..47c1df3 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/setting/SettingDialog.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/toolbar/setting/SettingDialog.java @@ -41,7 +41,7 @@ import org.eclipse.swt.widgets.Event; import org.eclipse.swt.widgets.Label; import org.eclipse.swt.widgets.Listener; import org.eclipse.swt.widgets.Shell; -import org.tizen.dynamicanalyzer.common.Global; +import org.tizen.dynamicanalyzer.common.AnalyzerManager; import org.tizen.dynamicanalyzer.communicator.DACommunicator; import org.tizen.dynamicanalyzer.handlers.CommonAction; import org.tizen.dynamicanalyzer.nl.AnalyzerLabels; @@ -222,7 +222,7 @@ public class SettingDialog extends DAMessageBox { tabView.addView(optionPage, false); // check platform SDK (show binary setting page) - if (Global.isPlatformSDK()) { + if (AnalyzerManager.isPlatformSDK()) { createBinarySettingPage(); } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/utils/InternalLogManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/utils/InternalLogManager.java index 5dd935a..bbdc794 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/utils/InternalLogManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/utils/InternalLogManager.java @@ -40,7 +40,6 @@ import java.util.HashMap; import java.util.List; import org.tizen.dynamicanalyzer.common.path.PathManager; -import org.tizen.dynamicanalyzer.ui.toolbar.setting.data.SettingDataManager; import org.tizen.dynamicanalyzer.util.CommonUtil; public class InternalLogManager { diff --git a/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/file/FileChartBoardTest.java b/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/file/FileChartBoardTest.java index 3b41e5c..9f31e99 100644 --- a/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/file/FileChartBoardTest.java +++ b/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/file/FileChartBoardTest.java @@ -1,18 +1,9 @@ package org.tizen.dynamicanalyzer.ui.file; -import static org.junit.Assert.*; import static org.mockito.Mockito.mock; -import java.lang.reflect.Method; - -import org.eclipse.swt.SWT; -import org.eclipse.swt.widgets.Composite; -import org.eclipse.swt.widgets.Display; -import org.eclipse.swt.widgets.Shell; import org.junit.Test; import org.powermock.reflect.Whitebox; -import org.tizen.dynamicanalyzer.callback.IExecutionCallback; -import org.tizen.dynamicanalyzer.nl.FilePageLabels; public class FileChartBoardTest { diff --git a/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/file/data/FileAccessDBTest.java b/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/file/data/FileAccessDBTest.java index 19d8c31..2568813 100644 --- a/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/file/data/FileAccessDBTest.java +++ b/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/file/data/FileAccessDBTest.java @@ -1,15 +1,13 @@ package org.tizen.dynamicanalyzer.ui.file.data; -import static org.junit.Assert.*; +import static org.junit.Assert.assertEquals; import java.io.File; import java.text.SimpleDateFormat; import java.util.Date; import java.util.List; -import org.junit.After; import org.junit.AfterClass; -import org.junit.Before; import org.junit.BeforeClass; import org.junit.Test; import org.tizen.dynamicanalyzer.common.AnalyzerConstants; diff --git a/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/file/data/FileAccessorDBTest.java b/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/file/data/FileAccessorDBTest.java index 80fd771..e310cb9 100644 --- a/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/file/data/FileAccessorDBTest.java +++ b/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/file/data/FileAccessorDBTest.java @@ -1,6 +1,6 @@ package org.tizen.dynamicanalyzer.ui.file.data; -import static org.junit.Assert.*; +import static org.junit.Assert.assertEquals; import java.io.File; import java.text.SimpleDateFormat; @@ -13,7 +13,6 @@ import org.junit.Test; import org.tizen.dynamicanalyzer.common.AnalyzerConstants; import org.tizen.dynamicanalyzer.database.DBTableRegistry; import org.tizen.dynamicanalyzer.database.SqlConnectionManager; -import org.tizen.dynamicanalyzer.ui.file.model.FileAccess; import org.tizen.dynamicanalyzer.ui.file.model.FileAccessor; public class FileAccessorDBTest { diff --git a/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/file/data/FileApiDBTest.java b/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/file/data/FileApiDBTest.java index 7f2d652..ee35993 100644 --- a/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/file/data/FileApiDBTest.java +++ b/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/file/data/FileApiDBTest.java @@ -1,6 +1,6 @@ package org.tizen.dynamicanalyzer.ui.file.data; -import static org.junit.Assert.*; +import static org.junit.Assert.assertEquals; import java.io.File; import java.sql.ResultSet; @@ -12,7 +12,6 @@ import java.util.List; import org.junit.AfterClass; import org.junit.BeforeClass; -import org.junit.Ignore; import org.junit.Test; import org.tizen.dynamicanalyzer.common.AnalyzerConstants; import org.tizen.dynamicanalyzer.database.DBTableRegistry; diff --git a/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/file/data/FileStatusDBTest.java b/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/file/data/FileStatusDBTest.java index 7dda45f..8949b4b 100644 --- a/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/file/data/FileStatusDBTest.java +++ b/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/file/data/FileStatusDBTest.java @@ -1,6 +1,6 @@ package org.tizen.dynamicanalyzer.ui.file.data; -import static org.junit.Assert.*; +import static org.junit.Assert.assertEquals; import java.io.File; import java.text.SimpleDateFormat; @@ -13,7 +13,6 @@ import org.junit.Test; import org.tizen.dynamicanalyzer.common.AnalyzerConstants; import org.tizen.dynamicanalyzer.database.DBTableRegistry; import org.tizen.dynamicanalyzer.database.SqlConnectionManager; -import org.tizen.dynamicanalyzer.ui.file.model.FileAccess; import org.tizen.dynamicanalyzer.ui.file.model.FileStatus; public class FileStatusDBTest { diff --git a/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/file/manager/FileDataMakerTest.java b/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/file/manager/FileDataMakerTest.java index d52405a..af335cd 100644 --- a/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/file/manager/FileDataMakerTest.java +++ b/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/file/manager/FileDataMakerTest.java @@ -1,6 +1,6 @@ package org.tizen.dynamicanalyzer.ui.file.manager; -import static org.junit.Assert.*; +import static org.junit.Assert.assertTrue; import java.io.File; import java.text.SimpleDateFormat; diff --git a/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/utils/AnalyzerUtilTest.java b/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/utils/AnalyzerUtilTest.java index 1a02b9d..461e2ec 100644 --- a/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/utils/AnalyzerUtilTest.java +++ b/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/utils/AnalyzerUtilTest.java @@ -27,7 +27,7 @@ package org.tizen.dynamicanalyzer.utils; -import static org.junit.Assert.*; +import static org.junit.Assert.fail; import org.junit.Test;