From b905bb473006a59ccc77507d6989ae37476edf50 Mon Sep 17 00:00:00 2001 From: greatim Date: Sun, 15 Dec 2013 20:30:31 +0900 Subject: [PATCH] [Title] kernel analysis implements(not complete) [Desc.] [Issue] --- .../tizen/dynamicanalyzer/nl/KernelPageLabels.java | 71 +++++ .../dynamicanalyzer/nl/KernelPageLabels.properties | 55 ++++ .../tizen/dynamicanalyzer/sql/DBTableManager.java | 39 ++- .../swap/model/data/LogDataTimeComparator.java | 20 ++ .../chart => kernel}/CallFlowChartRenderer.java | 2 +- .../dynamicanalyzer/ui/kernel/CallFlowView.java | 105 ++++++ .../ContextSwitchingChartRenderer.java | 2 +- .../ContextSwitchingChartSeriesItem.java | 36 ++- .../ui/kernel/ContextSwitchingChartView.java | 352 +++++++++++++++++++++ .../dynamicanalyzer/ui/kernel/KernelListTable.java | 67 ++++ .../dynamicanalyzer/ui/kernel/KernelListView.java | 77 +++++ .../dynamicanalyzer/ui/kernel/KernelPage.java | 94 ++++++ .../ui/kernel/KernelStatisticInfoView.java | 108 +++++++ .../ui/kernel/data/ContextDataDBInserter.java | 68 ++++ .../ui/kernel/data/FunctionDataDBInserter.java | 68 ++++ .../ui/kernel/data/KernelBlockingQueue.java | 31 ++ .../ui/kernel/data/KernelDataMaker.java | 329 +++++++++++++++++++ .../ui/kernel/data/KernelDataManager.java | 143 +++++++++ .../ui/kernel/data/KernelDataPerThread.java | 75 +++++ .../kernel/data/KernelDataPerThreadComparator.java | 23 ++ .../tizen/dynamicanalyzer/ui/page/BaseView.java | 5 + .../ui/timeline/chart/CPUCoreChart.java | 5 +- 22 files changed, 1769 insertions(+), 6 deletions(-) create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/nl/KernelPageLabels.java create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/nl/KernelPageLabels.properties mode change 100644 => 100755 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/sql/DBTableManager.java create mode 100755 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LogDataTimeComparator.java rename org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/{timeline/chart => kernel}/CallFlowChartRenderer.java (93%) create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/CallFlowView.java rename org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/{timeline/chart => kernel}/ContextSwitchingChartRenderer.java (99%) rename org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/{timeline/chart => kernel}/ContextSwitchingChartSeriesItem.java (62%) create mode 100755 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/ContextSwitchingChartView.java create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/KernelListTable.java create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/KernelListView.java create mode 100755 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/KernelPage.java create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/KernelStatisticInfoView.java create mode 100755 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/ContextDataDBInserter.java create mode 100755 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/FunctionDataDBInserter.java create mode 100755 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelBlockingQueue.java create mode 100755 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataMaker.java create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataManager.java create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataPerThread.java create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataPerThreadComparator.java mode change 100644 => 100755 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/page/BaseView.java diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/nl/KernelPageLabels.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/nl/KernelPageLabels.java new file mode 100644 index 0000000..b59d385 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/nl/KernelPageLabels.java @@ -0,0 +1,71 @@ +package org.tizen.dynamicanalyzer.nl; + +import org.eclipse.osgi.util.NLS; + +public class KernelPageLabels extends NLS { + private static final String BUNDLE_NAME = "org.tizen.dynamicanalyzer.nl.KernelPageLabels"; + + public static String CONTEXT_SWITCH_CHART_TITLE; + public static String CALLFLOW_CHART_TITLE; + public static String KERNEL_STATISTIC_TITLE; + + public static String KERNEL_CHART_SERIES_LOAD; + public static String KERNEL_CHART_SERIES_CORE; + public static String KERNEL_CHART_SERIES_FUNCTION; + public static String KERNEL_CHART_SERIES_THREAD; + + public static String UNKNOWN_FUNCTION_NAME; + public static String CORE_NAME_PREFIX; + public static String CORE_NAME_POSTFIX; + public static String THREAD_NAME_PREFIX; + public static String THREAD_NAME_POSTFIX; + public static String FUNCTION_NAME_POSTFIX; + + public static String KERNEL_CHART_ITEM_START; + public static String KERNEL_CHART_ITEM_END; + public static String KERNEL_CHART_ITEM_SWITCHED; + + public static String KERNEL_LIST_VIEW_INDEX; + public static String KERNEL_LIST_VIEW_START_TIME; + public static String KERNEL_LIST_VIEW_END_TIME; + public static String KERNEL_LIST_VIEW_EXECUTION_TIME; + public static String KERNEL_LIST_VIEW_START_PC; + public static String KERNEL_LIST_VIEW_END_PC; + public static String KERNEL_LIST_VIEW_ENTRY; + public static String KERNEL_LIST_VIEW_EXIT; + + public static String THREAD_LIST_VIEW_THREAD_TITLE; + public static String THREAD_LIST_VIEW_CORE_TITLE; + public static String THREAD_LIST_VIEW_FUNCTION_TITLE; + public static String THREAD_LIST_VIEW_INDEX; + public static String THREAD_LIST_VIEW_CORE; + public static String THREAD_LIST_VIEW_FUNCTION; + + public static String CORE_LIST_VIEW_CORE_TITLE; + public static String CORE_LIST_VIEW_THREAD_TITLE; + public static String CORE_LIST_VIEW_FUNCTION_TITLE; + public static String CORE_LIST_VIEW_INDEX; + public static String CORE_LIST_VIEW_PID; + public static String CORE_LIST_VIEW_TID; + public static String CORE_LIST_VIEW_FUNCTION; + + public static String KERNEL_STATISTIC_CS_COUNT; + public static String KERNEL_STATISTIC_CS_AVGTIME; + public static String KERNEL_STATISTIC_CS_OVERHEAD; + public static String KERNEL_STATISTIC_KERNEL_MODE_TIME; + public static String KERNEL_STATISTIC_CORE_AVGLOAD; + public static String KERNEL_STATISTIC_THREAD_STARVING_AVGTIME; + public static String KERNEL_STATISTIC_THREAD_STARVING_MAXTIME; + public static String KERNEL_STATISTIC_THREAD_CORE_COUNT; + public static String KERNEL_STATISTIC_THREAD_PARALLELISM_LEVEL; + public static String KERNEL_STATISTIC_LONGEST_FUNCTION_TIME; + public static String KERNEL_STATISTIC_LONGEST_FUNCTION_NAME; + + static { + // initialize resource bundle + NLS.initializeMessages(BUNDLE_NAME, KernelPageLabels.class); + } + + private KernelPageLabels() { + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/nl/KernelPageLabels.properties b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/nl/KernelPageLabels.properties new file mode 100644 index 0000000..c0e509c --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/nl/KernelPageLabels.properties @@ -0,0 +1,55 @@ +CONTEXT_SWITCH_CHART_TITLE=Context-switch +CALLFLOW_CHART_TITLE=Call-flow +KERNEL_STATISTIC_TITLE=Kernel Statistics + +KERNEL_CHART_SERIES_LOAD=Load +KERNEL_CHART_SERIES_CORE=Core +KERNEL_CHART_SERIES_FUNCTION=Function +KERNEL_CHART_SERIES_THREAD=Thread + +UNKNOWN_FUNCTION_NAME=unknown +CORE_NAME_PREFIX=core< +CORE_NAME_POSTFIX=> +THREAD_NAME_PREFIX=thread< +THREAD_NAME_POSTFIX=> +FUNCTION_NAME_POSTFIX=() + +KERNEL_CHART_ITEM_START=Start +KERNEL_CHART_ITEM_END=End +KERNEL_CHART_ITEM_SWITCHED=Switched + +KERNEL_LIST_VIEW_INDEX=# +KERNEL_LIST_VIEW_START_TIME=Start time +KERNEL_LIST_VIEW_END_TIME=End time +KERNEL_LIST_VIEW_EXECUTION_TIME=Execution time +KERNEL_LIST_VIEW_START_PC=Start pc addr +KERNEL_LIST_VIEW_END_PC=End pc addr +KERNEL_LIST_VIEW_ENTRY=Entry of func. +KERNEL_LIST_VIEW_EXIT=Exit of func. + +THREAD_LIST_VIEW_THREAD_TITLE=Context Switch List for Thread +THREAD_LIST_VIEW_CORE_TITLE=Core Usage List for Thread +THREAD_LIST_VIEW_FUNCTION_TITLE=Function Call List for Thread +THREAD_LIST_VIEW_INDEX=# +THREAD_LIST_VIEW_CORE=Core num +THREAD_LIST_VIEW_FUNCTION=Function name + +CORE_LIST_VIEW_CORE_TITLE=Context Switch List for Core +CORE_LIST_VIEW_THREAD_TITLE=Thread List fir Core +CORE_LIST_VIEW_FUNCTION_TITLE=Function Call List for Core +CORE_LIST_VIEW_INDEX=# +CORE_LIST_VIEW_PID=pid +CORE_LIST_VIEW_TID=tid +CORE_LIST_VIEW_FUNCTION=Function name + +KERNEL_STATISTIC_CS_COUNT=Number of context switch : +KERNEL_STATISTIC_CS_AVGTIME=Average execution time of contexts : +KERNEL_STATISTIC_CS_OVERHEAD=Overhead time of context switch : +KERNEL_STATISTIC_KERNEL_MODE_TIME=Average kernel mode time : +KERNEL_STATISTIC_CORE_AVGLOAD=Average core load +KERNEL_STATISTIC_THREAD_STARVING_AVGTIME=Average thread starving time : +KERNEL_STATISTIC_THREAD_STARVING_MAXTIME=Max thread starving time : +KERNEL_STATISTIC_THREAD_CORE_COUNT=Count of core for thread per second : +KERNEL_STATISTIC_THREAD_PARALLELISM_LEVEL=Average count of busy thread : +KERNEL_STATISTIC_LONGEST_FUNCTION_TIME=Longest function execution time : +KERNEL_STATISTIC_LONGEST_FUNCTION_NAME=Longest function name : diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/sql/DBTableManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/sql/DBTableManager.java old mode 100644 new mode 100755 index 5d8bda0..04b8e37 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/sql/DBTableManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/sql/DBTableManager.java @@ -48,6 +48,8 @@ public class DBTableManager { private static final String TABLE_NAME_LIB_OBJ = "LibraryObject";//$NON-NLS-1$ private static final String TABLE_NAME_APINAME = "ApiName";//$NON-NLS-1$ private static final String TABLE_NAME_GLES20_CONTEXT_DATA = "Gles20ContextData";//$NON-NLS-1$ + private static final String TABLE_NAME_CONTEXT_SWITCH_DATA = "ContextSwitchData";//$NON-NLS-1$ + private static final String TABLE_NAME_FUNCTION_CALL_DATA = "FunctionCallData";//$NON-NLS-1$ // private static final String TABLE_NAME_GLES20_CAHNGE_INFO = "Gles20ChangeInfo";//$NON-NLS-1$ private static List tableInfos; @@ -64,8 +66,10 @@ public class DBTableManager { public static final int TABLE_INDEX_LIB_OBJ = 9; public static final int TABLE_INDEX_APINAME = 10; public static final int TABLE_INDEX_GLES20_CONTEXT_DATA = 11; + public static final int TABLE_INDEX_CONTEXT_SWITCH_DATA = 12; + public static final int TABLE_INDEX_FUNCTION_CALL_DATA = 13; // public static final int TABLE_INDEX_GLES20_CHANGE_INFO = 12; - public static int TABLE_COUNT = 12; + public static int TABLE_COUNT = 14; public static final String EMPTY = CommonConstants.EMPTY; public static final String TEXT = "VARCHAR(256)";//$NON-NLS-1$ @@ -108,6 +112,8 @@ public class DBTableManager { public static final String CUSTOM_COLUMN_INCL_EXETIME = "inclExeTime";//$NON-NLS-1$ public static final String CUSTOM_COLUMN_EXCL_EXETIME = "exclExeTime";//$NON-NLS-1$ public static final String CUSTOM_COLUMN_CHILD_LIST = "childList";//$NON-NLS-1$ + public static final String CUSTOM_COLUMN_START_TIME = "StartTime"; + public static final String CUSTOM_COLUMN_END_TIME = "EndTime"; public static final String TARGET_INFO_SYS_MEM_SIZE = "SystemMemorySize";//$NON-NLS-1$ public static final String TARGET_INFO_STORAGE_SIZE = "StorageSize"; @@ -281,7 +287,7 @@ public class DBTableManager { // process info { - String[] names = {COMMON_COLUMN_PID, PROCESS_INFO }; + String[] names = { COMMON_COLUMN_PID, PROCESS_INFO }; String[] options = { EMPTY, EMPTY }; String[] types = { TEXT, TEXT }; DBTableInfo processInfoTableInfo = new DBTableInfo( @@ -344,6 +350,35 @@ public class DBTableManager { // tableInfos.set(TABLE_INDEX_GLES20_CHANGE_INFO, // Gles20ChangeInfoTableInfo); } + + // context switch data + { + String[] names = { COMMON_COLUMN_SEQ_NUMBER, COMMON_COLUMN_PID, + COMMON_COLUMN_TID, "CpuNum", CUSTOM_COLUMN_START_TIME, + "StartPcAddr", CUSTOM_COLUMN_END_TIME, "EndPcAddr" }; + String[] options = { NOT_NULL, NOT_NULL, NOT_NULL, EMPTY, EMPTY, + EMPTY, EMPTY, EMPTY }; + String[] types = { INTEGER, INTEGER, INTEGER, INTEGER, LONG, LONG, + LONG, LONG }; + DBTableInfo contextSwitchInfo = new DBTableInfo( + TABLE_NAME_CONTEXT_SWITCH_DATA, names, options, types); + tableInfos.set(TABLE_INDEX_CONTEXT_SWITCH_DATA, contextSwitchInfo); + } + + // function call data + { + String[] names = { COMMON_COLUMN_SEQ_NUMBER, COMMON_COLUMN_PID, + COMMON_COLUMN_TID, "CpuNum", CUSTOM_COLUMN_START_TIME, + "StartType", "StartPcAddr", CUSTOM_COLUMN_END_TIME, + "EndType", "EndPcAddr", "FunctionName" }; + String[] options = { NOT_NULL, NOT_NULL, NOT_NULL, EMPTY, EMPTY, + EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY }; + String[] types = { INTEGER, INTEGER, INTEGER, INTEGER, LONG, + INTEGER, LONG, LONG, INTEGER, LONG, TEXT }; + DBTableInfo funcCallInfo = new DBTableInfo( + TABLE_NAME_FUNCTION_CALL_DATA, names, options, types); + tableInfos.set(TABLE_INDEX_FUNCTION_CALL_DATA, funcCallInfo); + } } public DBTableInfo getTableInfo(int tableInfoIndex) { diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LogDataTimeComparator.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LogDataTimeComparator.java new file mode 100755 index 0000000..69d686d --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/LogDataTimeComparator.java @@ -0,0 +1,20 @@ +package org.tizen.dynamicanalyzer.swap.model.data; + +import java.util.Comparator; + +public class LogDataTimeComparator implements Comparator { + + @Override + public int compare(LogData arg0, LogData arg1) { + long time0 = arg0.getTime(); + long time1 = arg1.getTime(); + + if (time0 < time1) + return -1; + else if (time0 > time1) + return 1; + else + return 0; + } + +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/CallFlowChartRenderer.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/CallFlowChartRenderer.java similarity index 93% rename from org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/CallFlowChartRenderer.java rename to org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/CallFlowChartRenderer.java index 5ccbe85..06e61dd 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/CallFlowChartRenderer.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/CallFlowChartRenderer.java @@ -1,4 +1,4 @@ -package org.tizen.dynamicanalyzer.ui.timeline.chart; +package org.tizen.dynamicanalyzer.ui.kernel; import org.eclipse.swt.graphics.Font; import org.eclipse.swt.graphics.GC; diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/CallFlowView.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/CallFlowView.java new file mode 100644 index 0000000..eb04f17 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/CallFlowView.java @@ -0,0 +1,105 @@ +package org.tizen.dynamicanalyzer.ui.kernel; + +import org.eclipse.swt.SWT; +import org.eclipse.swt.custom.StackLayout; +import org.eclipse.swt.layout.FillLayout; +import org.eclipse.swt.widgets.Composite; +import org.tizen.dynamicanalyzer.common.AnalyzerManager; +import org.tizen.dynamicanalyzer.common.DASelectionData; +import org.tizen.dynamicanalyzer.model.DAView; +import org.tizen.dynamicanalyzer.nl.KernelPageLabels; +import org.tizen.dynamicanalyzer.resources.ColorResources; +import org.tizen.dynamicanalyzer.resources.FontResources; +import org.tizen.dynamicanalyzer.resources.ImageResources; +import org.tizen.dynamicanalyzer.ui.common.SetRangeMarkerMouseMoveListener; +import org.tizen.dynamicanalyzer.ui.common.UICommonConstants; +import org.tizen.dynamicanalyzer.ui.range.RangeDataManager; +import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants; +import org.tizen.dynamicanalyzer.ui.timeline.logparser.LifecycleLogParser; +import org.tizen.dynamicanalyzer.ui.widgets.TitleComboPopupRenderer; +import org.tizen.dynamicanalyzer.ui.widgets.TitleComboRenderer; +import org.tizen.dynamicanalyzer.ui.widgets.ViewContainer; +import org.tizen.dynamicanalyzer.widgets.button.DACustomButtonRenderer; +import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlotIntervalMarker; +import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoard; +import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoardItem; +import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoardSelectionListener; +import org.tizen.dynamicanalyzer.widgets.combo.DACustomCombo; +import org.tizen.dynamicanalyzer.widgets.timeline.DATimeline; + +public class CallFlowView extends DAView { + public static final String ID = CallFlowView.class.getName(); + + private final Composite contents; + private DAChartBoard callflowChart; + private DACustomCombo callflowCombo; + private final StackLayout stackLayout; + + private final RangeDataManager rangeDataManager = RangeDataManager + .getInstance(); + + public CallFlowView(Composite parent, int style) { + super(parent, style); + this.setLayout(new FillLayout()); + + ViewContainer viewContainer = new ViewContainer(this, false); + viewContainer.setTitleText(KernelPageLabels.CALLFLOW_CHART_TITLE); + + contents = viewContainer.getContentArea(); + contents.setBackground(ColorResources.WINDOW_BG_COLOR); + stackLayout = new StackLayout(); + contents.setLayout(stackLayout); + callflowChart = new DAChartBoard(contents, + KernelPageLabels.CALLFLOW_CHART_TITLE); + callflowChart.setNameFont(FontResources.CHART_NAME_FONT); + callflowChart.addSelectionListener(new DAChartBoardSelectionListener() { + @Override + public void handleSelectionEvent(DAChartBoardItem item) { + AnalyzerManager + .getCurrentPage() + .updatePage( + new DASelectionData( + CallFlowView.ID, + (long) (((DAChartPlotIntervalMarker) callflowChart + .getMarkers() + .get(UICommonConstants.SELECTION_MARKER_INDEX)) + .getStartVal() * TimelineConstants.MEGA_DOUBLE), + (long) (((DAChartPlotIntervalMarker) callflowChart + .getMarkers() + .get(UICommonConstants.SELECTION_MARKER_INDEX)) + .getEndVal() * TimelineConstants.MEGA_DOUBLE), + item.getData(), null)); + } + }); + +// initIntervalMarkers(callflowChart); + + stackLayout.topControl = callflowChart; + callflowCombo = new DACustomCombo(callflowChart.getTitleComp(), SWT.NONE); + callflowCombo.setImages(ImageResources.TIMELINE_DROPDOWN_NORMAL, + ImageResources.TIMELINE_DROPDOWN_HOVER, + ImageResources.TIMELINE_DROPDOWN_PUSH, + ImageResources.TIMELINE_DROPDOWN_NORMAL); + callflowCombo.add(KernelPageLabels.CALLFLOW_CHART_TITLE); + callflowCombo.setTextAlign(DACustomCombo.TEXT_ALIGN_CENTER); + callflowCombo.select(0); + callflowCombo.setEnabled(false); + callflowCombo.setComboRender(new TitleComboRenderer()); + callflowCombo.setComboPopupRender(new TitleComboPopupRenderer()); + callflowCombo.setButtonRenderer(new DACustomButtonRenderer()); + + DATimeline timeline = callflowChart.getTimeline(); + + timeline.setTimeTickFont(FontResources.TIMELINE_TICK_FONT); + timeline.setTimeBalloonFont(FontResources.TIMELINE_BALLOON_FONT); + + LifecycleLogParser.getInstance().registerLifecycleBar( + callflowChart.getLifecycleBar()); + LifecycleLogParser.getInstance().registerTimeline(timeline); + + timeline.addMouseMoveListener(new SetRangeMarkerMouseMoveListener( + rangeDataManager, callflowChart, timeline)); + + clear(); + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/ContextSwitchingChartRenderer.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/ContextSwitchingChartRenderer.java similarity index 99% rename from org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/ContextSwitchingChartRenderer.java rename to org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/ContextSwitchingChartRenderer.java index 4bc77e9..9a97838 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/ContextSwitchingChartRenderer.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/ContextSwitchingChartRenderer.java @@ -1,4 +1,4 @@ -package org.tizen.dynamicanalyzer.ui.timeline.chart; +package org.tizen.dynamicanalyzer.ui.kernel; import java.util.List; diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/ContextSwitchingChartSeriesItem.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/ContextSwitchingChartSeriesItem.java similarity index 62% rename from org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/ContextSwitchingChartSeriesItem.java rename to org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/ContextSwitchingChartSeriesItem.java index 5aed14e..b823d28 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/ContextSwitchingChartSeriesItem.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/ContextSwitchingChartSeriesItem.java @@ -1,4 +1,4 @@ -package org.tizen.dynamicanalyzer.ui.timeline.chart; +package org.tizen.dynamicanalyzer.ui.kernel; import org.eclipse.swt.graphics.Color; import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeriesItem; @@ -44,6 +44,36 @@ public class ContextSwitchingChartSeriesItem extends DAChartSeriesItem { this.style = style; } + public ContextSwitchingChartSeriesItem(String name, double x, double endX) { + super(x, 0); + this.endX = endX; + this.name = name; + } + + public ContextSwitchingChartSeriesItem(String name, double x, double endX, + Color borderColor) { + this(name, x, endX); + this.borderColor = borderColor; + } + + public ContextSwitchingChartSeriesItem(String name, double x, double endX, + int arrow, Color borderColor) { + this(name, x, endX, borderColor); + this.arrow = arrow; + } + + public ContextSwitchingChartSeriesItem(String name, double x, double endX, + Color color, Color borderColor) { + this(name, x, endX, borderColor); + this.color = color; + } + + public ContextSwitchingChartSeriesItem(String name, double x, double endX, + int style) { + this(name, x, endX); + this.style = style; + } + public String getName() { return name; } @@ -60,6 +90,10 @@ public class ContextSwitchingChartSeriesItem extends DAChartSeriesItem { this.endX = endX; } + public void setStyle(int style) { + this.style = style; + } + public int getArrow() { return arrow; } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/ContextSwitchingChartView.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/ContextSwitchingChartView.java new file mode 100755 index 0000000..b8f88bd --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/ContextSwitchingChartView.java @@ -0,0 +1,352 @@ +package org.tizen.dynamicanalyzer.ui.kernel; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.TreeMap; + +import org.eclipse.swt.SWT; +import org.eclipse.swt.custom.StackLayout; +import org.eclipse.swt.layout.FillLayout; +import org.eclipse.swt.widgets.Composite; +import org.tizen.dynamicanalyzer.common.AnalyzerManager; +import org.tizen.dynamicanalyzer.common.DASelectionData; +import org.tizen.dynamicanalyzer.model.DAView; +import org.tizen.dynamicanalyzer.nl.KernelPageLabels; +import org.tizen.dynamicanalyzer.resources.ColorResources; +import org.tizen.dynamicanalyzer.resources.FontResources; +import org.tizen.dynamicanalyzer.resources.ImageResources; +import org.tizen.dynamicanalyzer.ui.common.UICommonConstants; +import org.tizen.dynamicanalyzer.ui.kernel.data.KernelDataMaker; +import org.tizen.dynamicanalyzer.ui.kernel.data.KernelDataPerThread; +import org.tizen.dynamicanalyzer.ui.kernel.data.KernelDataPerThreadComparator; +import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants; +import org.tizen.dynamicanalyzer.ui.timeline.logparser.LifecycleLogParser; +import org.tizen.dynamicanalyzer.ui.widgets.TitleComboPopupRenderer; +import org.tizen.dynamicanalyzer.ui.widgets.TitleComboRenderer; +import org.tizen.dynamicanalyzer.ui.widgets.ViewContainer; +import org.tizen.dynamicanalyzer.widgets.button.DACustomButtonRenderer; +import org.tizen.dynamicanalyzer.widgets.chart.DAChart; +import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlotIntervalMarker; +import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeries; +import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlot.AutoRangeType; +import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoard; +import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoardHeightChangeableItem; +import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoardItem; +import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoardItemList; +import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoardSelectionListener; +import org.tizen.dynamicanalyzer.widgets.combo.DACustomCombo; +import org.tizen.dynamicanalyzer.widgets.timeline.DATimeline; + +public class ContextSwitchingChartView extends DAView { + public static final String ID = ContextSwitchingChartView.class.getName(); + public final static int KERNEL_CHART_HEIGHT = 40; + public final static int KERNEL_COMBO_ITEM_HEIGHT = 24; + + private final static int CONTEXT_DATA_COLUMN_INDEX_SEQ = 0; + private final static int CONTEXT_DATA_COLUMN_INDEX_PID = 1; + private final static int CONTEXT_DATA_COLUMN_INDEX_TID = 2; + private final static int CONTEXT_DATA_COLUMN_INDEX_CPU = 3; + private final static int CONTEXT_DATA_COLUMN_INDEX_STARTTIME = 4; + private final static int CONTEXT_DATA_COLUMN_INDEX_STARTADDR = 5; + private final static int CONTEXT_DATA_COLUMN_INDEX_ENDTIME = 6; + private final static int CONTEXT_DATA_COLUMN_INDEX_ENDADDR = 7; + + private final static int FUNCTION_DATA_COLUMN_INDEX_SEQ = 0; + private final static int FUNCTION_DATA_COLUMN_INDEX_PID = 1; + private final static int FUNCTION_DATA_COLUMN_INDEX_TID = 2; + private final static int FUNCTION_DATA_COLUMN_INDEX_CPU = 3; + private final static int FUNCTION_DATA_COLUMN_INDEX_STARTTIME = 4; + private final static int FUNCTION_DATA_COLUMN_INDEX_STARTTYPE = 5; + private final static int FUNCTION_DATA_COLUMN_INDEX_STARTADDR = 6; + private final static int FUNCTION_DATA_COLUMN_INDEX_ENDTIME = 7; + private final static int FUNCTION_DATA_COLUMN_INDEX_ENDTYPE = 8; + private final static int FUNCTION_DATA_COLUMN_INDEX_ENDADDR = 9; + private final static int FUNCTION_DATA_COLUMN_INDEX_FUNCNAME = 10; + + private final Composite contents; + private DAChartBoard contextChart; + private DACustomCombo contextCombo; + private final StackLayout stackLayout; + + private KernelDataMaker dataMaker; + + public ContextSwitchingChartView(Composite parent, int style) { + super(parent, style); + this.setLayout(new FillLayout()); + + ViewContainer viewContainer = new ViewContainer(this, false); + viewContainer.setTitleText(KernelPageLabels.CONTEXT_SWITCH_CHART_TITLE); + + contents = viewContainer.getContentArea(); + contents.setBackground(ColorResources.WINDOW_BG_COLOR); + + stackLayout = new StackLayout(); + contents.setLayout(stackLayout); + contextChart = new DAChartBoard(contents, + KernelPageLabels.CONTEXT_SWITCH_CHART_TITLE); + contextChart.setNameFont(FontResources.CHART_NAME_FONT); + + contextChart.addSelectionListener(new DAChartBoardSelectionListener() { + @Override + public void handleSelectionEvent(DAChartBoardItem item) { + handleSelection(item); + } + }); + + stackLayout.topControl = contextChart; + + contextCombo = new DACustomCombo(contextChart.getTitleComp(), SWT.NONE); + + contextCombo.setImages(ImageResources.TIMELINE_DROPDOWN_NORMAL, + ImageResources.TIMELINE_DROPDOWN_HOVER, + ImageResources.TIMELINE_DROPDOWN_PUSH, + ImageResources.TIMELINE_DROPDOWN_NORMAL); + contextCombo.add(KernelPageLabels.CONTEXT_SWITCH_CHART_TITLE); + contextCombo.select(0); + contextCombo.setTextAlign(DACustomCombo.TEXT_ALIGN_CENTER); + contextCombo.setEnabled(true); + contextCombo.setComboRender(new TitleComboRenderer()); + contextCombo.setComboPopupRender(new TitleComboPopupRenderer()); + contextCombo.setButtonRenderer(new DACustomButtonRenderer()); + + DATimeline threadTimeline = contextChart.getTimeline(); + + threadTimeline.setTimeTickFont(FontResources.TIMELINE_TICK_FONT); + threadTimeline.setTimeBalloonFont(FontResources.TIMELINE_BALLOON_FONT); + + LifecycleLogParser.getInstance().registerLifecycleBar( + contextChart.getLifecycleBar()); + LifecycleLogParser.getInstance().registerTimeline(threadTimeline); + + // setTimelineMouseListener(threadTimeline, threadChart); + // setTimelineMouseListener(coreTimeline, coreChart); + + dataMaker = KernelDataMaker.getInstance(); + } + + private void handleSelection(DAChartBoardItem selectItem) { + if (null == selectItem) { + AnalyzerManager + .getCurrentPage() + .updatePage( + new DASelectionData( + ContextSwitchingChartView.ID, + (long) (((DAChartPlotIntervalMarker) contextChart + .getMarkers() + .get(UICommonConstants.SELECTION_MARKER_INDEX)) + .getStartVal() * TimelineConstants.MEGA_DOUBLE), + (long) (((DAChartPlotIntervalMarker) contextChart + .getMarkers() + .get(UICommonConstants.SELECTION_MARKER_INDEX)) + .getEndVal() * TimelineConstants.MEGA_DOUBLE), + new Integer(0), null)); + } else { + AnalyzerManager + .getCurrentPage() + .updatePage( + new DASelectionData( + ContextSwitchingChartView.ID, + (long) (((DAChartPlotIntervalMarker) contextChart + .getMarkers() + .get(UICommonConstants.SELECTION_MARKER_INDEX)) + .getStartVal() * TimelineConstants.MEGA_DOUBLE), + (long) (((DAChartPlotIntervalMarker) contextChart + .getMarkers() + .get(UICommonConstants.SELECTION_MARKER_INDEX)) + .getEndVal() * TimelineConstants.MEGA_DOUBLE), + selectItem.getData(), null)); + } + } + + @Override + public void updateView() { + List threads = dataMaker.getThreadData(); + int thread_size = threads.size(); + + for (int i = 0; i < thread_size; i++) { + KernelDataPerThread kdata = threads.get(i); + DAChartBoardItem bitem = kdata.getContextChart(); + if (bitem == null) { + // create board item for this thread context + DAChartBoardHeightChangeableItem coreItem = new DAChartBoardHeightChangeableItem( + contextChart, getChartName(kdata)); + coreItem.useExpand(false); + coreItem.setHeightRatio(0.5); + + DAChart coreChart = coreItem.getChart(); + DAChartSeries coreSeries = new DAChartSeries("core", -1, + ColorResources.BLUE); + coreChart.addSeries(coreSeries); + + coreChart.getPlot().setAutoHeightRange(AutoRangeType.MANUAL); + coreChart.getPlot().setShowAxis(false); + + coreChart.setChartRenderer(new ContextSwitchingChartRenderer()); + coreItem.setData(kdata); + kdata.setContextChart(coreItem); + } else { + // delete previous drawing items + bitem.getChart().getSeries(0).clear(); + } + + bitem = kdata.getFunctionChart(); + if(kdata.getFunclog() != null && bitem == null) { + // create board item for function + DAChartBoardHeightChangeableItem functionItem = new DAChartBoardHeightChangeableItem( + kdata.getContextChart(), "functions"); + functionItem.useExpand(false); + functionItem.setHeightRatio(0.5); + + DAChart functionChart = functionItem.getChart(); + DAChartSeries functionSeries = new DAChartSeries("function", -1, + ColorResources.RED); + functionChart.addSeries(functionSeries); + + functionChart.getPlot().setAutoHeightRange(AutoRangeType.MANUAL); + functionChart.getPlot().setShowAxis(false); + + functionChart.setChartRenderer(new ContextSwitchingChartRenderer()); + functionItem.setData(kdata); + kdata.setFunctionChart(functionItem); + } else if(bitem != null) { + // delete previous drawing items + bitem.getChart().getSeries(0).clear(); + } + } + + // rearrange items + rearrangeChart(); + + // get data from database and add new item to series + long starttime = (long) (contextChart.getVisibleStartTime() * TimelineConstants.MEGA_DOUBLE); + long endtime = (long) (contextChart.getVisibleEndTime() * TimelineConstants.MEGA_DOUBLE); + + List> contextData = dataMaker.getContextDataFromDB( + starttime, endtime); + List> functionData = dataMaker.getFunctionDataFromDB( + starttime, endtime); + int csize = contextData.size(); + int fsize = functionData.size(); + + for (int i = 0; i < csize; i++) { + List idata = contextData.get(i); + int tid = Integer + .parseInt(idata.get(CONTEXT_DATA_COLUMN_INDEX_TID)); + int cpunum = Integer.parseInt(idata + .get(CONTEXT_DATA_COLUMN_INDEX_CPU)); + double contextStart = (double) (Long.parseLong(idata + .get(CONTEXT_DATA_COLUMN_INDEX_STARTTIME)) / TimelineConstants.MEGA_LONG); + double contextEnd = (double) (Long.parseLong(idata + .get(CONTEXT_DATA_COLUMN_INDEX_ENDTIME)) / TimelineConstants.MEGA_LONG); + + DAChartBoardItem coreItem = findCoreBoardItem(threads, tid); + assert (coreItem != null); + DAChartSeries coreSeries = coreItem.getChart().getSeries(0); + + coreSeries.addSeriesItem(new ContextSwitchingChartSeriesItem("core" + + cpunum, contextStart, contextEnd)); + } + + for (int i = 0; i < fsize; i++) { + List idata = functionData.get(i); + int tid = Integer.parseInt(idata + .get(FUNCTION_DATA_COLUMN_INDEX_TID)); + String funcname = idata.get(FUNCTION_DATA_COLUMN_INDEX_FUNCNAME); + double funcStart = (double) (Long.parseLong(idata + .get(FUNCTION_DATA_COLUMN_INDEX_STARTTIME)) / TimelineConstants.MEGA_LONG); + double funcEnd = (double) (Long.parseLong(idata + .get(FUNCTION_DATA_COLUMN_INDEX_ENDTIME)) / TimelineConstants.MEGA_LONG); + int type = Integer.parseInt(idata + .get(FUNCTION_DATA_COLUMN_INDEX_STARTTYPE)) + + Integer.parseInt(idata + .get(FUNCTION_DATA_COLUMN_INDEX_ENDTYPE)); + + DAChartBoardItem functionItem = findFunctionBoardItem(threads, tid); + assert (functionItem != null); + DAChartSeries funcSeries = functionItem.getChart().getSeries(0); + + int style; + switch (type) { + case 21: + case 31: + style = ContextSwitchingChartSeriesItem.STYLE_OCTAGON_LEFT_ONLY; + break; + case 12: + case 13: + style = ContextSwitchingChartSeriesItem.STYLE_OCTAGON_RIGHT_ONLY; + break; + case 22: + case 32: + case 23: + case 33: + style = ContextSwitchingChartSeriesItem.STYLE_OCTAGON; + break; + case 11: + default: + style = ContextSwitchingChartSeriesItem.STYLE_SQUARE; + break; + } + + funcSeries.addSeriesItem(new ContextSwitchingChartSeriesItem( + funcname, funcStart, funcEnd, style)); + } + + // redraw chart + contextChart.redraw(); + } + + private DAChartBoardItem findCoreBoardItem( + List threads, int tid) { + int size = threads.size(); + for(int i = 0; i < size; i++) { + if(threads.get(i).getTid() == tid) + return threads.get(i).getContextChart(); + } + + return null; + } + + private DAChartBoardItem findFunctionBoardItem( + List threads, int tid) { + int size = threads.size(); + for(int i = 0; i < size; i++) { + if(threads.get(i).getTid() == tid) + return threads.get(i).getFunctionChart(); + } + + return null; + } + + @Override + public void clear() { + contextChart.clear(); + } + + private String getChartName(KernelDataPerThread data) { + String name = "Pid : " + data.getPid() + "\nTid : " + data.getTid(); + return name; + } + + private void rearrangeChart() { + DAChartBoardItemList itemList = contextChart.getChartComposite(); + int listsize = itemList.getItemSize(); + + TreeMap sortedmap = new TreeMap( + new KernelDataPerThreadComparator()); + + for (int i = 0; i < listsize; i++) { + DAChartBoardItem item = itemList.get(i); + KernelDataPerThread gdata = (KernelDataPerThread) item.getData(); + sortedmap.put(gdata, i); + } + + Map.Entry entry; + ArrayList arranged = new ArrayList(); + while ((entry = sortedmap.pollFirstEntry()) != null) { + arranged.add(entry.getValue()); + } + + contextChart.reArrangeItem(arranged.toArray(new Integer[0])); + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/KernelListTable.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/KernelListTable.java new file mode 100644 index 0000000..4ba373f --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/KernelListTable.java @@ -0,0 +1,67 @@ +package org.tizen.dynamicanalyzer.ui.kernel; + +import org.eclipse.nebula.widgets.grid.GridItem; +import org.eclipse.swt.events.SelectionEvent; +import org.eclipse.swt.events.SelectionListener; +import org.eclipse.swt.widgets.Composite; +import org.tizen.dynamicanalyzer.common.AnalyzerManager; +import org.tizen.dynamicanalyzer.common.DASelectionData; +import org.tizen.dynamicanalyzer.ui.widgets.table.DAApiListTableComposite; +import org.tizen.dynamicanalyzer.ui.widgets.table.DATableDataFormat; +import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoard; + +public class KernelListTable extends DAApiListTableComposite { + private DAChartBoard chartBoard = null; + + public KernelListTable(Composite parent, int compStyle, int tableStyle) { + super(parent, compStyle, tableStyle); + table.addSelectionListener(new SelectionListener() { + + @Override + public void widgetSelected(SelectionEvent e) { + + GridItem[] items = table.getSelection(); + if (null == items) { + return; + } + long startTime = 0; + long endTime = 0; + + DATableDataFormat dataFormat; + long itemTime; + for (int i = 0; i < items.length; i++) { + dataFormat = (DATableDataFormat) items[i].getData(); + itemTime = dataFormat.getLogData().getTime(); + if (0 == startTime) { + startTime = itemTime; + } + if (startTime > itemTime) { + startTime = itemTime; + } + if (endTime < itemTime) { + endTime = itemTime; + } + } + + DASelectionData selData = new DASelectionData( + KernelListView.ID, startTime, endTime, items, table); + AnalyzerManager.getCurrentPage().updatePage(selData); + AnalyzerManager.getCurrentPage().controlSelection( + KernelListView.ID); + + DATableDataFormat dataFormats = (DATableDataFormat) items[0] + .getData(); +// NetworkData networkData = (NetworkData) dataFormats +// .getLogData(); +// NetworkChartManager.getInstance().setPacketMessage( +// networkData.getPacketMessage()); + } + + @Override + public void widgetDefaultSelected(SelectionEvent e) { + // TODO Auto-generated method stub + } + }); + } + +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/KernelListView.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/KernelListView.java new file mode 100644 index 0000000..b9c3ca0 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/KernelListView.java @@ -0,0 +1,77 @@ +package org.tizen.dynamicanalyzer.ui.kernel; + +import org.eclipse.swt.SWT; +import org.eclipse.swt.layout.FillLayout; +import org.eclipse.swt.widgets.Composite; +import org.tizen.dynamicanalyzer.common.AnalyzerConstants; +import org.tizen.dynamicanalyzer.model.DAView; +import org.tizen.dynamicanalyzer.nl.KernelPageLabels; +import org.tizen.dynamicanalyzer.resources.ColorResources; +import org.tizen.dynamicanalyzer.ui.widgets.ViewContainer; +import org.tizen.dynamicanalyzer.ui.widgets.table.TableColumnSizePackListener; + +public class KernelListView extends DAView { + public static final String ID = KernelListView.class.getName(); + + int[] innerMaxWeight = { 0, 100 }; + int[] outerMaxWeight = { 100, 0 }; + +// private String[] columnNames = { +// KernelPageLabels.NETWORK_API_LIST_VIEW_INDEX, +// KernelPageLabels.NETWORK_API_LIST_VIEW_START_TIME, +// KernelPageLabels.NETWORK_API_LIST_VIEW_END_TIME, +// KernelPageLabels.NETWORK_API_LIST_VIEW_PID, +// KernelPageLabels.NETWORK_API_LIST_VIEW_API, +// KernelPageLabels.NETWORK_API_LIST_VIEW_OBJECT, +// KernelPageLabels.NETWORK_API_LIST_VIEW_PARAMETER, +// KernelPageLabels.NETWORK_API_LIST_VIEW_THREAD_ID, +// KernelPageLabels.NETWORK_API_LIST_VIEW_RETURN, +// KernelPageLabels.NETWORK_API_LIST_VIEW_BYTE_SIZE, +// KernelPageLabels.NETWORK_API_LIST_VIEW_MESSAGE, +// KernelPageLabels.NETWORK_API_LIST_VIEW_ERRNO }; +// +// private int[] columnSizes = { 40, 70, 70, 70, 120, 90, 70, 70, 100, 70, +// 100, 100 }; +// private int[] columnAlignment = { SWT.RIGHT, SWT.LEFT, SWT.LEFT, SWT.LEFT, +// SWT.LEFT, SWT.LEFT, SWT.LEFT, SWT.LEFT, SWT.LEFT, SWT.LEFT, +// SWT.LEFT, SWT.LEFT }; +// +// int[] sortTypes = { AnalyzerConstants.SORT_TYPE_NUM, +// AnalyzerConstants.SORT_TYPE_NUM, AnalyzerConstants.SORT_TYPE_NUM, +// AnalyzerConstants.SORT_TYPE_NUM, +// AnalyzerConstants.SORT_TYPE_STRING, +// AnalyzerConstants.SORT_TYPE_STRING, +// AnalyzerConstants.SORT_TYPE_STRING, +// AnalyzerConstants.SORT_TYPE_NUM, +// AnalyzerConstants.SORT_TYPE_STRING, +// AnalyzerConstants.SORT_TYPE_STRING, +// AnalyzerConstants.SORT_TYPE_STRING, +// AnalyzerConstants.SORT_TYPE_STRING }; + + KernelListTable tableComp = null; + + public KernelListView(Composite parent, int style) { + super(parent, style); + this.setLayout(new FillLayout()); + + ViewContainer viewContainer = new ViewContainer(this, true); + viewContainer + .setTitleText(KernelPageLabels.THREAD_LIST_VIEW_THREAD_TITLE); + setMaxWeight(innerMaxWeight, outerMaxWeight); + + Composite contents = viewContainer.getContentArea(); + contents.setBackground(ColorResources.WINDOW_BG_COLOR); + contents.setLayout(new FillLayout()); + tableComp = new KernelListTable(contents, SWT.NONE, SWT.MULTI + | SWT.BORDER | SWT.FULL_SELECTION | SWT.H_SCROLL | SWT.V_SCROLL); +// tableComp.setSortTypes(sortTypes); +// tableComp.setFailedAPITableIndex(12); +// tableComp.setColumnAlignment(columnAlignment); +// tableComp.setColumns(columnNames); +// tableComp.setColumnSize(columnSizes); + tableComp.setTableName(KernelPageLabels.THREAD_LIST_VIEW_THREAD_TITLE); +// contents.addControlListener(new TableColumnSizePackListener(tableComp, +// columnSizes)); + } + +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/KernelPage.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/KernelPage.java new file mode 100755 index 0000000..22053e6 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/KernelPage.java @@ -0,0 +1,94 @@ +package org.tizen.dynamicanalyzer.ui.kernel; + +import org.eclipse.swt.SWT; +import org.eclipse.swt.custom.SashForm; +import org.eclipse.swt.layout.FillLayout; +import org.eclipse.swt.widgets.Composite; +import org.tizen.dynamicanalyzer.nl.AnalyzerLabels; +import org.tizen.dynamicanalyzer.shortcut.ShortCutManager; +import org.tizen.dynamicanalyzer.swap.logparser.LogPackage; +import org.tizen.dynamicanalyzer.ui.info.callstack.CallstackView; +import org.tizen.dynamicanalyzer.ui.info.snapshot.SnapshotView; +import org.tizen.dynamicanalyzer.ui.kernel.data.KernelDataManager; +import org.tizen.dynamicanalyzer.ui.page.DAPageComposite; +import org.tizen.dynamicanalyzer.ui.widgets.DATabComposite; + +public class KernelPage extends DAPageComposite { + public static final String ID = KernelPage.class.getName(); + private KernelDataManager kdataManager; + + SashForm baseForm; + SashForm leftForm; + SashForm rightForm; + + public KernelPage(Composite parent, int style) { + super(parent, style); + kdataManager = KernelDataManager.getInstance(); + + name = AnalyzerLabels.COOLBAR_AREA_KERNEL; + this.setData(DAPageComposite.KEY_TOOLTIP, + ShortCutManager.COOLBAR_AREA_NETWORK_TOOLTIP); + this.setLayout(new FillLayout()); + + baseForm = new SashForm(this, SWT.HORIZONTAL); + baseForm.setLayout(new FillLayout()); + + leftForm = new SashForm(baseForm, SWT.VERTICAL); + ContextSwitchingChartView kernelChartView = new ContextSwitchingChartView(leftForm, + SWT.NONE); + addView(kernelChartView); + DATabComposite lefttabView = new DATabComposite(leftForm, SWT.NONE); + addView(lefttabView); + { + CallFlowView callflowView = new CallFlowView( + lefttabView.getContentComposite(), SWT.NONE); + lefttabView.addView(callflowView, false); + + KernelListView kernelListView = new KernelListView( + lefttabView.getContentComposite(), SWT.NONE); + lefttabView.addView(kernelListView, false); + } + + leftForm.setWeights(new int[] { 60, 40 }); + + rightForm = new SashForm(baseForm, SWT.VERTICAL); + DATabComposite tabView = new DATabComposite(rightForm, SWT.NONE); + addView(tabView); + { + SnapshotView snapshotView = new SnapshotView( + tabView.getContentComposite(), SWT.NONE, false, name); + snapshotView.setObservingViews(new String[] { KernelListView.ID }); + tabView.addView(snapshotView, false); + + CallstackView callstack = new CallstackView( + tabView.getContentComposite(), SWT.NONE); + callstack.setObservingViews(new String[] { KernelListView.ID }); + tabView.addView(callstack, false); + } + + KernelStatisticInfoView statInfo = new KernelStatisticInfoView( + rightForm, SWT.NONE); + addView(statInfo); + + rightForm.setWeights(new int[] { 50, 50 }); + baseForm.setWeights(new int[] { 75, 25 }); + } + + @Override + protected void setFormWeights() { + baseForm.setWeights(new int[] { 100 - wRate, wRate }); + rightForm.setWeights(new int[] { hRate, 100 - hRate }); + } + + @Override + public void updateLog(LogPackage logPack) { + kdataManager.pushLogPackage(logPack); + } + + @Override + public void clear() { + super.clear(); + if (kdataManager != null) + kdataManager.clear(); + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/KernelStatisticInfoView.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/KernelStatisticInfoView.java new file mode 100644 index 0000000..db84288 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/KernelStatisticInfoView.java @@ -0,0 +1,108 @@ +package org.tizen.dynamicanalyzer.ui.kernel; + +import org.eclipse.swt.SWT; +import org.eclipse.swt.layout.FillLayout; +import org.eclipse.swt.layout.FormAttachment; +import org.eclipse.swt.layout.FormData; +import org.eclipse.swt.layout.FormLayout; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Event; +import org.eclipse.swt.widgets.Label; +import org.eclipse.swt.widgets.Listener; +import org.eclipse.swt.widgets.ScrollBar; +import org.eclipse.swt.widgets.Text; +import org.tizen.dynamicanalyzer.common.CommonConstants; +import org.tizen.dynamicanalyzer.model.DAView; +import org.tizen.dynamicanalyzer.nl.KernelPageLabels; +import org.tizen.dynamicanalyzer.resources.ColorResources; +import org.tizen.dynamicanalyzer.resources.FontResources; +import org.tizen.dynamicanalyzer.ui.widgets.ViewContainer; + +public class KernelStatisticInfoView extends DAView { + public static final String ID = KernelStatisticInfoView.class.getName(); + + private Text detailText = null; + private Label labelMessage = null; + private int indexScrolledTop = 0; + + int[] innerMaxWeight = { 0, 100 }; + int[] outerMaxWeight = { 0, 100 }; + + public KernelStatisticInfoView(Composite parent, int style) { + super(parent, style); + this.setLayout(new FillLayout()); + + ViewContainer viewContainer = new ViewContainer(this, true); + viewContainer.setTitleText(KernelPageLabels.KERNEL_STATISTIC_TITLE); + setMaxWeight(innerMaxWeight, outerMaxWeight); + + Composite detailCom = viewContainer.getContentArea(); + detailCom.setBackground(ColorResources.VIEW_BG_COLOR); + detailCom.setLayout(new FormLayout()); + FormData labelData = new FormData(); + labelData.top = new FormAttachment(0, 0); + labelData.left = new FormAttachment(0, 0); + labelData.right = new FormAttachment(100, 0); + labelData.bottom = new FormAttachment(100, 0); + detailCom.setLayoutData(labelData); + + Composite contents = detailCom; + contents.setBackground(ColorResources.VIEW_BG_COLOR); + contents.setLayout(new FormLayout()); + + detailText = new Text(contents, SWT.BORDER | SWT.V_SCROLL + | SWT.H_SCROLL); + detailText.setBackground(ColorResources.VIEW_BG_COLOR); + detailText.setForeground(ColorResources.TABLE_CONTENTS_FONT_COLOR); + detailText.setFont(FontResources.DETAIL_INFO_FONT); + + FormData buttonData = new FormData(); + buttonData.top = new FormAttachment(labelMessage, 0); + buttonData.left = new FormAttachment(0, 0); + buttonData.right = new FormAttachment(100, 0); + buttonData.bottom = new FormAttachment(100, 0); + detailText.setLayoutData(buttonData); + + Listener listener = new Listener() { + public void handleEvent(Event e) { + indexScrolledTop = detailText.getTopIndex(); + } + }; + ScrollBar hBar = detailText.getHorizontalBar(); + if (hBar != null) { + hBar.addListener(SWT.Selection, listener); + } + ScrollBar vBar = detailText.getVerticalBar(); + if (vBar != null) { + vBar.addListener(SWT.Selection, listener); + } + + StringBuffer strDetailView = new StringBuffer(); + strDetailView.append(CommonConstants.NEW_LINE); +// strDetailView.append(leftFormAttachment +// + NetworkPageLabels.NETWORK_DETAILS_ADDRESS +// + heightFormAttachment); +// strDetailView.append(leftFormAttachment +// + NetworkPageLabels.NETWORK_DETAILS_RECV_SIZE +// + heightFormAttachment); +// strDetailView.append(leftFormAttachment +// + NetworkPageLabels.NETWORK_DETAILS_SEND_SIZE +// + heightFormAttachment); +// strDetailView.append(leftFormAttachment +// + NetworkPageLabels.NETWORK_DETAILS_TOTAL_USE_TIME +// + heightFormAttachment); +// strDetailView.append(leftFormAttachment +// + NetworkPageLabels.NETWORK_DETAILS_API_COUNT +// + heightFormAttachment); +// strDetailView.append(leftFormAttachment +// + NetworkPageLabels.NETWORK_DETAILS_FAILED_API_COUNT +// + heightFormAttachment); +// strDetailView.append(leftFormAttachment +// + NetworkPageLabels.NETWORK_DETAILS_PACKET_MESSAGE +// + heightFormAttachment); +// strDetailView.append(NetworkChartManager.getInstance() +// .getPacketMessage()); + detailText.setText(strDetailView.toString()); + } + +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/ContextDataDBInserter.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/ContextDataDBInserter.java new file mode 100755 index 0000000..19325cf --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/ContextDataDBInserter.java @@ -0,0 +1,68 @@ +package org.tizen.dynamicanalyzer.ui.kernel.data; + +import java.util.List; + +import org.tizen.dynamicanalyzer.common.AnalyzerManager; +import org.tizen.dynamicanalyzer.sql.DBTableManager; +import org.tizen.dynamicanalyzer.sql.SqlManager; + +public class ContextDataDBInserter implements Runnable { + private static KernelBlockingQueue>> contextDataQueue = new KernelBlockingQueue>>(); + + private static volatile Thread inserterThread = null; + + public static void startThread() { + if (inserterThread == null || !inserterThread.isAlive()) { + synchronized (ContextDataDBInserter.class) { + if (inserterThread == null || !inserterThread.isAlive()) { + inserterThread = new Thread(null, + new ContextDataDBInserter()); + inserterThread.start(); + } + } + } + } + + public static void stopThread() { + if (inserterThread != null && inserterThread.isAlive()) { + try { + sendNotify(); + inserterThread.join(AnalyzerManager.THREAD_JOIN_WAIT_TIME); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + } + + public static void pushContextData(List> data) { + contextDataQueue.offer(data); + } + + public static void clear() { + stopThread(); + } + + @Override + public void run() { + while (!AnalyzerManager.isExit()) { + List> contextData = contextDataQueue.poll(); + + if (contextData != null) { + SqlManager + .getInstance() + .insertQuery( + DBTableManager + .getInstance() + .getTableInfo( + DBTableManager.TABLE_INDEX_CONTEXT_SWITCH_DATA) + .insertQuery(), contextData); + } + } + } + + public static void sendNotify() { + synchronized (contextDataQueue) { + contextDataQueue.notifyAll(); + } + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/FunctionDataDBInserter.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/FunctionDataDBInserter.java new file mode 100755 index 0000000..f345e21 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/FunctionDataDBInserter.java @@ -0,0 +1,68 @@ +package org.tizen.dynamicanalyzer.ui.kernel.data; + +import java.util.List; + +import org.tizen.dynamicanalyzer.common.AnalyzerManager; +import org.tizen.dynamicanalyzer.sql.DBTableManager; +import org.tizen.dynamicanalyzer.sql.SqlManager; + +public class FunctionDataDBInserter implements Runnable { + private static KernelBlockingQueue>> functionDataQueue = new KernelBlockingQueue>>(); + + private static volatile Thread inserterThread = null; + + public static void startThread() { + if (inserterThread == null || !inserterThread.isAlive()) { + synchronized (FunctionDataDBInserter.class) { + if (inserterThread == null || !inserterThread.isAlive()) { + inserterThread = new Thread(null, + new FunctionDataDBInserter()); + inserterThread.start(); + } + } + } + } + + public static void stopThread() { + if (inserterThread != null && inserterThread.isAlive()) { + try { + sendNotify(); + inserterThread.join(AnalyzerManager.THREAD_JOIN_WAIT_TIME); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + } + + public static void pushFunctionData(List> data) { + functionDataQueue.offer(data); + } + + public static void clear() { + stopThread(); + } + + @Override + public void run() { + while (!AnalyzerManager.isExit()) { + List> functionData = functionDataQueue.poll(); + + if (functionData != null) { + SqlManager + .getInstance() + .insertQuery( + DBTableManager + .getInstance() + .getTableInfo( + DBTableManager.TABLE_INDEX_FUNCTION_CALL_DATA) + .insertQuery(), functionData); + } + } + } + + public static void sendNotify() { + synchronized (functionDataQueue) { + functionDataQueue.notifyAll(); + } + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelBlockingQueue.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelBlockingQueue.java new file mode 100755 index 0000000..20d2e6f --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelBlockingQueue.java @@ -0,0 +1,31 @@ +package org.tizen.dynamicanalyzer.ui.kernel.data; + +import java.util.concurrent.ConcurrentLinkedQueue; + +public class KernelBlockingQueue { + private ConcurrentLinkedQueue dataQueue; + + public KernelBlockingQueue() { + dataQueue = new ConcurrentLinkedQueue(); + } + + public synchronized E poll() { + while (dataQueue.isEmpty()) { + try { + wait(); + } catch (InterruptedException e) { + e.printStackTrace(); + break; + } + } + + E data = dataQueue.poll(); + + return data; + } + + public synchronized void offer(E data) { + dataQueue.offer(data); + notifyAll(); + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataMaker.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataMaker.java new file mode 100755 index 0000000..28b0ff4 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataMaker.java @@ -0,0 +1,329 @@ +package org.tizen.dynamicanalyzer.ui.kernel.data; + +import java.util.ArrayList; +import java.util.List; +import java.util.Stack; + +import org.tizen.dynamicanalyzer.sql.DBTableInfo; +import org.tizen.dynamicanalyzer.sql.DBTableManager; +import org.tizen.dynamicanalyzer.sql.SqlManager; +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; + +public class KernelDataMaker { + public static final int START_TYPE_START = 10; + public static final int START_TYPE_RESUME = 20; + public static final int START_TYPE_RETURNED = 30; + public static final int END_TYPE_END = 1; + public static final int END_TYPE_PAUSED = 2; + public static final int END_TYPE_CALL = 3; + + private static KernelDataMaker instance = null; + + // 'threads' may be necessary to synchronize but i didn't + // because i think that it does not make critical error + private ArrayList threads; + + private ArrayList> contextDataList; + private ArrayList> functionDataList; + + public KernelDataMaker() { + threads = new ArrayList(); + + contextDataList = new ArrayList>(); + functionDataList = new ArrayList>(); + } + + public synchronized static KernelDataMaker getInstance() { + if (instance == null) { + instance = new KernelDataMaker(); + } + + return instance; + } + + private KernelDataPerThread findKernelData(int tid) { + int size = threads.size(); + + for (int i = 0; i < size; i++) { + KernelDataPerThread kdata = threads.get(i); + if (kdata.getTid() == tid) { + return kdata; + } + } + + return null; + } + + public void makeData(List inputs) { + Stack prefunc; + Stack prefunc_type; + + int size = inputs.size(); + for (int i = 0; i < size; i++) { + LogData input = (LogData) inputs.get(i); + + switch (input.getId()) { + case DataChannelConstants.MSG_CONTEXT_SWITCH_ENTRY: { + ContextSwitchData csdata = (ContextSwitchData) input; + int tid = csdata.getTid(); + + KernelDataPerThread kdata = findKernelData(tid); + if (kdata == null) { // thread id is not exist in thread id + kdata = new KernelDataPerThread(csdata.getPid(), tid, + csdata); + threads.add(kdata); + } else { // thread id is exist in thread id array + if (kdata.getCorelog() != null) { + // TODO : error + System.out + .println("[ERR] context switch entry log is coming without exit log of previous context"); + } else { + kdata.setCorelog(csdata); + + prefunc = kdata.getFunclog(); + prefunc_type = kdata.getFunclogType(); + + if (prefunc != null) { + ProfileData pfdata = prefunc.peek(); + pfdata.setTime(csdata.getTime()); + pfdata.setPcAddr(csdata.getPcAddr()); + pfdata.setCpuNum(csdata.getCpuNum()); + + prefunc_type.set(prefunc_type.size() - 1, + START_TYPE_RESUME); + } + } + } + break; + } + case DataChannelConstants.MSG_CONTEXT_SWITCH_EXIT: { + ContextSwitchData csdata = (ContextSwitchData) input; + ContextSwitchData precore; + int tid = csdata.getTid(); + + KernelDataPerThread kdata = findKernelData(tid); + if (kdata == null) { // thread id is not exist + // TODO : error + System.out + .println("[ERR] context switch exit log is coming without any entry log"); + } else if ((precore = kdata.getCorelog()) == null) { + // TODO : error + System.out + .println("[ERR] context switch exit log is coming without corresponding entry log"); + } else if (precore.getCpuNum() != csdata.getCpuNum()) { + // TODO : error + System.out + .println("[ERR] context switch exit log is coming with different cpu num"); + } else { + kdata.setCorelog(null); + + ArrayList dbdata = new ArrayList(); + dbdata.add(String.valueOf(precore.getSeq())); + dbdata.add(String.valueOf(precore.getPid())); + dbdata.add(String.valueOf(precore.getTid())); + dbdata.add(String.valueOf(precore.getCpuNum())); + dbdata.add(String.valueOf(precore.getTime())); + dbdata.add(String.valueOf(precore.getPcAddr())); + dbdata.add(String.valueOf(csdata.getTime())); + dbdata.add(String.valueOf(csdata.getPcAddr())); + contextDataList.add(dbdata); + + prefunc = kdata.getFunclog(); + prefunc_type = kdata.getFunclogType(); + if (prefunc != null) { + if (prefunc.isEmpty() || prefunc_type.isEmpty()) { + System.out + .println("[WRN] context switch exit log is coming but there is no function in stack"); + } else { + ProfileData lastfunc = prefunc.peek(); + int lastfunc_type = prefunc_type.peek(); + + ArrayList dbfuncdata = new ArrayList(); + dbfuncdata.add(String.valueOf(csdata.getSeq())); + dbfuncdata.add(String.valueOf(csdata.getPid())); + dbfuncdata.add(String.valueOf(csdata.getTid())); + dbfuncdata.add(String.valueOf(csdata.getCpuNum())); + dbfuncdata.add(String.valueOf(lastfunc.getTime())); + dbfuncdata.add(String.valueOf(lastfunc_type)); + dbfuncdata + .add(String.valueOf(lastfunc.getPcAddr())); + dbfuncdata.add(String.valueOf(csdata.getTime())); + dbfuncdata.add(String.valueOf(END_TYPE_PAUSED)); + dbfuncdata.add(String.valueOf(csdata.getPcAddr())); + dbfuncdata.add(lastfunc.getApiName()); + functionDataList.add(dbfuncdata); + } + } + } + break; + } + case DataChannelConstants.MSG_FUNCTION_ENTRY: { + ProfileData fndata = (ProfileData) input; + int tid = fndata.getTid(); + + KernelDataPerThread kdata = findKernelData(tid); + if (kdata == null) { + // TODO : error + System.out + .println("[ERR] function entry log is coming without any context entry log"); + } else { + assert (kdata.getCorelog() != null); + if (kdata.getFunclog() == null) { + kdata.createFunctionStack(); + } + + prefunc = kdata.getFunclog(); + prefunc_type = kdata.getFunclogType(); + assert (prefunc != null && prefunc_type != null); + + if (prefunc.isEmpty()) { + assert (prefunc_type.isEmpty()); + + prefunc.push(fndata); + prefunc_type.push(START_TYPE_START); + } else { + ProfileData lastfunc = prefunc.peek(); + int lastfunc_type = prefunc_type.peek(); + + ArrayList dbfuncdata = new ArrayList(); + dbfuncdata.add(String.valueOf(fndata.getSeq())); + dbfuncdata.add(String.valueOf(fndata.getPid())); + dbfuncdata.add(String.valueOf(fndata.getTid())); + dbfuncdata.add(String.valueOf(fndata.getCpuNum())); + dbfuncdata.add(String.valueOf(lastfunc.getTime())); + dbfuncdata.add(String.valueOf(lastfunc_type)); + dbfuncdata.add(String.valueOf(lastfunc.getPcAddr())); + dbfuncdata.add(String.valueOf(fndata.getTime())); + dbfuncdata.add(String.valueOf(END_TYPE_CALL)); + dbfuncdata.add(String.valueOf(fndata.getPcAddr())); + dbfuncdata.add(lastfunc.getApiName()); + functionDataList.add(dbfuncdata); + + prefunc.push(fndata); + prefunc_type.push(START_TYPE_START); + } + } + break; + } + case DataChannelConstants.MSG_FUNCTION_EXIT: { + ProfileData fndata = (ProfileData) input; + int tid = fndata.getTid(); + + KernelDataPerThread kdata = findKernelData(tid); + if (kdata == null) { + // TODO : error + System.out + .println("[ERR] function entry log is coming without any context entry log"); + } else { + assert (kdata.getCorelog() != null); + if (kdata.getFunclog() == null) { + kdata.createFunctionStack(); + } + + prefunc = kdata.getFunclog(); + prefunc_type = kdata.getFunclogType(); + assert (prefunc != null && prefunc_type != null); + + if (prefunc.isEmpty() || prefunc_type.isEmpty()) { + // TODO : error + System.out + .println("[ERR] function exit log is coming without function entry log"); + } else { + ProfileData lastfunc = prefunc.pop(); + int lastfunc_type = prefunc_type.pop(); + + assert (lastfunc.getApiName() == fndata.getApiName()); + + ArrayList dbfuncdata = new ArrayList(); + dbfuncdata.add(String.valueOf(fndata.getSeq())); + dbfuncdata.add(String.valueOf(fndata.getPid())); + dbfuncdata.add(String.valueOf(fndata.getTid())); + dbfuncdata.add(String.valueOf(fndata.getCpuNum())); + dbfuncdata.add(String.valueOf(lastfunc.getTime())); + dbfuncdata.add(String.valueOf(lastfunc_type)); + dbfuncdata.add(String.valueOf(lastfunc.getPcAddr())); + dbfuncdata.add(String.valueOf(fndata.getTime())); + dbfuncdata.add(String.valueOf(END_TYPE_END)); + dbfuncdata.add(String.valueOf(fndata.getPcAddr())); + dbfuncdata.add(lastfunc.getApiName()); + functionDataList.add(dbfuncdata); + + prefunc.peek().setTime(fndata.getTime()); + prefunc.peek().setPcAddr(fndata.getPcAddr()); + prefunc_type.set(prefunc_type.size() - 1, + START_TYPE_RETURNED); + } + } + break; + } + default: + break; + } + } + + @SuppressWarnings("unchecked") + List> clist = (List>) contextDataList.clone(); + contextDataList.clear(); + + @SuppressWarnings("unchecked") + List> flist = (List>) functionDataList + .clone(); + functionDataList.clear(); + + ContextDataDBInserter.pushContextData(clist); + ContextDataDBInserter.startThread(); + FunctionDataDBInserter.pushFunctionData(flist); + FunctionDataDBInserter.startThread(); + } + + public void clear() { + threads.clear(); + contextDataList.clear(); + functionDataList.clear(); + } + + public List> getContextDataFromDB(long start, long end) { + DBTableManager dbManager = DBTableManager.getInstance(); + DBTableInfo csTable = dbManager + .getTableInfo(DBTableManager.TABLE_INDEX_CONTEXT_SWITCH_DATA); + SqlManager sql = SqlManager.getInstance(); + + String where = "where " + DBTableManager.CUSTOM_COLUMN_START_TIME + + " < " + end + " and " + DBTableManager.CUSTOM_COLUMN_END_TIME + + " > " + start + " order by " + + DBTableManager.CUSTOM_COLUMN_START_TIME; + + String[] csColumns = csTable.getColumnNames(); + + List> queriedContextData = sql.selectQuery(null, + csColumns, csTable.getTableName(), where); + + return queriedContextData; + } + + public List> getFunctionDataFromDB(long start, long end) { + DBTableManager dbManager = DBTableManager.getInstance(); + DBTableInfo fnTable = dbManager + .getTableInfo(DBTableManager.TABLE_INDEX_FUNCTION_CALL_DATA); + SqlManager sql = SqlManager.getInstance(); + + String where = "where " + DBTableManager.CUSTOM_COLUMN_START_TIME + + " < " + end + " and " + DBTableManager.CUSTOM_COLUMN_END_TIME + + " > " + start + " order by " + + DBTableManager.CUSTOM_COLUMN_START_TIME; + + String[] fnColumns = fnTable.getColumnNames(); + + List> queriedFunctionData = sql.selectQuery(null, + fnColumns, fnTable.getTableName(), where); + + return queriedFunctionData; + } + + public List getThreadData() { + return threads; + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataManager.java new file mode 100644 index 0000000..e27ca8a --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataManager.java @@ -0,0 +1,143 @@ +package org.tizen.dynamicanalyzer.ui.kernel.data; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import java.util.PriorityQueue; +import org.tizen.dynamicanalyzer.common.AnalyzerConstants; +import org.tizen.dynamicanalyzer.common.AnalyzerManager; +import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants; +import org.tizen.dynamicanalyzer.swap.logparser.LogPackage; +import org.tizen.dynamicanalyzer.swap.model.data.LogData; +import org.tizen.dynamicanalyzer.swap.model.data.LogDataTimeComparator; + +public class KernelDataManager implements Runnable { + private static KernelDataManager instance = null; + + private Thread updateLogThread = null; + private KernelBlockingQueue logPackQueue = null; + private KernelDataMaker kdataMaker = null; + + public KernelDataManager() { + logPackQueue = new KernelBlockingQueue(); + kdataMaker = KernelDataMaker.getInstance(); + } + + public synchronized static KernelDataManager getInstance() { + if (null == instance) { + instance = new KernelDataManager(); + } + return instance; + } + + public void pushLogPackage(LogPackage pack) { + logPackQueue.offer(pack); + } + + @Override + public void run() { + while (!AnalyzerManager.isExit()) { + LogPackage pack = logPackQueue.poll(); + if (null == pack) { + break; + } + + ArrayList logs = getLogsFromLogPackage(pack); + if (!logs.isEmpty()) + kdataMaker.makeData(logs); + } + + /* log for debug */ + System.out.println("kernel chart manager thread end!!"); //$NON-NLS-1$ + } + + public void startUpdateLogThread() { + if (null == updateLogThread || !updateLogThread.isAlive()) { + updateLogThread = new Thread(null, this, + AnalyzerConstants.KERNEL_CHART_MANAGER_THREAD); + updateLogThread.start(); + } + } + + public void stopUpdateLogThread() { + if (null != updateLogThread && updateLogThread.isAlive()) { + try { + sendNotify(); + updateLogThread.join(AnalyzerManager.THREAD_JOIN_WAIT_TIME); + System.out.println("thread chart manager joined!"); //$NON-NLS-1$ + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + } + + public void sendNotify() { + synchronized (logPackQueue) { + logPackQueue.notifyAll(); + } + } + + public void clear() { + kdataMaker.clear(); + } + + private ArrayList getLogsFromLogPackage(LogPackage logPack) { + List contextEntryLogs = logPack.getLogs( + DataChannelConstants.MSG_CONTEXT_SWITCH_ENTRY).getCloneLogs(); + List contextExitLogs = logPack.getLogs( + DataChannelConstants.MSG_CONTEXT_SWITCH_EXIT).getCloneLogs(); + List functionEntryLogs = logPack.getLogs( + DataChannelConstants.MSG_FUNCTION_ENTRY).getCloneLogs(); + List functionExitLogs = logPack.getLogs( + DataChannelConstants.MSG_FUNCTION_EXIT).getCloneLogs(); + + ArrayList kernelLogs = new ArrayList(); + PriorityQueue pqueue = new PriorityQueue(5, + new LogDataTimeComparator()); + + Iterator centryiter = contextEntryLogs.iterator(); + Iterator cexititer = contextExitLogs.iterator(); + Iterator fentryiter = functionEntryLogs.iterator(); + Iterator fexititer = functionExitLogs.iterator(); + + if (centryiter.hasNext()) + pqueue.offer(centryiter.next()); + if (cexititer.hasNext()) + pqueue.offer(cexititer.next()); + if (fentryiter.hasNext()) + pqueue.offer(fentryiter.next()); + if (fexititer.hasNext()) + pqueue.offer(fexititer.next()); + + do { + LogData top = pqueue.poll(); + if (top == null) + break; + + switch (top.getId()) { + case DataChannelConstants.MSG_CONTEXT_SWITCH_ENTRY: + if (centryiter.hasNext()) + pqueue.offer(centryiter.next()); + break; + case DataChannelConstants.MSG_CONTEXT_SWITCH_EXIT: + if (cexititer.hasNext()) + pqueue.offer(cexititer.next()); + break; + case DataChannelConstants.MSG_FUNCTION_ENTRY: + if (fentryiter.hasNext()) + pqueue.offer(fentryiter.next()); + break; + case DataChannelConstants.MSG_FUNCTION_EXIT: + if (fexititer.hasNext()) + pqueue.offer(fexititer.next()); + break; + default: + break; + } + + kernelLogs.add(top); + } while (true); + + return kernelLogs; + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataPerThread.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataPerThread.java new file mode 100644 index 0000000..062657e --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataPerThread.java @@ -0,0 +1,75 @@ +package org.tizen.dynamicanalyzer.ui.kernel.data; + +import java.util.Stack; + +import org.tizen.dynamicanalyzer.swap.model.data.ContextSwitchData; +import org.tizen.dynamicanalyzer.swap.model.data.ProfileData; +import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoardItem; + +public class KernelDataPerThread { + private int pid; + private int tid; + private ContextSwitchData core_log; + private Stack func_log = null; + private Stack func_log_type = null; + + private DAChartBoardItem contextChart = null; + private DAChartBoardItem functionChart = null; + + public KernelDataPerThread(int pid, int tid) { + this.pid = pid; + this.tid = tid; + core_log = null; + } + + public KernelDataPerThread(int pid, int tid, ContextSwitchData corelog) { + this.pid = pid; + this.tid = tid; + core_log = corelog; + } + + public void createFunctionStack() { + func_log = new Stack(); + func_log_type = new Stack(); + } + + public int getPid() { + return pid; + } + + public int getTid() { + return tid; + } + + public ContextSwitchData getCorelog() { + return core_log; + } + + public Stack getFunclog() { + return func_log; + } + + public Stack getFunclogType() { + return func_log_type; + } + + public void setCorelog(ContextSwitchData corelog) { + core_log = corelog; + } + + public DAChartBoardItem getContextChart() { + return contextChart; + } + + public void setContextChart(DAChartBoardItem contextChart) { + this.contextChart = contextChart; + } + + public DAChartBoardItem getFunctionChart() { + return functionChart; + } + + public void setFunctionChart(DAChartBoardItem functionChart) { + this.functionChart = functionChart; + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataPerThreadComparator.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataPerThreadComparator.java new file mode 100644 index 0000000..b7c5445 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/kernel/data/KernelDataPerThreadComparator.java @@ -0,0 +1,23 @@ +package org.tizen.dynamicanalyzer.ui.kernel.data; + +import java.util.Comparator; + +public class KernelDataPerThreadComparator implements + Comparator { + + @Override + public int compare(KernelDataPerThread o1, KernelDataPerThread o2) { + if (o1.getPid() < o2.getPid()) + return -1; + else if (o1.getPid() > o2.getPid()) + return 1; + else { + if (o1.getTid() < o2.getTid()) + return -1; + else if (o1.getTid() > o2.getTid()) + return 1; + else + return 0; + } + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/page/BaseView.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/page/BaseView.java old mode 100644 new mode 100755 index 9c41ee8..53cb9b8 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/page/BaseView.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/page/BaseView.java @@ -34,6 +34,7 @@ import org.eclipse.swt.widgets.Display; import org.eclipse.ui.part.ViewPart; import org.tizen.dynamicanalyzer.model.DAView; 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.ui.opengl.ui.GLPage; import org.tizen.dynamicanalyzer.ui.summary.SummaryPage; @@ -78,6 +79,10 @@ public class BaseView extends ViewPart { Composite graphicsPage = new GLPage( tabView.getContentComposite(), SWT.NONE); tabView.addView(graphicsPage, false); + +// Composite kernelPage = new KernelPage( +// tabView.getContentComposite(), SWT.NONE); +// tabView.addView(kernelPage, false); Composite summaryPage = new SummaryPage( tabView.getContentComposite(), SWT.NONE); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/CPUCoreChart.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/CPUCoreChart.java index 5286f4b..d6e5d8c 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/CPUCoreChart.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/CPUCoreChart.java @@ -41,6 +41,9 @@ import org.tizen.dynamicanalyzer.swap.logparser.LogPackage; import org.tizen.dynamicanalyzer.swap.logparser.Logs; import org.tizen.dynamicanalyzer.swap.model.data.LogData; import org.tizen.dynamicanalyzer.swap.model.data.SystemData; +import org.tizen.dynamicanalyzer.ui.kernel.CallFlowChartRenderer; +import org.tizen.dynamicanalyzer.ui.kernel.ContextSwitchingChartRenderer; +import org.tizen.dynamicanalyzer.ui.kernel.ContextSwitchingChartSeriesItem; import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants; import org.tizen.dynamicanalyzer.utils.Formatter; import org.tizen.dynamicanalyzer.widgets.chart.DAChart; @@ -143,7 +146,7 @@ public class CPUCoreChart extends TimelineChart { // function DAChartBoardHeightChangeableItem functionItem = new DAChartBoardHeightChangeableItem( - item, "function"); + coreItem, "function"); DAChartSeries functionSeries = new DAChartSeries("function", -1, ColorResources.RED); -- 2.7.4