public static final String SEND_MESSAGE_THREAD = "Send message thread"; //$NON-NLS-1$\r
public static final String START_STOP_THREAD = "Start stop thread"; //$NON-NLS-1$\r
public static final String FILE_CHART_MANAGER_THREAD = "File Chart Manager thread"; //$NON-NLS-1$\r
- public static final String USER_INTERFACE_PAGE_MANAGER_THREAD = "User Interface Page Manager thread"; //$NON-NLS-1$\r
+ public static final String FUNCTION_USAGE_PROFILING_THREAD = "Function usage profiling thread"; //$NON-NLS-1$\r
+ public static final String USER_INTERFACE_PAGE_MANAGER_THREAD = "User Interface Page Managerthread"; //$NON-NLS-1$ \r
\r
/* log parsing token and callstack parsing token, etc... */\r
public static final String CALLSTACK_START = "callstack_start"; //$NON-NLS-1$\r
private static LeakDetector leakDetector = null;
private static FailedChecker failedChecker = null;
private static FailedChecker calledChecker = null;
- private static FunctionUsageProfiler functionUsageProfiler = null;
private static boolean appInfoArrived = false;
private static boolean sampleThread = false;
leakDetector = null;
failedChecker = null;
calledChecker = null;
- functionUsageProfiler = null;
sampleThread = false;
UserFunctionManager.getInstance().clear();
-
+ FunctionUsageProfiler.clear();
+ FunctionUsageProfiler.stopProfiler();
startBinaryAddr = null;
endBinaryAddr = null;
appInfoArrived = false;
return calledChecker;
}
- public static FunctionUsageProfiler getFunctionUserProfiler() {
- if (null == functionUsageProfiler) {
- functionUsageProfiler = new FunctionUsageProfiler();
- }
- return functionUsageProfiler;
- }
+ // public static FunctionUsageProfiler getFunctionUserProfiler() {
+ // if (null == functionUsageProfiler) {
+ // functionUsageProfiler = new FunctionUsageProfiler();
+ // }
+ // return functionUsageProfiler;
+ // }
public static boolean recordStart() {
AnalyzerUtil.executeCommand(ClearHandler.ID);
import org.tizen.dynamicanalyzer.common.CommonConstants;
import org.tizen.dynamicanalyzer.nl.AnalyzerLabels;
import org.tizen.dynamicanalyzer.project.AppDesktopInfo;
-import org.tizen.dynamicanalyzer.ui.info.range.StateManager;
+import org.tizen.dynamicanalyzer.ui.info.range.StopProcessManager;
import org.tizen.dynamicanalyzer.ui.toolbar.StopLogProcessor;
import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
import org.tizen.dynamicanalyzer.uirecorder.UIRecorderTool;
Display.getDefault().syncExec(new Runnable() {
@Override
public void run() {
- StateManager
+ StopProcessManager
.getInstance()
.stopProcessStart(
AnalyzerLabels.STOP_PROCESS_DLG_DEVICE_DISCONNECTED);
import org.tizen.dynamicanalyzer.ui.toolbar.OpenTraceInputReader;
import org.tizen.dynamicanalyzer.ui.toolbar.StopLogProcessor;
import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
-import org.tizen.dynamicanalyzer.ui.userinterface.UIDataManager;
import org.tizen.dynamicanalyzer.utils.UpdateViewTimer;
public class ExitHandler extends AbstractHandler {
AnalyzerManager.setExit(true);
ToolbarArea.getInstance().stopTimer();
UpdateViewTimer.stop();
- OpenTraceInputReader.stopOpenTraceThread();
+ OpenTraceInputReader.stopOpenTraceInputReader();
LogInserter.stopInsertLogThread();
LogParser.stopLogParser();
StopLogProcessor.stopStopLogProcessThread();
IDECommunicator.stopIDEcommunicatorThread();
- UIDataManager.getInstance().stopUpdateLogThread();
if (DACommunicator.isDaemonAlive()) {
DACommunicator.killDaemon();
import org.tizen.dynamicanalyzer.common.AnalyzerPaths;
import org.tizen.dynamicanalyzer.ui.page.DAPageComposite;
import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
-import org.tizen.dynamicanalyzer.utils.UpdateViewTimer;
-
public class OpenTraceCompleteHandler extends AbstractHandler {
- public static String ID = OpenTraceCompleteHandler.class.getName();
+ public static String ID = OpenTraceCompleteHandler.class.getName();
- @Override
- public Object execute(ExecutionEvent event) throws ExecutionException {
+ @Override
+ public Object execute(ExecutionEvent event) throws ExecutionException {
- Display.getDefault().syncExec(new Runnable() {
- @Override
- public void run() {
- DAPageComposite page = AnalyzerManager.getCurrentPage();
- page.updatePage();
- if (AnalyzerManager.getProject().getSavePath()
- .contains(AnalyzerPaths.TEMP_FOLDER_PATH)) {
- ToolbarArea.getInstance().setToolbarEnablement(true);
- } else {
- ToolbarArea.getInstance().setSaveButtonEnable(false);
- }
- }
- });
+ Display.getDefault().syncExec(new Runnable() {
+ @Override
+ public void run() {
+ DAPageComposite page = AnalyzerManager.getCurrentPage();
+ page.updatePage();
+ if (AnalyzerManager.getProject().getSavePath()
+ .contains(AnalyzerPaths.TEMP_FOLDER_PATH)) {
+ ToolbarArea.getInstance().setToolbarEnablement(true);
+ } else {
+ ToolbarArea.getInstance().setSaveButtonEnable(false);
+ }
+ }
+ });
- UpdateViewTimer.stop();
- System.out.println("open trace complete!!"); //$NON-NLS-1$
- return null;
- }
+ System.out.println("open trace complete handler ");
+ Display.getDefault().syncExec(new Runnable() {
+ @Override
+ public void run() {
+ DAPageComposite page = AnalyzerManager.getCurrentPage();
+ page.updatePage();
+ }
+ });
+ System.out.println("open trace complete!!"); //$NON-NLS-1$
+ return null;
+ }
}
import org.eclipse.core.commands.AbstractHandler;\r
import org.eclipse.core.commands.ExecutionEvent;\r
import org.eclipse.core.commands.ExecutionException;\r
+import org.eclipse.swt.widgets.Display;\r
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;\r
import org.tizen.dynamicanalyzer.common.AnalyzerManager;\r
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;\r
+import org.tizen.dynamicanalyzer.logparser.OpenTraceProgressManager;\r
import org.tizen.dynamicanalyzer.model.ImageInfo;\r
import org.tizen.dynamicanalyzer.model.LogCenter;\r
import org.tizen.dynamicanalyzer.nl.AnalyzerLabels;\r
import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler;\r
import org.tizen.dynamicanalyzer.ui.summary.profiling.ProfilingChildData;\r
import org.tizen.dynamicanalyzer.ui.summary.profiling.ProfilingData;\r
-import org.tizen.dynamicanalyzer.ui.toolbar.OpenTraceInputReader;\r
import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;\r
-import org.tizen.dynamicanalyzer.utils.UpdateViewTimer;\r
\r
public class OpenTraceHandler extends AbstractHandler {\r
\r
public static final String ID = OpenTraceHandler.class.getName();\r
+ Project p = null;\r
\r
@Override\r
public Object execute(ExecutionEvent event) throws ExecutionException {\r
\r
- Project p = AnalyzerManager.getProject();\r
+ p = AnalyzerManager.getProject();\r
ResultSet rs = SqlManager.selectAllFromProject(p);\r
if (null == rs) {\r
return null;\r
}\r
\r
if (pInfo.isEmpty()) {\r
+ // TODO: message box\r
+ // TODO: valid check\r
System.out.println("invalid save file"); //$NON-NLS-1$\r
return null;\r
}\r
-\r
+ Display.getDefault().syncExec(new Runnable() {\r
+ @Override\r
+ public void run() {\r
+ OpenTraceProgressManager.getInstance().openTracePrgressStart(\r
+ "Loading xml files..");\r
+ }\r
+ });\r
int size = pInfo.size();\r
List<String> logCenterNames = new ArrayList<String>();\r
for (int i = 0; i < size; i++) {\r
}\r
p.initLogCenters(logCenterNames);\r
\r
- loadAppInfo(p);\r
- loadCallStackData(p);\r
- loadCallStackApis(p);\r
- loadProfilingData();\r
- loadProfilingChildData();\r
- loadLeakData(p);\r
- loadFailedData();\r
- loadImageSet(p);\r
- p.closeConnection();\r
-\r
- ToolbarArea.getInstance().setTime(p.getLastTime());\r
- ToolbarArea.getInstance().setAppComboText(p.getAppName());\r
- ToolbarArea.getInstance().setRepalyButtonEnable(true);\r
- if (AnalyzerManager.getProject().getBinaryPath().isEmpty()) {\r
- ToolbarArea.getInstance().setSourceViewEnable(false);\r
- ToolbarArea.getInstance().setSourceViewTooltip(\r
- AnalyzerLabels.MESSAGE_PROCESS_PG_WARNING);\r
- } else {\r
- ToolbarArea.getInstance().setSourceViewEnable(true);\r
- ToolbarArea.getInstance().setSourceViewTooltip(\r
- AnalyzerLabels.MESSAGE_PROCESS_VIEW_SOURCE);\r
- }\r
- /* add each part action.. close... open...etc... */\r
+ Display.getDefault().syncExec(new Runnable() {\r
+ @Override\r
+ public void run() {\r
+ int percent = OpenTraceProgressManager.getInstance()\r
+ .getPercent();\r
+ OpenTraceProgressManager.getInstance().setProgressPercent(\r
+ "Loading appInfo..", percent += 20);\r
+\r
+ loadAppInfo(p);\r
+ OpenTraceProgressManager.getInstance().setProgressPercent(\r
+ "Loading Callstack data..", percent += 5);\r
+\r
+ loadCallStackData(p);\r
+ OpenTraceProgressManager.getInstance().setProgressPercent(\r
+ "Loading Callstack APIs..", percent += 5);\r
+\r
+ loadCallStackApis(p);\r
+ OpenTraceProgressManager.getInstance().setProgressPercent(\r
+ "Loading Profiling data..", percent += 5);\r
+\r
+ loadProfilingData();\r
+ OpenTraceProgressManager.getInstance().setProgressPercent(\r
+ "Making Profiling tree..", percent += 5);\r
+\r
+ loadProfilingChildData();\r
+ OpenTraceProgressManager.getInstance().setProgressPercent(\r
+ "Loading Leak data..", percent += 5);\r
+\r
+ loadLeakData(p);\r
+ OpenTraceProgressManager.getInstance().setProgressPercent(\r
+ "Loading Failed data..", percent += 5);\r
+\r
+ loadFailedData();\r
+ OpenTraceProgressManager.getInstance().setProgressPercent(\r
+ "Loading Images..", percent += 5);\r
+\r
+ loadImageSet(p);\r
+ OpenTraceProgressManager.getInstance().setProgressPercent(\r
+ "Toolbar setting...", percent += 5);\r
+ p.closeConnection();\r
+\r
+ ToolbarArea.getInstance().setTime(p.getLastTime());\r
+ ToolbarArea.getInstance().setAppComboText(p.getAppName());\r
+ ToolbarArea.getInstance().setRepalyButtonEnable(true);\r
+ if (AnalyzerManager.getProject().getBinaryPath().isEmpty()) {\r
+ ToolbarArea.getInstance().setSourceViewEnable(false);\r
+ ToolbarArea.getInstance().setSourceViewTooltip(\r
+ AnalyzerLabels.MESSAGE_PROCESS_PG_WARNING);\r
+ } else {\r
+ ToolbarArea.getInstance().setSourceViewEnable(true);\r
+ ToolbarArea.getInstance().setSourceViewTooltip(\r
+ AnalyzerLabels.MESSAGE_PROCESS_VIEW_SOURCE);\r
+ }\r
\r
- /* resource log view action start */\r
- List<LogCenter> logCenters = AnalyzerManager.getLogCenters();\r
- size = logCenters.size();\r
- for (int i = 0; i < size; i++) {\r
- LogCenter center = logCenters.get(i);\r
- int dataSize = SqlManager.selectCount(center);\r
- center.setDataSize(dataSize);\r
- }\r
+ OpenTraceProgressManager.getInstance().setProgressPercent(\r
+ "Loading data..", percent += 3);\r
+\r
+ /* add each part action.. close... open...etc... */\r
\r
- /* Timeline + file chart */\r
- UpdateViewTimer.start();\r
- OpenTraceInputReader.startOpenTraceThread();\r
+ /* resource log view action start */\r
+ List<LogCenter> logCenters = AnalyzerManager.getLogCenters();\r
+ int size = logCenters.size();\r
+ for (int i = 0; i < size; i++) {\r
+ LogCenter center = logCenters.get(i);\r
+ int dataSize = SqlManager.selectCount(center);\r
+ center.setDataSize(dataSize);\r
+ }\r
+ /* Timeline + file chart */\r
+ OpenTraceProgressManager.getInstance().runThreads();\r
+ OpenTraceProgressManager.getInstance().openTraceComplete();\r
+ }\r
+ });\r
return null;\r
}\r
\r
DBTableManager.TABLE_INDEX_PROFILING_DATA);\r
String tableName = profilingData.getTableName();\r
ResultSet rs = SqlManager.selectAllFromTable(tableName);\r
- FunctionUsageProfiler profiler = AnalyzerManager\r
- .getFunctionUserProfiler();\r
+ // FunctionUsageProfiler profiler = AnalyzerManager\r
+ // .getFunctionUserProfiler();\r
+ FunctionUsageProfiler profiler = FunctionUsageProfiler.getInstance();\r
if (null == rs || profiler == null) {\r
return;\r
}\r
data.add(rs.getString(i));\r
}\r
// possibility of extensions - network, efl, db, etc...\r
- ProfilingData fupData = new ProfilingData(\r
- data);\r
- String seq = data\r
- .get(ProfilingData.SEQUENCE_INDEX);\r
+ ProfilingData fupData = new ProfilingData(data);\r
+ String seq = data.get(ProfilingData.SEQUENCE_INDEX);\r
profiler.getProfilingDataMap().put(seq, fupData);\r
String symbol = data.get(ProfilingData.KEY_INDEX);\r
profiler.getSymbolSeqHash().put(symbol, seq);\r
.getTableInfo(DBTableManager.TABLE_INDEX_PROFILING_CHILD_DATA);\r
String tableName = profilingChildData.getTableName();\r
ResultSet rs = SqlManager.selectAllFromTable(tableName);\r
- FunctionUsageProfiler profiler = AnalyzerManager\r
- .getFunctionUserProfiler();\r
+ // FunctionUsageProfiler profiler = AnalyzerManager\r
+ // .getFunctionUserProfiler();\r
+ FunctionUsageProfiler profiler = FunctionUsageProfiler.getInstance();\r
if (null == rs || profiler == null) {\r
return;\r
}\r
for (int ii = 0; ii < splitSeqs.length; ii++) {\r
childData.add(new String(splitSeqs[ii]));\r
}\r
- ProfilingData parent = profiler\r
- .getProfilingDataMap().get(data.get(0));\r
+ ProfilingData parent = profiler.getProfilingDataMap().get(\r
+ data.get(0));\r
ProfilingChildData child = parent.getChildData();\r
child.getChildren().addAll(childData);\r
profiler.getChildListMap().put(data.get(0), child);\r
import org.tizen.dynamicanalyzer.model.LogCenter;
import org.tizen.dynamicanalyzer.project.Project;
import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackManager;
-import org.tizen.dynamicanalyzer.ui.info.range.StateManager;
+import org.tizen.dynamicanalyzer.ui.info.range.StopProcessManager;
import org.tizen.dynamicanalyzer.ui.page.BaseView;
import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
}
}
+ public static boolean isLogParsingEnd() {
+ if (null != logParser && logParser.isAlive()) {
+ return false;
+ }
+ return true;
+ }
+
/*** log parsing thread ***/
@Override
public void run() {
Display.getDefault().syncExec(new Runnable() {
@Override
public void run() {
- StateManager.getInstance().logQueueObserverThreadEnd();
+ StopProcessManager.getInstance().logQueueObserverThreadEnd();
}
});
ToolbarArea.getInstance().stopTimer();
slicedLog = log[0].split(AnalyzerConstants.DATA_PARSING_TOKEN);
logId = slicedLog[LogCenterConstants.ID_INDEX];
int id = Integer.parseInt(logId);
- if (LogCenterConstants.LOG_DEVICE != id){
-// if (LogCenterConstants.LOG_DEVICE != id && LogCenterConstants.LOG_UI_SCENE != id) {
+ if (LogCenterConstants.LOG_DEVICE != id) {
if (null == pid) {
pid = slicedLog[LogCenterConstants.PROCESS_ID_INDEX];
} else {
}
}
}
-// if (LogCenterConstants.LOG_UI_SCENE == id) {
-// System.out.println("break point");
-// }
String currentTime = null;
try {
// e.printStackTrace();
}
+ if (null == functionName || functionName.isEmpty()) {
+ System.out.println("function name is empty");
+ }
input[LogCenterConstants.APINAME_INDEX] = functionName;
}
import org.tizen.dynamicanalyzer.communicator.DACommunicator;
import org.tizen.dynamicanalyzer.nl.AnalyzerLabels;
import org.tizen.dynamicanalyzer.services.RecordStateSourceProvider;
-import org.tizen.dynamicanalyzer.ui.info.range.StateManager;
+import org.tizen.dynamicanalyzer.ui.info.range.StopProcessManager;
import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler;
import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineMaster;
import org.tizen.dynamicanalyzer.ui.toolbar.RecordStartStopThread;
Display.getDefault().syncExec(new Runnable() {
@Override
public void run() {
- StateManager
+ StopProcessManager
.getInstance()
.stopProcessStart(
AnalyzerLabels.STOP_PROCESS_DLG_DEVICE_DISCONNECTED); // socket
@Override
public void run() {
if (!AnalyzerManager.isExit()) {
- StateManager
+ StopProcessManager
.getInstance()
.stopProcessStart(
AnalyzerLabels.STOP_PROCESS_DLG_SUMMARIZING_DATA);
}
public void processUserProfiling(String input) {
- FunctionUsageProfiler profiler = AnalyzerManager
- .getFunctionUserProfiler();
-
- profiler.makeFunctionUsageProfileData(input);
+// FunctionUsageProfiler profiler = AnalyzerManager
+// .getFunctionUserProfiler();
+ FunctionUsageProfiler profiler = FunctionUsageProfiler.getInstance();
+ profiler.pushSample(input);
+// profiler.makeFunctionUsageProfileData(input);
}
}
--- /dev/null
+package org.tizen.dynamicanalyzer.logparser;
+
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.widgets.Shell;
+import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
+import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.handlers.ClearHandler;
+import org.tizen.dynamicanalyzer.handlers.OpenTraceCompleteHandler;
+import org.tizen.dynamicanalyzer.handlers.OpenTraceHandler;
+import org.tizen.dynamicanalyzer.project.Project;
+import org.tizen.dynamicanalyzer.ui.file.chart.FileChartManager;
+import org.tizen.dynamicanalyzer.ui.timeline.TimelinePage;
+import org.tizen.dynamicanalyzer.ui.toolbar.OpenTraceInputReader;
+import org.tizen.dynamicanalyzer.ui.userinterface.UIDataManager;
+import org.tizen.dynamicanalyzer.ui.widgets.ProgressDialog;
+import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
+
+public class OpenTraceProgressManager implements Runnable {
+ public static final int INIT = 0;
+ public static final int OPEN_TRACE_PROCESS_START = 1;
+ public static final int OPEN_TRACE_PROCESS_END = 2;
+ private int state = INIT;
+ private ProgressDialog dialog = null;
+ private String savePath = null;
+
+ private int percent = 0;
+
+ private static OpenTraceProgressManager instance = new OpenTraceProgressManager();
+ private Thread openTraceThread = null;
+
+ private OpenTraceProgressManager() {
+
+ }
+
+ public void startOpenTraceThread() {
+ if (null == openTraceThread || !openTraceThread.isAlive()) {
+ openTraceThread = new Thread(null, new OpenTraceProgressManager(),
+ AnalyzerConstants.OPEN_TRACE_THREAD);
+ openTraceThread.start();
+ }
+ }
+
+ public void stopOpenTraceThread() {
+ if (null != openTraceThread && openTraceThread.isAlive()) {
+ openTraceThread.interrupt();
+ }
+ }
+
+ public int getPercent() {
+ return percent;
+ }
+
+ public void setSavePath(String path) {
+ savePath = path;
+ }
+
+ public String getSavePath() {
+ return savePath;
+ }
+
+ public static OpenTraceProgressManager getInstance() {
+ return instance;
+ }
+
+ public void openTracePrgressStart(String EndMessage) {
+ if (state == OPEN_TRACE_PROCESS_START) {
+ return;
+ }
+ state = OPEN_TRACE_PROCESS_START;
+ Shell shell = AnalyzerUtil.getWorkbenchWindow().getShell();
+ dialog = new ProgressDialog(shell, SWT.APPLICATION_MODAL);
+ if (null != dialog) {
+ dialog.open();
+ dialog.setProcessMessage(EndMessage);
+ }
+ }
+
+ public void setProgressPercent(String message, int percent) {
+
+ if (null != dialog) {
+ this.percent = percent;
+ dialog.setProcessSelection(percent);
+ dialog.setProcessMessage(message);
+ }
+ }
+
+ public void openTraceComplete() {
+ if (null != dialog) {
+ waitingThreads();
+ dialog.setProcessSelection(100);
+ AnalyzerUtil.changePage(TimelinePage.ID);
+ dialog.close();
+ state = OPEN_TRACE_PROCESS_END;
+ AnalyzerUtil.executeCommand(OpenTraceCompleteHandler.ID);
+ percent = 0;
+ }
+ }
+
+ public int getState() {
+ return state;
+ }
+
+ public void runThreads() {
+ FileChartManager.getInstance().startUpdateLogThread();
+ OpenTraceInputReader.startOpenTraceInputReader();
+ UIDataManager.getInstance().startUpdateLogThread();
+ }
+
+ private void waitingThreads() {
+ while (true) {
+ try {
+ if (!FileChartManager.getInstance().isThreadAlive()
+ && !OpenTraceInputReader.isThreadAlive()) {
+ break;
+ } else {
+ Thread.sleep(AnalyzerConstants.LOG_CHECK_INTERVAL);
+ }
+ } catch (InterruptedException e) {
+ /** thread stop by interrupt */
+ break;
+ }
+ }
+ }
+
+ @Override
+ public void run() {
+ AnalyzerUtil.executeCommand(ClearHandler.ID);
+ Project project = new Project();
+ AnalyzerManager.setProjectNoRegist(project);
+ project.setSavePath(getInstance().getSavePath());
+
+ AnalyzerUtil.executeCommand(OpenTraceHandler.ID);
+ }
+}
import org.tizen.dynamicanalyzer.model.BaseLogCenter;
import org.tizen.dynamicanalyzer.model.LogCenter;
import org.tizen.dynamicanalyzer.sql.SqlManager;
+import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler;
import org.tizen.sdblib.IDevice;
public class Project {
}
public boolean isPieBuild() {
- if ("1".equals(appInfo.get(AnalyzerConstants.APP_INFO_PIE_BUILD))) { //$NON-NLS-1$
- return true;
+ try {
+ if ("1".equals(appInfo.get(AnalyzerConstants.APP_INFO_PIE_BUILD))) { //$NON-NLS-1$
+ return true;
+ }
+ } catch (NullPointerException e) {
+ System.out.println(appInfo.get(AnalyzerConstants.APP_INFO_PIE_BUILD));
+ e.printStackTrace();
+ return false;
}
return false;
}
}
public void setTotalProfilingSampleCount(int count) {
- AnalyzerManager.getFunctionUserProfiler().setTotalSampleCount(count);
+ // AnalyzerManager.getFunctionUserProfiler().setTotalSampleCount(count);
+ FunctionUsageProfiler.getInstance().setTotalSampleCount(count);
}
public int getTotalProfilingSampleCount() {
- return AnalyzerManager.getFunctionUserProfiler().getTotalSampleCount();
+ return FunctionUsageProfiler.getInstance().getTotalSampleCount();
+ // return
+ // AnalyzerManager.getFunctionUserProfiler().getTotalSampleCount();
}
}
unlockDB();
return;
}
- FunctionUsageProfiler profiler = AnalyzerManager
- .getFunctionUserProfiler();
+// FunctionUsageProfiler profiler = AnalyzerManager
+// .getFunctionUserProfiler();
+ FunctionUsageProfiler profiler = FunctionUsageProfiler.getInstance();
HashMap<String, ProfilingData> profilingDataMap = profiler
.getProfilingDataMap();
List<ProfilingData> pDataList = new ArrayList<ProfilingData>();
unlockDB();
return;
}
- FunctionUsageProfiler profiler = AnalyzerManager
- .getFunctionUserProfiler();
+// FunctionUsageProfiler profiler = AnalyzerManager
+// .getFunctionUserProfiler();
+ FunctionUsageProfiler profiler = FunctionUsageProfiler.getInstance();
HashMap<String, ProfilingChildData> profilingDataMap = profiler
.getChildListMap();
List<ProfilingChildData> pDataList = new ArrayList<ProfilingChildData>();
int output = selection - size;
output = (output < 0) ? 0 : output;
- System.out.println(output + " size " + size);
return output;
}
}
import org.tizen.dynamicanalyzer.communicator.ResourceCommunicator;
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
import org.tizen.dynamicanalyzer.logparser.LogListQueue;
+import org.tizen.dynamicanalyzer.logparser.LogParser;
import org.tizen.dynamicanalyzer.resources.ColorResources;
+import org.tizen.dynamicanalyzer.services.RecordStateSourceProvider;
import org.tizen.dynamicanalyzer.ui.file.FileChartData;
import org.tizen.dynamicanalyzer.ui.file.FileChartItemData;
import org.tizen.dynamicanalyzer.ui.summary.failed.FailedData;
private final int TYPE_OPEN = 1;
private final int TYPE_CLOSE = 2;
- private final long ONE_MINUTE = 60000000;
private int openApiCount = 0;
private int closeApiCount = 0;
}
}
+ public boolean isThreadAlive() {
+ if (null == updateLogThread || !updateLogThread.isAlive()) {
+ return false;
+ }
+ return true;
+ }
+
/*** make file data thread ***/
@Override
public void run() {
LogListQueue logListQueue = getInstance().getLogListQueue();
while (true) {
-
try {
if (!logListQueue.isEmpty()) {
List<List<String>> logs = logListQueue.getFirst();
getInstance().makeData(logs);
- } else {
+ } else if (!LogParser.isLogParsingEnd()
+ || (AnalyzerUtil.getRecordState()
+ .equals(RecordStateSourceProvider.RECORD_RECORDING))) {
Thread.sleep(AnalyzerConstants.LOG_CHECK_INTERVAL);
+ } else {
+ break;
}
} catch (InterruptedException e) {
/** thread stop by interrupt */
/* log for debug */
System.out.println("file manager thread end!!"); //$NON-NLS-1$
-
}
public static Color getFileOpenStartColor() {
.get(LogCenterConstants.RESOURCE_FILE_PATH_INDEX);
String fd = input.get(LogCenterConstants.RESOURCE_FDVALUE_INDEX);
String err = input.get(LogCenterConstants.ERROR_INDEX);
- int errno = Integer.parseInt(err);
+ long errno = Long.parseLong(err);
String name = input.get(LogCenterConstants.APINAME_INDEX);
// error check
}
}
- if (!file.isRepeatCehcked() && file.getData().size() > 3) {
- if (!WarningDataManager.getInstance().isChecked(file.getKey(),
- WarningCase.REPEATEDLY_OPEN_CLOSE.getType())) {
- WarningData wData = new WarningData(
- LogCenterConstants.LOG_RESOURCE,
- WarningCase.REPEATEDLY_OPEN_CLOSE.getType(), input,
- file.getKey());
- WarningDataManager.getInstance().getWarningData()
- .add(wData);
- file.setRepeatCheck();
- }
- }
} else if (type == TYPE_OPEN) {
if (!file.isClosed()) {
if (!WarningDataManager.getInstance().isChecked(file.getKey(),
}
}
- long usedTime = 0;
long closedTime = 0;
if (null != file.getLastData()) {
closedTime = file.getLastData().getCloseTime();
closedTime = ToolbarArea.getInstance().getTime();
}
- long lastTime = 0;
- if (null != file.getLastData()) {
- lastTime = file.getLastData().getLastTime();
- }
- if (lastTime < 0) {
- long openTime = file.getLastData().getOpenTime();
- usedTime = closedTime - openTime;
- } else {
- usedTime = closedTime - lastTime;
- }
-
- if (usedTime > ONE_MINUTE) {
- if (!WarningDataManager.getInstance().isChecked(file.getKey(),
- WarningCase.LONG_TIME_USED.getType())) {
- WarningData wData = new WarningData(
- LogCenterConstants.LOG_RESOURCE,
- WarningCase.LONG_TIME_USED.getType(), input,
- file.getKey());
- WarningDataManager.getInstance().getWarningData().add(wData);
- }
- }
}
private FileChartItemData createNewFileData(String path) {
}
// insert call count
- FunctionUsageProfiler profiler = AnalyzerManager
- .getFunctionUserProfiler();
+// FunctionUsageProfiler profiler = AnalyzerManager
+// .getFunctionUserProfiler();
+ FunctionUsageProfiler profiler = FunctionUsageProfiler.getInstance();
profiler.makeFupDataForCallTrace(selfCallstackUnit, input);
List<CallStackUnit> userCallstack = getUserCallstack(tid);
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Shell;
import org.tizen.dynamicanalyzer.ui.summary.SummaryPage;
-import org.tizen.dynamicanalyzer.ui.widgets.StopProgressDialog;
+import org.tizen.dynamicanalyzer.ui.widgets.ProgressDialog;
import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
-public class StateManager {
+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 int state = INIT;
- private StopProgressDialog dialog = null;
+ private ProgressDialog dialog = null;
- private static StateManager instance = new StateManager();
+ private static StopProcessManager instance = new StopProcessManager();
- private StateManager() {
+ private StopProcessManager() {
}
- public static StateManager getInstance() {
+ public static StopProcessManager getInstance() {
return instance;
}
}
state = STOP_PROCESS_START;
Shell shell = AnalyzerUtil.getWorkbenchWindow().getShell();
- dialog = new StopProgressDialog(shell, SWT.APPLICATION_MODAL);
- dialog.open();
+ dialog = new ProgressDialog(shell, SWT.APPLICATION_MODAL);
if (null != dialog) {
+ dialog.open();
dialog.setProcessMessage(EndMessage);
}
}
import org.tizen.dynamicanalyzer.common.CommonConstants;
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
import org.tizen.dynamicanalyzer.nl.SummaryLabels;
+import org.tizen.dynamicanalyzer.services.RecordStateSourceProvider;
import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackManager;
import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackUnit;
import org.tizen.dynamicanalyzer.ui.userinterface.UIDataManager;
+import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
import org.tizen.dynamicanalyzer.utils.Formatter;
-public class FunctionUsageProfiler {
+public class FunctionUsageProfiler implements Runnable {
class CallstackTree {
ProfilingData me;
public void addChildExeTime(int time) {
childExeTime += time;
}
-
+
public int getInclusiveExeTime() {
-// int cTime = 0;
-// for (int i = 0; i < children.size(); i++) {
-// cTime += children.get(i).getThis().getLastExeTime();
-// }
+ // int cTime = 0;
+ // for (int i = 0; i < children.size(); i++) {
+ // cTime += children.get(i).getThis().getLastExeTime();
+ // }
return me.getLastElapsedTime() - childExeTime;
}
private int totalSampleCount = 0;
private CallstackTree current = null;
+ private final int QUEUE_CHECK_INTERVAL = 2; // sec
+
+ private static FunctionUsageProfiler instance = null;
/**
* key: seq - value : function usage profiling data hash map all function
* profiling data. all parent and child data is in
*/
private HashMap<String, String> symbolSeqHash = null;
+ private List<String> sampleInputs = null;
+ private static Thread profiler = null;
private ProfilingData appBin = null;
private ProfilingData dependentLib = null;
private String appBinName = null;
+ public static FunctionUsageProfiler getInstance() {
+ if (null == instance) {
+ instance = new FunctionUsageProfiler();
+ }
+ return instance;
+ }
+
public HashMap<String, ProfilingData> getProfilingDataMap() {
if (null == profilingDataMap) {
profilingDataMap = new HashMap<String, ProfilingData>();
return symbolSeqHash;
}
+ private List<String> getSampleInputs() {
+ if (null == sampleInputs) {
+ sampleInputs = new ArrayList<String>();
+ }
+ return sampleInputs;
+ }
+
+ private String getFirstSample() {
+ String first = new String(getSampleInputs().get(0));
+ getSampleInputs().remove(0);
+ return first;
+ }
+
+ public void pushSample(String sample) {
+ getSampleInputs().add(sample);
+ }
+
public String getAppBinName() {
return appBinName;
}
parent = makeNewProfilingData(inputCallstackApiData, true);
checkUserCall(inputCallstackApiData, parent, null);
- ProfilingData child = makeNewProfilingData(
- inputCallstackApiData, false);
+ ProfilingData child = makeNewProfilingData(inputCallstackApiData,
+ false);
parent.addChild(child);
child.addExCount();
child.addElpasedTime(exeTime);
child.addCallCount();
}
} else {
- ProfilingData child = getProfilingDataByKey(inputCallstackApiData.getSymbol());
+ ProfilingData child = getProfilingDataByKey(inputCallstackApiData
+ .getSymbol());
if (null == child) {
child = makeNewProfilingData(inputCallstackApiData, false);
parent.addChild(child);
if (type == LogCenterConstants.USER_FUNCTION_EVENT_TYPE_EXIT) {
if (null == current) {
// bug
- System.out.println("bug found!!" + inputCallstackApiData.getFunctionName()); //$NON-NLS-1$
+ System.out
+ .println("bug found!!" + inputCallstackApiData.getFunctionName()); //$NON-NLS-1$
} else {
CallstackTree parentCt = current.getParent();
- if(null != parentCt) {
- parentCt.addChildExeTime(current.getThis().getLastElapsedTime());
+ if (null != parentCt) {
+ parentCt.addChildExeTime(current.getThis()
+ .getLastElapsedTime());
}
child.addExclusiveElapsedTime(current.getInclusiveExeTime());
current = current.getParent();
- UIDataManager.getInstance().getfunctionProfilingDataChecker().addPfofilingData( child );
+ UIDataManager.getInstance()
+ .getfunctionProfilingDataChecker()
+ .addPfofilingData(child);
}
} else {
if (null == current) {
if (null == inputData) {
return;
}
-
+
// drop samples of probe library
- if(inputData.getPath().startsWith(AnalyzerPaths.DA_REMOTE_PROBE_PATH)) {
+ if (inputData.getPath().startsWith(AnalyzerPaths.DA_REMOTE_PROBE_PATH)) {
return;
}
if (inputFuncName.equals(UNKNOWN)) {
parent.addExCount();
} else {
- ProfilingData child = makeNewProfilingData(
- inputData, false);
+ ProfilingData child = makeNewProfilingData(inputData, false);
parent.addChild(child);
child.addExCount();
child.setParent(parent.getName());
for (int i = 0; i < addrs.size(); i++) {
CallStackUnit callstackCsa = addrMap.get(addrs.get(i));
// disable inclusive cpu time of dependent library
- if (!CallStackManager.getInstance().checkUserCall(callstackCsa.getPath())) {
+ if (!CallStackManager.getInstance().checkUserCall(
+ callstackCsa.getPath())) {
continue;
}
-
+
if (callstackCsa.getFunctionName().equals(UNKNOWN)) {
ProfilingData inParent = getProfilingDataByKey(callstackCsa
.getPath());
checkUserCall(callstackCsa, inParent, pp);
}
inParent.addInCount(totalSampleCount);
-
+
if (null != inParent.getParent()) {
String pInParentName = inParent.getParent();
pp = getProfilingDataByKey(pInParentName);
- pp.addInCount(totalSampleCount);
+ pp.addInCount(totalSampleCount);
}
} else {
ProfilingData fupData = getProfilingDataByKey(callstackCsa
}
}
- private void checkUserCall(CallStackUnit csa,
- ProfilingData parent, ProfilingData pp) {
+ private void checkUserCall(CallStackUnit csa, ProfilingData parent,
+ ProfilingData pp) {
if (CallStackManager.getInstance().checkUserCall(csa.getPath())) {
if (null == appBin) {
CallStackUnit appBinCsa = new CallStackUnit(-1,
CallStackUnit funcName = addrMap.get(addr);
if (null == funcName) {
String funcSymbol = callstackLog.get(i + 1);
-// funcSymbol = SymbolNameDemangler.nameDemangle(funcSymbol);
+ // funcSymbol = SymbolNameDemangler.nameDemangle(funcSymbol);
CallStackUnit cas = new CallStackUnit(addr, funcSymbol);
if (null == addrMap.get(addr)) {
addrMap.put(addr, cas);
return getProfilingDataMap().get(seq);
}
- private ProfilingData makeNewProfilingData(
- CallStackUnit inputData, boolean isParent) {
- ProfilingData newProfilingData = new ProfilingData(
- inputData, isParent);
+ private ProfilingData makeNewProfilingData(CallStackUnit inputData,
+ boolean isParent) {
+ ProfilingData newProfilingData = new ProfilingData(inputData, isParent);
getProfilingDataMap().put(newProfilingData.getSequence(),
newProfilingData);
if (isParent) {
public int getTotalSampleCount() {
return totalSampleCount;
}
+
+ public static void startProfiler() {
+ if (null == profiler || !profiler.isAlive()) {
+ profiler = new Thread(null, new FunctionUsageProfiler(),
+ AnalyzerConstants.LOG_QUEUE_OBSERVING_THREAD);
+ profiler.start();
+ }
+ }
+
+ public static void stopProfiler() {
+ if (null != profiler && profiler.isAlive()) {
+ profiler.interrupt();
+ }
+ }
+
+ /*** profiling thread ***/
+ @Override
+ public void run() {
+ System.out.println("start profiling thread");
+ int emptyCount = 0;
+ while (true) {
+ try {
+ if (!getInstance().getSampleInputs().isEmpty()) {
+ String sample = getInstance().getFirstSample();
+ getInstance().makeFunctionUsageProfileData(sample);
+ emptyCount = 0;
+ } else if (emptyCount < QUEUE_CHECK_INTERVAL
+ || (AnalyzerUtil.getRecordState()
+ .equals(RecordStateSourceProvider.RECORD_RECORDING))) {
+ emptyCount++;
+ Thread.sleep(AnalyzerConstants.LOG_CHECK_INTERVAL);
+ } else {
+ break;
+ }
+ } catch (InterruptedException e) {
+ /** thread stop by interrupt */
+ break;
+ }
+ }
+
+ /* log for debug */
+ System.out.println("profiling thread end!!"); //$NON-NLS-1$
+ }
+
+ public static void clear() {
+ instance = null;
+ }
}
import java.util.ArrayList;
import java.util.List;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackUnit;
public class ProfilingData {
public ProfilingChildData getChildData() {
if (null == children) {
children = new ProfilingChildData(Integer.toString(seq));
- AnalyzerManager.getFunctionUserProfiler().getChildListMap()
+ // AnalyzerManager.getFunctionUserProfiler().getChildListMap()
+ // .put(Integer.toString(seq), children);
+ FunctionUsageProfiler.getInstance().getChildListMap()
.put(Integer.toString(seq), children);
}
return children;
return exCount;
}
- FunctionUsageProfiler profiler = AnalyzerManager
- .getFunctionUserProfiler();
+ // FunctionUsageProfiler profiler = AnalyzerManager
+ // .getFunctionUserProfiler();
+ FunctionUsageProfiler profiler = FunctionUsageProfiler.getInstance();
int size = seqs.size();
int count = 0;
for (int i = 0; i < size; i++) {
}
public List<ProfilingData> getChildList() {
- FunctionUsageProfiler profiler = AnalyzerManager
- .getFunctionUserProfiler();
+ // FunctionUsageProfiler profiler = AnalyzerManager
+ // .getFunctionUserProfiler();
+ FunctionUsageProfiler profiler = FunctionUsageProfiler.getInstance();
List<ProfilingData> output = new ArrayList<ProfilingData>();
List<String> seqs = getChildData().getChildren();
public class ProfilingTable extends DATreeComposite {
public static final String ID = ProfilingTable.class.getName();
+
public ProfilingTable(Composite parent, int compStyle, int tableStyle) {
super(parent, compStyle, tableStyle);
setComparator(new TreeDataComparator());
}
tableData.setObject(input.getName());
- FunctionUsageProfiler profiler = AnalyzerManager
- .getFunctionUserProfiler();
+ FunctionUsageProfiler profiler = FunctionUsageProfiler.getInstance();
+ // FunctionUsageProfiler profiler = AnalyzerManager
+ // .getFunctionUserProfiler();
String exTime = "0", exRate = "0.00", inTime = "0", inRate = "0.00", callCount = "0", exeTime = "0", inExeTime = "0"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ //$NON-NLS-7$
try {
@Override
public List<TreeInput> makeTreeInput() {
List<TreeInput> output = new ArrayList<TreeInput>();
- FunctionUsageProfiler profiler = AnalyzerManager
- .getFunctionUserProfiler();
-
+ // FunctionUsageProfiler profiler = AnalyzerManager
+ // .getFunctionUserProfiler();
+ FunctionUsageProfiler profiler = FunctionUsageProfiler.getInstance();
ProfilingData appBin = profiler.getAppBin();
if (null != appBin) {
TreeInput appBinInput = makeInput(appBin,
import org.tizen.dynamicanalyzer.nl.SummaryLabels;
public enum WarningCase {
- DUPLICATE_OPEN(
- 1,
- SummaryLabels.WARNING_CASE_PRE_FIX,
+ DUPLICATE_OPEN(1, SummaryLabels.WARNING_CASE_PRE_FIX,
SummaryLabels.WARNING_CASE_POST_FIX_DUPLICATE,
- SummaryLabels.WARNING_CASE_BRIEF_DUPLICATE),
- WITHOUT_USING(
- 2,
+ SummaryLabels.WARNING_CASE_BRIEF_DUPLICATE), WITHOUT_USING(2,
SummaryLabels.WARNING_CASE_PRE_FIX,
SummaryLabels.WARNING_CASE_POST_FIX_NO_OPERATION,
- SummaryLabels.WARNING_CASE_BRIEF_NO_OPERATION),
- REPEATEDLY_OPEN_CLOSE(
- 3,
- SummaryLabels.WARNING_CASE_PRE_FIX,
- SummaryLabels.WARNING_CASE_POST_FIX_REPEAT,
- SummaryLabels.WARNING_CASE_BRIEF_REPEAT),
- LONG_TIME_USED(
- 4,
- SummaryLabels.WARNING_CASE_PRE_FIX,
- SummaryLabels.WARNING_CASE_POST_FIX_UNUSED,
- SummaryLabels.WARNING_CASE_BRIEF_UNUSED);
-
+ SummaryLabels.WARNING_CASE_BRIEF_NO_OPERATION
+ // )
+ // ,
+ // REPEATEDLY_OPEN_CLOSE(
+ // 3,
+ // SummaryLabels.WARNING_CASE_PRE_FIX,
+ // SummaryLabels.WARNING_CASE_POST_FIX_REPEAT,
+ // SummaryLabels.WARNING_CASE_BRIEF_REPEAT),
+ // LONG_TIME_USED(
+ // 4,
+ // SummaryLabels.WARNING_CASE_PRE_FIX,
+ // SummaryLabels.WARNING_CASE_POST_FIX_UNUSED,
+ // SummaryLabels.WARNING_CASE_BRIEF_UNUSED);
+ );
private final int type;
private final String prefix;
private final String postfix;
return WarningCase.WITHOUT_USING.getShortMessage();
}
return WarningCase.WITHOUT_USING.getMessage(warning.getKey());
- } else if (warningCase == WarningCase.REPEATEDLY_OPEN_CLOSE.getType()) {
- if (isShort) {
- return WarningCase.REPEATEDLY_OPEN_CLOSE.getShortMessage();
- }
- return WarningCase.REPEATEDLY_OPEN_CLOSE.getMessage(warning
- .getKey());
- } else if (warningCase == WarningCase.LONG_TIME_USED.getType()) {
- if (isShort) {
- return WarningCase.LONG_TIME_USED.getShortMessage();
- }
- return WarningCase.LONG_TIME_USED.getMessage(warning.getKey());
}
+
// FIXME: error???
return ""; //$NON-NLS-1$
}
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.AnalyzerPaths;
import org.tizen.dynamicanalyzer.common.DesignConstants;
-import org.tizen.dynamicanalyzer.handlers.ClearHandler;
-import org.tizen.dynamicanalyzer.handlers.OpenTraceHandler;
+import org.tizen.dynamicanalyzer.logparser.OpenTraceProgressManager;
import org.tizen.dynamicanalyzer.nl.AnalyzerLabels;
-import org.tizen.dynamicanalyzer.project.Project;
import org.tizen.dynamicanalyzer.resources.ColorResources;
import org.tizen.dynamicanalyzer.resources.FontResources;
import org.tizen.dynamicanalyzer.ui.widgets.DAButton;
openPath = AnalyzerPaths.DYNAMIC_ANALYZER_SAVE_PATH
+ File.separator + selection.getText();
}
-
- AnalyzerUtil.executeCommand(ClearHandler.ID);
- Project p = new Project();
- AnalyzerManager.setProjectNoRegist(p);
- // p.init();
- p.setSavePath(openPath);
-
- AnalyzerUtil.executeCommand(OpenTraceHandler.ID);
+ OpenTraceProgressManager.getInstance().setSavePath(openPath);
+ OpenTraceProgressManager.getInstance().startOpenTraceThread();
shell.dispose();
}
}
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
-import org.tizen.dynamicanalyzer.handlers.OpenTraceCompleteHandler;
import org.tizen.dynamicanalyzer.logparser.LogPackage;
import org.tizen.dynamicanalyzer.logparser.Logs;
import org.tizen.dynamicanalyzer.model.LogCenter;
private static Thread openTraceInputThread = null;
- public static void startOpenTraceThread() {
+ public static void startOpenTraceInputReader() {
if (null == openTraceInputThread || !openTraceInputThread.isAlive()) {
openTraceInputThread = new Thread(null, new OpenTraceInputReader(),
AnalyzerConstants.OPEN_TRACE_THREAD);
}
}
- public static void stopOpenTraceThread() {
+ public static void stopOpenTraceInputReader() {
if (null != openTraceInputThread && openTraceInputThread.isAlive()) {
openTraceInputThread.interrupt();
}
}
+ public static boolean isThreadAlive() {
+ if (null == openTraceInputThread || !openTraceInputThread.isAlive()) {
+ return false;
+ }
+ return true;
+ }
+
public static void clear() {
- stopOpenTraceThread();
+ stopOpenTraceInputReader();
}
@Override
from += AnalyzerConstants.DATABASE_READ_SIZE;
to = from + AnalyzerConstants.DATABASE_READ_SIZE;
}
+ System.out.println("input reader complete");
// end
- AnalyzerUtil.executeCommand(OpenTraceCompleteHandler.ID);
}
private void updateLog(LogPackage logPack) {
import org.tizen.dynamicanalyzer.nl.AnalyzerLabels;
import org.tizen.dynamicanalyzer.services.RecordStateSourceProvider;
import org.tizen.dynamicanalyzer.ui.file.chart.FileChartManager;
-import org.tizen.dynamicanalyzer.ui.info.range.StateManager;
-import org.tizen.dynamicanalyzer.ui.userinterface.UIDataManager;
+import org.tizen.dynamicanalyzer.ui.info.range.StopProcessManager;
+import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler;
import org.tizen.dynamicanalyzer.uirecorder.UIRecorderTool;
import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
import org.tizen.dynamicanalyzer.utils.UpdateViewTimer;
ToolbarArea.getInstance().startTimer();
LogParser.startLogParser();
FileChartManager.getInstance().startUpdateLogThread();
- UIDataManager.getInstance().startUpdateLogThread();
-
+ FunctionUsageProfiler.startProfiler();
/* Timeline */
UpdateViewTimer.start();
Display.getDefault().syncExec(new Runnable() {
@Override
public void run() {
- StateManager.getInstance().stopProcessStart(
+ StopProcessManager.getInstance().stopProcessStart(
AnalyzerLabels.STOP_PROCESS_DLG_SUMMARIZING_DATA);
}
});
AnalyzerUtil.executeCommand(StopHandler.ID);
- UIDataManager.getInstance().stopUpdateLogThread();
}
}
import org.tizen.dynamicanalyzer.logparser.LogParser;
import org.tizen.dynamicanalyzer.project.Project;
import org.tizen.dynamicanalyzer.sql.SqlManager;
-import org.tizen.dynamicanalyzer.ui.info.range.StateManager;
+import org.tizen.dynamicanalyzer.ui.info.range.StopProcessManager;
import org.tizen.dynamicanalyzer.utils.UpdateViewTimer;
public class StopLogProcessor implements Runnable {
Display.getDefault().syncExec(new Runnable() {
@Override
public void run() {
- StateManager.getInstance().saveProjectAndOthers();
+ StopProcessManager.getInstance().saveProjectAndOthers();
}
});
Display.getDefault().syncExec(new Runnable() {
@Override
public void run() {
- StateManager.getInstance().insertToDBComplete();
+ StopProcessManager.getInstance().insertToDBComplete();
}
});
repeatCount++;
if (repeatCount == AnalyzerConstants.MAX_REPEAT_COUNT) {
LogParser.getLogQueue().clear();
- OpenTraceInputReader.stopOpenTraceThread();
+ OpenTraceInputReader.stopOpenTraceInputReader();
}
final int nSeclect = repeatCount * 10;
Display.getDefault().syncExec(new Runnable() {
@Override
public void run() {
- StateManager.getInstance().waitForLogParsing(
+ StopProcessManager.getInstance().waitForLogParsing(
nSeclect);
}
});
Display.getDefault().syncExec(new Runnable() {
@Override
public void run() {
- StateManager.getInstance().waitForLogParsing(50);
+ StopProcessManager.getInstance().waitForLogParsing(50);
}
});
System.out.println("wait for log parsing..."); //$NON-NLS-1$
Display.getDefault().syncExec(new Runnable() {
@Override
public void run() {
- StateManager.getInstance().stopTrace();
+ StopProcessManager.getInstance().stopTrace();
}
});
LogListQueue controllogListQueue = getInstance().getControlLogListQueue();
LogListQueue sceneTransformlogListQueue = getInstance().getSceneTransformLogListQueue();
while (true) {
-
try {
boolean isSleep = true;
if (!controllogListQueue.isEmpty()) {
import java.util.List;
import java.util.TreeSet;
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.AnalyzerPaths;
import org.tizen.dynamicanalyzer.nl.AnalyzerLabels;
import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler;
UIFunctionProfilingData fd = new UIFunctionProfilingData();
- FunctionUsageProfiler profiler = AnalyzerManager.getFunctionUserProfiler();
+ FunctionUsageProfiler profiler = FunctionUsageProfiler.getInstance();
String exTime = "-", inTime = "-", exeTime = "-", inExeTime = "-",exAvgTime = "-", inAvgTime = "-", exeAvgTime = "-", inExeAvgTime = "-"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ //$NON-NLS-7$ //$NON-NLS-8$ //$NON-NLS-9$
try {
exTime = profiler.getCpuTime(input, true);
import org.tizen.dynamicanalyzer.resources.ImageResources;
import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
-public class StopProgressDialog {
+public class ProgressDialog {
private Shell parent = null;
private Shell shell = null;
private long excuteTime = 10000; // max process time(default 10000
// MiliSeconds)
+ Composite base;
private Label loadingImage = null;
private Label processMessage = null;
private Label processInfo = null;
private static final int DEFAULT_MAXIMUM = 100;
private static final int TIMER_PERIOD = 1000;
private static final int DEFAULT_LINE_WIDTH = 1;
-
+
private final Image iconImage = ImageResources.STOP_PROGRESS_LOADING;
-
+
Timer timer = null;
long startTime = 0;
long time;
- public StopProgressDialog(Shell parent, int style) {
+ public ProgressDialog(Shell parent, int style) {
shell = new Shell(parent, style);
this.parent = parent;
createContents();
AnalyzerUtil.setCenter(shell);
}
- public StopProgressDialog(Shell parent, int style, long excuteTime) {
+ public ProgressDialog(Shell parent, int style, long excuteTime) {
this(parent, style);
this.excuteTime = excuteTime;
}
}
public void setProcessSelection(int value) {
- if (null == progressbar){
+ if (null == progressbar) {
return;
}
- if(value < progressbar.getSelection()){
+ if (value < progressbar.getSelection()) {
return;
}
+ redrawOthers();
progressbar.setSelection(value);
}
+ private void redrawOthers() {
+ /* TODO: bug fix */
+ // temp code for ubuntu 11.10 bug
+ // other OS test required
+ base.redraw();
+ loadingImage.redraw();
+ processInfo.redraw();
+ shell.redraw();
+ }
+
protected void createContents() {
setDefaultSize(parent.getBounds());
- FillLayout fillLayout = new FillLayout();
- fillLayout.marginHeight = DEFAULT_LINE_WIDTH*2;
- fillLayout.marginWidth = DEFAULT_LINE_WIDTH*2;
-
+ FillLayout fillLayout = new FillLayout();
+ fillLayout.marginHeight = DEFAULT_LINE_WIDTH * 2;
+ fillLayout.marginWidth = DEFAULT_LINE_WIDTH * 2;
+
shell.setLayout(fillLayout);
shell.addPaintListener(new PaintListener() {
-
+
@Override
public void paintControl(PaintEvent e) {
e.gc.setForeground(ColorResources.STOP_PROGRESS_LINE2_COLOR);
e.gc.setLineWidth(DEFAULT_LINE_WIDTH);
e.gc.drawRectangle(e.x, e.y, e.width, e.height);
e.gc.setForeground(ColorResources.STOP_PROGRESS_LINE1_COLOR);
- e.gc.drawRectangle(e.x+DEFAULT_LINE_WIDTH, e.y+DEFAULT_LINE_WIDTH, e.width - (DEFAULT_LINE_WIDTH*2), e.height - (DEFAULT_LINE_WIDTH*2));
+ e.gc.drawRectangle(e.x + DEFAULT_LINE_WIDTH, e.y
+ + DEFAULT_LINE_WIDTH, e.width
+ - (DEFAULT_LINE_WIDTH * 2), e.height
+ - (DEFAULT_LINE_WIDTH * 2));
}
});
-
- Composite base = new Composite(shell, SWT.NONE);
+
+ base = new Composite(shell, SWT.NONE);
base.setLayout(new FormLayout());
base.setBackground(ColorResources.STOP_PROGRESS_BACKGROUND_COLOR);
// Loading image
loadingImage = new Label(base, SWT.NONE);
- loadingImage.setBackground(ColorResources.STOP_PROGRESS_BACKGROUND_COLOR);
+ loadingImage
+ .setBackground(ColorResources.STOP_PROGRESS_BACKGROUND_COLOR);
loadingImage.setImage(iconImage);
-
+
// Process Message
processMessage = new Label(base, SWT.NONE);
processMessage.setText(message);
- processMessage.setBackground(ColorResources.STOP_PROGRESS_BACKGROUND_COLOR);
+ processMessage
+ .setBackground(ColorResources.STOP_PROGRESS_BACKGROUND_COLOR);
processMessage.setAlignment(SWT.LEFT);
processMessage.setForeground(ColorResources.DEFAULT_FONT_COLOR);
processMessage.setFont(FontResources.STOP_PROGRESS_FONT);
// Process Infomation
processInfo = new Label(base, SWT.NONE);
processInfo.setText(infomation);
- processInfo.setBackground(ColorResources.STOP_PROGRESS_BACKGROUND_COLOR);
+ processInfo
+ .setBackground(ColorResources.STOP_PROGRESS_BACKGROUND_COLOR);
processInfo.setAlignment(SWT.LEFT);
processInfo.setForeground(ColorResources.STOP_PROGRESS_INFO_FONT_COLOR);
processInfo.setFont(FontResources.STOP_PROGRESS_FONT);
progressbar = new ProgressBar(base, SWT.SMOOTH);
progressbar.setMaximum(DEFAULT_MAXIMUM);
-
// loading icon
FormData formData = new FormData();
formData.left = new FormAttachment(0, 10);
formData.width = 24;
formData.height = 24;
loadingImage.setLayoutData(formData);
-
+
// Process Message
formData = new FormData();
formData.left = new FormAttachment(loadingImage, 5);
}\r
\r
// return demangled;\r
- return makeReturnValue(demangled);\r
+ return makeReturnValue(mangled, demangled);\r
}\r
\r
- private static String makeReturnValue(String input) {\r
- if (input.length() > 0) {\r
- String[] splitInput = input.split("\\(");\r
+ private static String makeReturnValue(String mangled, String demangled) {\r
+ if (demangled.length() > 0) {\r
+ String[] splitInput = demangled.split("\\(");\r
return new String(splitInput[0]);\r
}\r
- return null;\r
+ // FIXME: no here!!\r
+ System.out.println("demangling failed and return mangled fuction Name" + mangled);\r
+ return mangled;\r
}\r
\r
private static String readFunc(String func) throws Exception {\r
import org.eclipse.swt.widgets.Display;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
-import org.tizen.dynamicanalyzer.ui.info.range.StateManager;
+import org.tizen.dynamicanalyzer.ui.info.range.StopProcessManager;
import org.tizen.dynamicanalyzer.ui.toolbar.UpdateTimerTask;
public class UpdateViewTimer {
Display.getDefault().syncExec(new Runnable() {
@Override
public void run() {
- StateManager.getInstance().updateTimerStop();
+ StopProcessManager.getInstance().updateTimerStop();
}
});
}
projects / sdk / tools / dynamic-analyzer.git / commitdiff