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
--- /dev/null
+/**
+ *
+ */
+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 {
+
+}
--- /dev/null
+/**
+ *
+ */
+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 {
+}
// 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;
}
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 {
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 {
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;
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 {
}
}
+ @UIMethod
public static ViewPart getViewPart(String id) {
ViewPart viewpart = null;
IWorkbenchWindow window = getWorkbenchWindow();
commandId="org.tizen.dynamicanalyzer.handlers.OpenTraceHandler">
</handler>
<handler
- class="org.tizen.dynamicanalyzer.handlers.ReplayTraceHandler"
+ class="org.tizen.dynamicanalyzer.handlers.ReplayManager"
commandId="org.tizen.dynamicanalyzer.handlers.ReplayTraceHandler">
</handler>
<handler
public static final String FAILED_DATA_TABLE_NAME = "FailedData"; //$NON-NLS-1$
/* thread names */
- public static final String LOG_QUEUE_OBSERVING_THREAD = "Log parser thread"; //$NON-NLS-1$
+ public static final String SIDEWORKER_THREAD = "Side worker thread"; //$NON-NLS-1$
public static final String COMMUNICATOR_RECEIVE_THREAD = "Data channel recv thread"; //$NON-NLS-1$
+ public static final String MESSAGE_PARSER_THREAD = "Message parsing thread"; //$NON-NLS-1$
+ public static final String LOG_QUEUE_OBSERVING_THREAD = "Log parsing thread"; //$NON-NLS-1$
public static final String MESSAGE_INTERNAL_IMAGE_THREAD = "Internal Image Process Thread"; //$NON-NLS-1$
public static final String STOP_LOG_THREAD = "Stop Log Thread"; //$NON-NLS-1$
public static final String BATTERY_RECEIVE_THREAD = "Battery Receive Thread"; //$NON-NLS-1$
/* thread constant */
public static final int THREAD_JOIN_WAIT_TIME = 5000;
public static final int INSERT_JOIN_WAIT_TIME = 30000;
-
+
+ /* timeout value */
+ public static final int DATA_SOCKET_TIMEOUT_NORMAL = 10000; // 10 second
+ public static final int DATA_SOCKET_TIMEOUT_TERMINATE = 3000; // 3 second
+ public static final int DATA_SOCKET_TIMEOUT_CLEAR = 10; // 10 ms
+ public static final int CONTROL_SOCKET_TIMEOUT = 10000; // 10 second
+
/* timer intervals */
- public static final int SOCKET_CHECK_INTERVAL = 10;
- public static final int DATA_SOCKET_TIMEOUT = 50000;
- public static final int CONTROL_SOCKET_TIMEOUT = 10000;
public static final int PROC_ADD_INFO_TIMEOUT = 1000;
public static final int SOCKET_FORWARD_INTERVAL = 1000;
package org.tizen.dynamicanalyzer.common;
-import java.io.File;
-import java.util.Map;
-import java.util.Timer;
-import java.util.concurrent.ConcurrentHashMap;
-
-import org.tizen.dynamicanalyzer.handlers.ClearHandler;
-import org.tizen.dynamicanalyzer.handlers.StartHandler;
+import org.tizen.dynamicanalyzer.annotation.FutureUse;
+import org.tizen.dynamicanalyzer.annotation.UIMethod;
import org.tizen.dynamicanalyzer.project.Project;
import org.tizen.dynamicanalyzer.swap.callstack.BaseCallstackManager;
import org.tizen.dynamicanalyzer.swap.callstack.SWAPCallStackManager;
-import org.tizen.dynamicanalyzer.swap.model.data.LogDataFactory;
-import org.tizen.dynamicanalyzer.ui.info.screenshot.ScreenshotTimerTask;
import org.tizen.dynamicanalyzer.ui.opengl.data.type.GLSelectionData;
import org.tizen.dynamicanalyzer.ui.page.BaseView;
import org.tizen.dynamicanalyzer.ui.range.RangeDataManager;
import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler;
import org.tizen.dynamicanalyzer.ui.summary.profiling.ProfilingData;
import org.tizen.dynamicanalyzer.ui.summary.warning.WarningChecker;
-import org.tizen.dynamicanalyzer.ui.toolbar.StopProcessManager;
-import org.tizen.dynamicanalyzer.ui.toolbar.setting.data.SettingConstants;
-import org.tizen.dynamicanalyzer.ui.toolbar.setting.data.SettingDataManager;
-import org.tizen.dynamicanalyzer.util.Logger;
import org.tizen.dynamicanalyzer.util.WorkbenchUtil;
-import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
import org.tizen.dynamicanalyzer.widgets.da.view.DABaseComposite;
import org.tizen.dynamicanalyzer.widgets.da.view.DAPageComposite;
public class AnalyzerManager {
- private static boolean isRunning = false;
- private static boolean isLogParsingComplete = false;
+ public static final Object waitStartAck = new Object();
+
+ private static boolean isPlatformSDK = false;
- private static ConcurrentHashMap<Integer, ConcurrentHashMap<Long, Integer>> 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() {
}
}
- // 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<Long, Integer> getFuncIDMapByPid(int pid) {
- if (funcIDMapByPid == null) {
- synchronized (AnalyzerManager.class) {
- if (funcIDMapByPid == null) {
- funcIDMapByPid = new ConcurrentHashMap<Integer, ConcurrentHashMap<Long, Integer>>();
- }
- }
- }
- ConcurrentHashMap<Long, Integer> funcIDMap = funcIDMapByPid.get(pid);
- if (funcIDMap == null) {
- funcIDMap = new ConcurrentHashMap<Long, Integer>();
- 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;
- }
- }
}
public void start(BundleContext context) throws Exception {\r
super.start(context);\r
plugin = this;\r
- \r
+\r
// check for platform sdk\r
- Global.setPlatformSDK(PathManager.checkPlatformPlugin());\r
+ AnalyzerManager.setPlatformSDK(PathManager.checkPlatformPlugin());\r
\r
// Adds workbench listener.\r
IWorkbench workbench = PlatformUI.getWorkbench();\r
public void postShutdown(IWorkbench workbench) {\r
// close db connection\r
SqlConnectionManager.closeConnection();\r
- \r
+\r
File tempDir = new File(PathManager.DA_TEMP_FOLDER_PATH);\r
if (tempDir.isDirectory() && tempDir.exists()) {\r
if (AnalyzerUtil.deleteFile(tempDir)) {\r
Logger.debug("BUG: temp folder is already exists but failed to delete");\r
}\r
}\r
- \r
+\r
// if temp save folder does not exist or not a directory\r
if (!saveFolder.isDirectory()) {\r
if (!saveFolder.mkdirs()) {\r
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());
warning.setIcon(ImageResources.DIALOG_WARNING_ICON);
warning.open();
- ToolbarArea.getInstance().setToolbarStartStopState(true);
+ ToolbarArea.getInstance().setAllControlState(true);
}
});
Logger.debug("invalid application name :" + appid);
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;
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() {
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;
// 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;
}
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";
+ }
+ }
}
}
/**
- * 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
*/
// TODO: remove unnecessary code
public static int getFuncId(ProfileData input, long address, int pid, long time) {
- Map<Long, Integer> 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()) {
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;
}
}
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;
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);
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;
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;
}
}
- 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) {
@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)
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) {
updateToolbarDevice();
}
}
- if (null != Global.getCurrentDeviceInfo() && null != Global.getCurrentApplication()) {
- Display.getDefault().syncExec(new Runnable() {
- @Override
- public void run() {
- ToolbarArea.getInstance().setStartButtonEnablement(true);
- }
- });
- }
}
};
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());
Global.setCurrentDeviceInfo(device);
if (device == null) {
popupMessage(UserErrorWarningLabels.ERROR_DEVICE_CONNECTION);
- ToolbarArea.getInstance().setToolbarStartStopState(true);
+ ToolbarArea.getInstance().setAllControlState(true);
return;
}
if (pkgInfo == null) {
popupMessageWithAppname(binaryOfTarget,
UserErrorWarningLabels.ERROR_NONEXIST_APPLICATION);
- ToolbarArea.getInstance().setToolbarStartStopState(true);
+ ToolbarArea.getInstance().setAllControlState(true);
return;
}
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;
}
if (errormsg != null) {
Logger.error("error during binary setting wit rpm");
popupMessage(errormsg);
- ToolbarArea.getInstance().setToolbarStartStopState(true);
+ ToolbarArea.getInstance().setAllControlState(true);
return;
}
if (pkgInfo == null) {
popupMessageWithAppname(appID,
UserErrorWarningLabels.ERROR_NONEXIST_APPLICATION);
- ToolbarArea.getInstance().setToolbarStartStopState(true);
+ ToolbarArea.getInstance().setAllControlState(true);
return;
}
} else {
popupMessage(UserErrorWarningLabels.ERROR_LIBTRACE_START
+ CommonConstants.NEW_LINE
+ UserErrorWarningLabels.ERROR_NO_APPID_FOR_LAUNCHPAD);
- ToolbarArea.getInstance().setToolbarStartStopState(true);
+ ToolbarArea.getInstance().setAllControlState(true);
return;
}
} else {
// TODO : get appInfo from executable path
popupMessageWithAppname(executablePath,
UserErrorWarningLabels.ERROR_UNSUPPORTED_APPLICATION);
- ToolbarArea.getInstance().setToolbarStartStopState(true);
+ ToolbarArea.getInstance().setAllControlState(true);
}
if (pkgInfo != null) {
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;
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;
* Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
*
* Contact:
- * Jungwook Ryu <jungwook.ryu@samsung.com>
+ * Jaewon Lim <jaewon81.lim@samsung.com>
* Juyoung Kim <j0.kim@samsung.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
*
*/
-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;
+
}
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Jaewon Lim <jaewon81.lim@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+
+package org.tizen.dynamicanalyzer.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<STAGE, Integer> accumMap = new EnumMap<STAGE, Integer>(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<STAGE, Integer> progressMap = phase.accumMap;
+ Integer accumVal = progressMap.get(stage);
+ if (accumVal != null) {
+ return accumVal.intValue() * 100 / progressMap.get(STAGE.FINAL).intValue();
+ } else {
+ return 0;
+ }
+ }
+}
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Jaewon Lim <jaewon81.lim@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+
+package org.tizen.dynamicanalyzer.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<Runnable> workQueue = new LinkedBlockingQueue<Runnable>();
+
+ 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");
+ }
+}
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() {
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();
+ }
+ });
}
}
--- /dev/null
+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();
+ }
+ });
+ }
+}
+++ /dev/null
-/*
- * Dynamic Analyzer
- *
- * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * Jaewon Lim <jaewon81.lim@samsung.com>
- * Juyoung Kim <j0.kim@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-
-package org.tizen.dynamicanalyzer.database;
-
-import java.util.HashMap;
-import java.util.Map;
-
-public class DBInsertManager {
- private static Map<String, DBInserter> insertThreads = new HashMap<String, DBInserter>();
-
- 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<String, DBInserter> entry : insertThreads.entrySet()) {
- DBInserter inserter = entry.getValue();
- inserter.startThread();
- }
- }
-
- public static void stopInserters() {
- for (Map.Entry<String, DBInserter> entry : insertThreads.entrySet()) {
- DBInserter thread = entry.getValue();
- thread.stopThread();
- }
- }
-
- public static DBInserter getInserter(String tablename) {
- return insertThreads.get(tablename);
- }
-}
import java.util.List;
import java.util.concurrent.LinkedBlockingQueue;
-import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
-
public class DBInserter implements Runnable {
- private static List<List<Object>> END_OF_QUEUE = new ArrayList<List<Object>>();
+ public static List<List<Object>> END_OF_QUEUE = new ArrayList<List<Object>>();
private LinkedBlockingQueue<List<List<Object>>> dataQueue = new LinkedBlockingQueue<List<List<Object>>>();
private DBTable table = null;
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();
public abstract class DBTable implements IPreparedStatement, IResultSet {
private List<DBColumn> columns = new ArrayList<DBColumn>();
+ protected DBInserter dbInserter = null;
// instance initializing block
{
return columns.size();
}
+ public final void setDBInserter(DBInserter inserter) {
+ dbInserter = inserter;
+ }
+
protected final void addColumn(DBColumn col) {
columns.add(col);
}
+++ /dev/null
-/*
- * Dynamic Analyzer
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * Jaewon Lim <jaewon81.lim@samsung.com>
- * Juyoung Kim <j0.kim@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-
-package org.tizen.dynamicanalyzer.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;
- }
-
-}
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();
}
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();
+ }
+
}
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() {
return ret;
}
-
+
/**
* check current device is valid for tracing or not
+ *
* @return true if device is connected normally, false otherwise
*/
public static boolean checkDeviceValidness() {
/**
* check current application is valid for tracing or not
+ *
* @return true if application is valid, false otherwise
*/
public static boolean checkApplicatinValidness() {
/**
* check configuration is performed with target or not
+ *
* @return true if configuration to target is done, false otherwise
*/
public static boolean checkConfiguration() {
} 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();
+ }
+ });
+ }
}
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 {
@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;
}
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;
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();
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;
}
DACustomCombo appCombo = ToolbarArea.getInstance().getAppCombo();
deviceCombo.setText(Global.getProject().getDevice());
appCombo.setText(Global.getProject().getAppName());
- deviceCombo.setEnabled(true);
- appCombo.setEnabled(true);
}
});
}
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);
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;
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();
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;
+ }
}
+++ /dev/null
-/*
- * Dynamic Analyzer
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * Jaewon Lim <jaewon81.lim@samsung.com>
- * Jooyoul Lee <jy.exe.lee@samsung.com>
- * Juyoung Kim <j0.kim@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-
-package org.tizen.dynamicanalyzer.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;
- }
-
-}
*
* Contact:
* Jaewon Lim <jaewon81.lim@samsung.com>
- * Jooyoul Lee <jy.exe.lee@samsung.com>
* Juyoung Kim <j0.kim@samsung.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
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;
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);
+ }
+ });
}
}
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;
Logger.performance("TEST", "DA Start", "Target Binary Setting");
IDECommunicator.startIDECommunicatorThread();
+ SideWorker.start();
Logger.performance("TEST", "DA Start", "Start IDE Communicator");
SettingDataManager.getInstance();
ExecutionCallbackManager.WINDOWADVISOR_PREWINDOWCLOSE,
new PreWindowShellCloseCallback());
+ Global.setCurrentState(STATE.INIT);
init = true;
}
}
// return;
// }
- switch (data.getId()) {
+ switch (data.getMsgID()) {
case DataChannelConstants.MSG_PROBE_FILE:
pageId = FilePage.pageID;
break;
}
public void handleEvent(Event event) {
- if (!ToolbarArea.getInstance().getSourceViewEnable()) {
+ if (!ToolbarArea.getInstance().getButtonEnabled(ToolbarArea.SOURCE_BUTTON)) {
return;
}
break;
case AnalyzerConstants.TYPE_TABLE_CALLTRACE:
List<Object> 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;
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 {
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);
}
break;
case AnalyzerConstants.TYPE_TABLE_CALLTRACE:
List<Object> 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
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()) {
+++ /dev/null
-/*
- * Dynamic Analyzer
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * Jaewon Lim <jaewon81.lim@samsung.com>
- * Jooyoul Lee <jy.exe.lee@samsung.com>
- * Juyoung Kim <j0.kim@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-
-package org.tizen.dynamicanalyzer.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<LogPackage> logs = null;
-
- private List<LogPackage> getLogs() {
- if (null == logs) {
- logs = new ArrayList<LogPackage>();
- }
- 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();
- }
-}
+++ /dev/null
-/*
- * Dynamic Analyzer
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * Jaewon Lim <jaewon81.lim@samsung.com>
- * Jooyoul Lee <jy.exe.lee@samsung.com>
- * Juyoung Kim <j0.kim@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-
-package org.tizen.dynamicanalyzer.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<List<LogData>> data = null;
-
- public LogListQueue() {
- data = new ArrayList<List<LogData>>();
- }
-
- public synchronized List<LogData> getFirst() {
- while (isEmpty()) {
- if (AnalyzerManager.isLogParsingComplete()) {
- return null;
- }
- try {
- wait();
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- List<LogData> output = data.get(0);
- data.remove(0);
- notifyAll();
- return output;
- }
-
- public synchronized void putLog(List<LogData> input) {
- while (isFull()) {
- try {
- wait();
- } catch (InterruptedException e) {
- e.printStackTrace();
- break;
- }
- }
- data.add(input);
- notifyAll();
- }
-
- public boolean isEmpty() {
- if (null == data) {
- data = new ArrayList<List<LogData>>();
- }
- return data.isEmpty();
- }
-
- private boolean isFull() {
- if (size() > 10000) {
- return true;
- }
- return false;
- }
-
- public int size() {
- return data.size();
- }
-
- public void clear() {
- data.clear();
- }
-}
+++ /dev/null
-/*
- * Dynamic Analyzer
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * Jaewon Lim <jaewon81.lim@samsung.com>
- * Jooyoul Lee <jy.exe.lee@samsung.com>
- * Juyoung Kim <j0.kim@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-
-package org.tizen.dynamicanalyzer.logparser;
-
-import java.util.HashMap;
-import java.util.List;
-
-
-public class LogPackage {
- private HashMap<Integer, Logs> logMap;
-
- public void clear()
- {
- getLogMap().clear();
- }
-
- public LogPackage() {
- logMap = new HashMap<Integer, Logs>();
- }
-
- private HashMap<Integer, Logs> getLogMap()
- {
- if (null == logMap)
- {
- logMap = new HashMap<Integer, Logs>();
- }
- return logMap;
- }
- public boolean isEmpty()
- {
- return getLogMap().isEmpty();
- }
-
- public void setLogs(int id, List<String> 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());
- }
- }
- }
-}
+++ /dev/null
-/*
- * Dynamic Analyzer
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * Jaewon Lim <jaewon81.lim@samsung.com>
- * Jooyoul Lee <jy.exe.lee@samsung.com>
- * Juyoung Kim <j0.kim@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-
-package org.tizen.dynamicanalyzer.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<List<String>> data = null;
-
- public LogQueue() {
- data = new ArrayList<List<String>>();
- }
-
- public synchronized List<String> getFirst() {
- while (isEmpty()) {
- try {
- if (!AnalyzerManager.isRunning()) {
- return null;
- }
- wait();
- } catch (InterruptedException e) {
- Logger.debug("log queue interrupt!!"); //$NON-NLS-1$
- continue;
- }
- }
-
- List<String> output = data.get(0);
- data.remove(0);
- notifyAll();
- return output;
- }
-
- public synchronized void putLog(List<String> 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<List<String>>();
- }
- 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();
- }
-}
+++ /dev/null
-/*
- * Dynamic Analyzer
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * Jaewon Lim <jaewon81.lim@samsung.com>
- * Jooyoul Lee <jy.exe.lee@samsung.com>
- * Juyoung Kim <j0.kim@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-
-package org.tizen.dynamicanalyzer.logparser;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public class Logs {
- private List<List<String>> logs;
- int logCenterId;
-
- public Logs(int id) {
- logs = new ArrayList<List<String>>();
- logCenterId = id;
- }
-
- public int getId() {
- return logCenterId;
- }
-
- // getLogs -> getRawLogs
- public List<List<String>> getLogs() {
- if (null == logs) {
- logs = new ArrayList<List<String>>();
- }
- return logs;
- }
-
- public void setLogs(List<List<String>> input) {
- logs = input;
- }
-
- public void setLogCenterId(int id) {
- logCenterId = id;
- }
-
- // cloneLogs -> getLogs
- public List<List<String>> getCloneLogs() {
- List<List<String>> newLogs = new ArrayList<List<String>>();
- int size = logs.size();
- for (int i = 0; i < size; i++) {
- List<String> newLog = new ArrayList<String>();
- newLog.addAll(logs.get(i));
- newLogs.add(newLog);
- }
- return newLogs;
- }
-}
+++ /dev/null
-/*
- * Dynamic Analyzer
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * Jaewon Lim <jaewon81.lim@samsung.com>
- * Juyoung Kim <j0.kim@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-
-package org.tizen.dynamicanalyzer.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;
- }
-}
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;
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);
}
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
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;
private NavigableMap<Long, ProcessMemoryMap> processMemSnapshots = new TreeMap<Long, ProcessMemoryMap>();
private boolean isMapping = true;
+ // not saved data
+ // temporary function address-id map
+ private Map<Long, Integer> funcIDMap = null;
+
public int getPid() {
return pid;
}
return isMapping;
}
+ private Map<Long, Integer> getFuncIDMap() {
+ if (funcIDMap == null) {
+ synchronized (this) {
+ if (funcIDMap == null) {
+ funcIDMap = new ConcurrentHashMap<Long, Integer>();
+ }
+ }
+ }
+
+ 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<Long, ProcessMemoryMap> entry : processMemSnapshots.entrySet()) {
entry.getValue().saveMemoryMap(table);
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;
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;
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<Long, ImageInfo> imageInfos = new TreeMap<Long, ImageInfo>();
-
- private int seqRotation = -1;
+
+ private int seqRotation = 0;
+ private int activeProcessCount = 0;
static {
// register DB table
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) {
}
}
- // 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 {
}
}
}
+ 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;
List<String> 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);
bv.addTabViewPage(list[i]);
}
}
-
+
private void openTargetStatusInfo(BufferedReader in) throws IOException {
String content = in.readLine();
if (content != null && content.equals(DEVICE_SECTION)) {
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;
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;
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) {
// 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();
}
}
dialog.open();
}
}
-
+
return null;
-
- }
+
+ }
}
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;
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));
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));
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;
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;
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;
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;
}
@Override
- public DAResult startTrace() {
+ public DAResult startTrace(IProgress progress) throws InterruptedException {
DeviceInfo curDev = Global.getCurrentDeviceInfo();
if (curDev == null) {
return DAResult.ERR_DEVICE_IS_NULL;
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);
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);
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
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);
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);
if (result.isSuccess()) {
device.setDataSock(dataSock);
+ AnalyzerManager.setDataSocketClosed(false);
}
return result;
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);
*/
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);
+ }
+ });
+ }
}
}
}
- public static void stopThreads() {
+ public static void stopThreadsNormal() {
for (Map.Entry<String, PageDataManager> entry : dataManagers.entrySet()) {
- entry.getValue().stopThread();
+ entry.getValue().stopNormal();
+ }
+ }
+
+ public static void stopThreadsForced() {
+ for (Map.Entry<String, PageDataManager> entry : dataManagers.entrySet()) {
+ entry.getValue().stopForced();
}
}
--- /dev/null
+package org.tizen.dynamicanalyzer.swap.logparser;
+
+import java.util.ArrayList;
+
+import org.tizen.dynamicanalyzer.swap.model.data.LogData;
+
+public class LogList extends ArrayList<LogData> {
+
+ public static final LogList END_OF_QUEUE = new LogList();
+
+ /**
+ * default serial number
+ */
+ private static final long serialVersionUID = 1L;
+
+}
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<Integer, Logs> logMap;
public void clear() {
*/
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;
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<LogList> queue = new LinkedBlockingQueue<LogList>();
// map for matching exit log with entry log
- private static Map<Integer, List<Long>> functionEntryStackByTidMap = new HashMap<Integer, List<Long>>();
+ private Map<Integer, Deque<Long>> functionEntryStackByTidMap = new HashMap<Integer, Deque<Long>>();
private int SMALL_IMG_WIDTH = 40;
private int SMALL_IMG_HEIGHT = 66;
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<Long> getFunctionEntryStack(int tid) {
- List<Long> functionEntryStack = functionEntryStackByTidMap.get(tid);
- if (null == functionEntryStack) {
- functionEntryStack = new ArrayList<Long>();
- 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<Long> getFunctionEntryStack(int tid) {
+ Deque<Long> functionEntryStack = functionEntryStackByTidMap.get(tid);
+ if (null == functionEntryStack) {
+ functionEntryStack = new ArrayDeque<Long>();
+ functionEntryStackByTidMap.put(tid, functionEntryStack);
+ }
+ return functionEntryStack;
}
/*** log parsing thread ***/
@Override
public void run() {
- AnalyzerManager.setLogParsingComplete(false);
- LogQueue logQueue = getLogQueue();
- while (!AnalyzerManager.isExit()) {
- List<LogData> 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<LogData> 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<Long> 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 : <unknown function> check with apiId
- if (apiId == -1 || apiName.equals("<unknown function>")) {
- 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<Long> 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 : <unknown function> check with apiId
+ if (apiID == AnalyzerConstants.INVALID_INDEX || apiName.equals("<unknown function>")) {
+ 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
}
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);
}
}
+++ /dev/null
-/*
- * Dynamic Analyzer
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * Jaewon Lim <jaewon81.lim@samsung.com>
- * Jooyoul Lee <jy.exe.lee@samsung.com>
- * Juyoung Kim <j0.kim@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-
-package org.tizen.dynamicanalyzer.swap.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<List<LogData>> data = null;
- private static boolean isFull = false;
-
- public LogQueue() {
- data = new ArrayList<List<LogData>>();
- }
-
- public synchronized List<LogData> getFirst() {
- while (isEmpty()) {
- try {
- if (!AnalyzerManager.isRunning()) {
- return null;
- }
- wait();
- } catch (InterruptedException e) {
- Logger.debug("log queue interrupt!!"); //$NON-NLS-1$
- continue;
- }
- }
-
- List<LogData> output = data.get(0);
- data.remove(0);
- if (data.size() < HALF_COUNT) {
- isFull = false;
- notifyAll();
- }
- return output;
- }
-
- public synchronized void putLog(List<LogData> 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<List<LogData>>();
- }
- return data.isEmpty();
- }
-
- public boolean isFull() {
- return isFull;
- }
-
- public synchronized int size() {
- return data.size();
- }
-
- public void clear() {
- data.clear();
- }
-}
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<LogData> queue = new LinkedBlockingQueue<LogData>();
+ 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<LogData> buffer = new ArrayList<LogData>();
- 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<LogData>();
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);
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);
}
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);
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);
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);
}
}
- 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/<pid>/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/<pid>/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;
- }
}
*/
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<LogPackage> logPackQueue = new LinkedBlockingQueue<LogPackage>();
-
- private enum State {
- NOT_RUNNING, RUNNING, TO_BE_STOPED
- }
-
- private State state = State.NOT_RUNNING;
+ private Map<String, DBInserter> insertThreads = new HashMap<String, DBInserter>();
public final String getName() {
if (name == null) {
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() {
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<String, DBInserter> entry : insertThreads.entrySet()) {
+ DBInserter inserter = entry.getValue();
+ inserter.start();
+ }
+ }
+
+ private final void stopInsertersNormal() {
+ for (Map.Entry<String, DBInserter> entry : insertThreads.entrySet()) {
+ DBInserter thread = entry.getValue();
+ thread.stopNormal();
+ }
+ }
+
+ private final void stopInsertersForced() {
+ for (Map.Entry<String, DBInserter> entry : insertThreads.entrySet()) {
+ DBInserter thread = entry.getValue();
+ thread.stopForced();
+ }
+ }
+
+ private final void setToStopInserter() {
+ for (Map.Entry<String, DBInserter> 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);
onThreadStop();
+ setToStopInserter();
+
+ clearAll();
+
/* log for debug */
Logger.debug(getName() + " thread end!!"); //$NON-NLS-1$
}
*/
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;
}
}
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;
+ // }
+ //
}
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;
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;
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 {
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;
}
*/
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;
}
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 {
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;
}
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));
}
}
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;
}
+++ /dev/null
-/*
- * Dynamic Analyzer
- *
- * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * Jungwook Ryu <jungwook.ryu@samsung.com>
- * Jooyoul Lee <jy.exe.lee@samsung.com>
- * Juyoung Kim <j0.kim@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-package org.tizen.dynamicanalyzer.swap.model.data;
-
-public class LifeCycleData extends ProbeCommonData {
-
- public LifeCycleData() {
- }
-}
*/
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() {
}
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;
}
}
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<Integer> logIDList = new ArrayList<Integer>();
- private LogDataFactory() {
- // is static class
- }
-
public static List<Integer> getLogIDList() {
if (logIDList.isEmpty()) {
initLogIDList();
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) {
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) {
}
return formatName;
}
-
- public static void clean() {
- }
}
import java.util.Comparator;
-public class LogDataSeqNoComparator implements Comparator<LogData> {
+public class LogDataSeqComparator implements Comparator<LogData> {
@Override
public int compare(LogData arg0, LogData arg1) {
}
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;
- }
}
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;
}
@Override
public int getKey() {
- Long key = getAddress();
- return key.hashCode();
+ return (int) (address ^ (address >>> 32));
}
}
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;
}
public String getDestinationAddress() {
- return getdestinationIPAddress() + CommonConstants.NEW_LINE
- + getDestinationPortAddress();
+ return getdestinationIPAddress() + CommonConstants.NEW_LINE + getDestinationPortAddress();
}
public void setFdApiType(int fdApiType) {
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));
}
}
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;
protected int reserved1 = 0;
protected int reserved2 = 0;
+ protected String libName = null;
private String apiName = null;
public ProbeCommonData() {
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;
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;
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() {
public String getApiName() {
if (null == apiName) {
- apiName = Global.getFunctionName(apiId);
+ apiName = Global.getFunctionName(apiID);
}
return apiName;
}
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;
/** 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;
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;
}
public void setEntrySeq(long seq) {
this.entrySeq = seq;
}
-
+
public int getBuildType() {
return buildType;
}
}
public boolean isPieBuild() {
- if (buildType == 1) {
- return true;
- }
- return false;
+ return (buildType == 1);
}
public int getBinaryId() {
public void setBinaryPath(int binaryId) {
this.binaryId = binaryId;
}
-
- public String getLibName() {
- return libName;
- }
-
- public void setLibName(String libName) {
- this.libName = libName;
- }
-
}
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<RecordEventObject> recordEvent = new ArrayList<RecordEventObject>();
-
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;
public int getPid() {
return 0;
}
-
}
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;
}
*/
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;
}
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;
}
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,
VIDEO,
CALL
}
-
+
String cpuFrequency = null;
String cpuLoad = null;
long systemMemoryUsed = 0;
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);
}
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(',');
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(',');
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;
}
}
return processProfileDataList;
}
- public void setProcessProfileDataList(
- ProcessProfileData[] processProfileDataList) {
+ public void setProcessProfileDataList(ProcessProfileData[] processProfileDataList) {
this.processProfileDataList = processProfileDataList;
}
public void setOtherProcessLoad(String otherProcessLoad) {
this.otherProcessLoad = otherProcessLoad;
}
-
+
@Override
public int getPid() {
return 0;
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;
}
public String getClassName() {
return className;
}
-
+
public void setClassName(String className) {
this.className = className;
}
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;
}
public void setInfo2(int info2) {
this.info2 = info2;
}
-
- private int logNum = 0;
-
- @Override
- public int getLogNum() {
- return logNum++;
- }
}
+++ /dev/null
-/*
- * Dynamic Analyzer
- *
- * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * Jungwook Ryu <jungwook.ryu@samsung.com>
- * Jooyoul Lee <jy.exe.lee@samsung.com>
- * Juyoung Kim <j0.kim@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-package org.tizen.dynamicanalyzer.swap.model.data;
-
-public class WindowingTableData extends LogData {
- public WindowingTableData() {
- }
- @Override
- public int getPid() {
- return 0;
- }
-
-}
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;
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;
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();
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;
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() {
return tid;
}
- public void setSeq(long seqNo) {
- this.seq = seqNo;
- }
-
public long getFileSize() {
return fileSize;
}
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;
private ScreenshotDataManager() {
lastCpuRate = new ArrayList<Long>();
screenShotDBTable = new ScreenShotDBTable();
- screenShotDBInserter = DBInsertManager.makeInserter(screenShotDBTable);
+ screenShotDBInserter = makeInserter(screenShotDBTable);
}
public synchronized static ScreenshotDataManager getInstance() {
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Jungwook Ryu <jungwook.ryu@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+
+package org.tizen.dynamicanalyzer.ui.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();
+ }
+}
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;
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();
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;
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);
}
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());
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;
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;
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;
return topComposite;
}
+ @UIMethod
public void clear() {
tabView.clear();
}
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
}
ProfileDataMaker profileDataMaker = getProfileDataMakerByPid(top.getPid());
- switch (top.getId()) {
+ switch (top.getMsgID()) {
case DataChannelConstants.MSG_FUNCTION_ENTRY:
if (rsEntry.next()) {
ProfileData pEntry = makeFunctionProfileData(
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;
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);
}
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);
}
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);
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);
private String libName = null;
public FailedData(LogData log) {
- id = log.getId();
+ id = log.getMsgID();
seq = log.getSeq();
time = log.getTime();
ProbeCommonData plog = ((ProbeCommonData) log);
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;
public void makeAllocData(LogData log) {
ArrayList<Object> dbAllocData = new ArrayList<Object>();
- switch (log.getId()) {
+ switch (log.getMsgID()) {
case DataChannelConstants.MSG_PROBE_MEMORY: {
MemoryData mData = (MemoryData) log;
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;
public void makeFreeData(LogData log) {
ArrayList<Object> dbFreeData = new ArrayList<Object>();
- 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;
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)) {
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);
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);
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;
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();
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()));
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()));
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));
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;
}
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();
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
+ 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;
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<SyncData> insertSyncAPIList) {
}
insertData.add(insertRowData);
}
- if (insertData.size() > 0) {
+ if (insertData.size() > 0 && dbInserter != null) {
dbInserter.pushData(insertData);
}
}
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;
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
+ " 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;
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<List<Object>> getSyncDataFromDB() {
e.printStackTrace();
}
}
- if (insertData.size() > 0) {
+ if (insertData.size() > 0 && dbInserter != null) {
dbInserter.pushData(insertData);
}
}
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
+ 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;
addColumn(new DBColumn(COLUMN.BLOCKENDTIME.name, DBConstants.NOT_NULL,
DBConstants.DBTYPE_LONG));
setIndexColumn(COLUMN.SYNCDATAID.index);
-
- dbInserter = DBInsertManager.makeInserter(this);
}
public List<List<Object>> getSyncEventFromDB() {
}
insertData.add(insertRowData);
}
- if (DACommunicator.isRunning()) {
+ if (DACommunicator.isRunning() && dbInserter != null) {
dbInserter.pushData(insertData);
} else {
insertData(insertData);
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
+ " 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;
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<List<Object>> getThreadAPIFromDB() {
if (apiData.size() == 0) {
return;
}
- if (DACommunicator.isRunning()) {
+ if (DACommunicator.isRunning() && dbInserter != null) {
dbInserter.pushData(apiData);
} else {
insertData(apiData);
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
+ " 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;
DBConstants.DBTYPE_INT4));
addColumn(new DBColumn(COLUMN.CALLERID.name, DBConstants.EMPTY, DBConstants.DBTYPE_INT4));
setIndexColumn(COLUMN.THREADDATAID.index);
- dbInserter = DBInsertManager.makeInserter(this);
}
public List<List<Object>> getThreadEventFromDB() {
if (insertData.size() == 0) {
return;
}
- if (DACommunicator.isRunning()) {
+ if (DACommunicator.isRunning() && dbInserter != null) {
dbInserter.pushData(insertData);
} else {
insertData(insertData);
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;
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());
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;
+++ /dev/null
-/*
- * Dynamic Analyzer
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * Jaewon Lim <jaewon81.lim@samsung.com>
- * Juyoung Kim <j0.kim@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-
-package org.tizen.dynamicanalyzer.ui.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);
- }
-}
+++ /dev/null
-/*
- * Dynamic Analyzer
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * Jaewon Lim <jaewon81.lim@samsung.com>
- * Jooyoul Lee <jy.exe.lee@samsung.com>
- * Juyoung Kim <j0.kim@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-
-package org.tizen.dynamicanalyzer.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--;
- }
-}
+++ /dev/null
-/*
- * Dynamic Analyzer
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * Jaewon Lim <jaewon81.lim@samsung.com>
- * Jooyoul Lee <jy.exe.lee@samsung.com>
- * yeongtaik byeon <yeongtaik.byeon@samsung.com>
- * Juyoung Kim <j0.kim@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-package org.tizen.dynamicanalyzer.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;
- }
-}
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;
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;
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;
private static ToolbarArea coolbarArea;
- // Toolbar
+ // toolbar controls
private DACustomCombo deviceCombo;
private DACustomCombo appCombo;
-
private DACustomCombo processCombo;
-
- private HashMap<Integer, DACustomButton> buttons = new HashMap<Integer, DACustomButton>();
-
private DACustomButton startButton;
private TimerClock timerClock;
private DACustomButton saveTraceButton;
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<Integer, DACustomButton> buttons = new HashMap<Integer, DACustomButton>();
- 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) {
}
public static ToolbarArea getInstance() {
- if (null != coolbarArea) {
- return coolbarArea;
- } else {
- return null;
+ if (null == coolbarArea) {
+ createInstance(LayoutManager.getToolbarComposite());
}
+
+ return coolbarArea;
}
public DACustomCombo getDeviceCombo() {
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() {
if (newDevice != null && !newDevice.isEmpty()) {
DACommunicator.setSelectedDeviceBySerial(serial);
initAppCombo();
- setRepalyButtonEnable(true);
+ setReplayButtonState(true);
}
}
});
} else if (!serial.equals(oldDeviceName)) {
DACommunicator.setSelectedDeviceBySerial(serial);
initAppCombo();
- setRepalyButtonEnable(true);
+ setReplayButtonState(true);
}
}
}
if (enablestart && null != Global.getCurrentDeviceInfo()) {
setStartButtonState(true);
- setRepalyButtonEnable(true);
+ setReplayButtonState(true);
}
}
}
@Override
public void handleClickEvent(DACustomButton button) {
if (!AnalyzerManager.isRunning()) {
- if (AnalyzerUtil.executeCommand(ReplayTraceHandler.ID) != AnalyzerConstants.FAIL) {
+ if (ReplayManager.init()) {
startTrace();
}
}
});
}
- 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) {
});
}
- public TimerClock getTimer() {
- return timerClock;
- }
-
private void initAppCombo() {
String device = deviceCombo.getText();
if (device.isEmpty()) {
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<String> items) {
deviceCombo.select(0);
appCombo.initCombo();
appCombo.setEnabled(false);
- setRepalyButtonEnable(false);
- setStartButtonEnablement(false);
+ setReplayButtonState(false);
+ setStartButtonState(false);
return;
} else {
int size = items.size();
initAppCombo();
}
appCombo.setEnabled(true);
- setRepalyButtonEnable(true);
- setStartButtonEnablement(true);
- setSettingsButtonEnablement(true);
+ setReplayButtonState(true);
+ setStartButtonState(true);
+ configButton.setButtonEnabled(true);
}
}
}
- 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();
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<DeviceInfo> 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();
}
+
}
+++ /dev/null
-/*
- * Dynamic Analyzer
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * Jaewon Lim <jaewon81.lim@samsung.com>
- * Jooyoul Lee <jy.exe.lee@samsung.com>
- * Juyoung Kim <j0.kim@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-
-package org.tizen.dynamicanalyzer.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();
- }
-}
+++ /dev/null
-/*
- * Dynamic Analyzer
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * Jaewon Lim <jaewon81.lim@samsung.com>
- * Jooyoul Lee <jy.exe.lee@samsung.com>
- * Juyoung Kim <j0.kim@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-
-package org.tizen.dynamicanalyzer.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<LogData> 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<Integer> 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);
- }
-}
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;
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());
List<RecordEventObject> eventObjs = output.getRecordEvent();
for (List<Object> 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();
if (i == 0) {
itemData.setEventMouseDownTime(reo.getTime());
itemData.setStrEventType(setEventType(reo.getEventType()));
- itemData.setEventRid(reo.getId());
+ itemData.setEventRid(reo.getMsgID());
}
setItemDataValue(itemData, reo);
}
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;
tabView.addView(optionPage, false);
// check platform SDK (show binary setting page)
- if (Global.isPlatformSDK()) {
+ if (AnalyzerManager.isPlatformSDK()) {
createBinarySettingPage();
}
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 {
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 {
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;
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 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 {
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;
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;
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 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 {
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;
package org.tizen.dynamicanalyzer.utils;
-import static org.junit.Assert.*;
+import static org.junit.Assert.fail;
import org.junit.Test;
projects / sdk / tools / dynamic-analyzer.git / commitdiff