});
nameCell = new Canvas(this, SWT.NONE);
+ if (parent.getDepth() == 0) {
+ nameCell.setBackgroundImage(ImageResources.CHART_NAME_BG_NORMAL);
+ } else {
+ nameCell.setBackgroundImage(ImageResources.CHART_NAME_CHILD_BG_NORMAL);
+ }
nameCell.addPaintListener(new PaintListener() {
@Override
public void paintControl(PaintEvent e) {
Rectangle rect = ((Canvas) (e.widget)).getClientArea();
- if (parent.getDepth() == 0) {
- if (false == isSelectCell()) {
- e.gc.setForeground(ColorResources.CHART_NAME_BACK_START); // FIXME
- e.gc.setBackground(ColorResources.CHART_NAME_BACK_END); // FIXME
- } else {
- e.gc.setForeground(ColorResources.CHART_NAME_SELECT_BACK_START); // FIXME
- e.gc.setBackground(ColorResources.CHART_NAME_SELECT_BACK_END); // FIXME
- }
- } else {
- e.gc.setForeground(ColorResources.CHART_NAME_CHILD_BACK); // FIXME
- e.gc.setBackground(ColorResources.CHART_NAME_CHILD_BACK);
- }
- e.gc.fillGradientRectangle(rect.x, rect.y, rect.width,
- rect.height, true);
+
e.gc.setForeground(ColorResources.BLACK);
e.gc.setFont(FontResources.CHART_ITEM_NAME_FONT);
drawNameString(e.gc, parent.getItemName(), rect.width / 2,
ImageResources.TREE_FOLD, ImageResources.TREE_FOLD,
ImageResources.TREE_FOLD, null, ImageResources.TREE_OPEN,
ImageResources.TREE_OPEN);
- childExpandButton
- .setBackground(ColorResources.CHART_BOARD_ITEM_NAME_FOLD_BG);
Rectangle rt = nameCell.getClientArea();
childExpandButton.setBounds(rt.x + DEFAULT_TOGGLE_BUTTON_SIZE
- DEFAULT_TOGGLE_BUTTON_MARGIN, rt.height / 2
@Override
public void handleClickEvent(DACustomButton button) {
if (true == childExpandButton.isToggled()) {
- childExpandButton.setImages(
- ImageResources.TREE_FOLD,
- ImageResources.TREE_OPEN,
- ImageResources.TREE_OPEN, null);
+ parent.callbackSelect();
parent.callbackUnFold();
+ nameCell.redraw();
} else {
- childExpandButton.setImages(
- ImageResources.TREE_FOLD,
- ImageResources.TREE_FOLD,
- ImageResources.TREE_FOLD, null);
+ parent.callbackSelect();
parent.callbackFold();
+ nameCell.redraw();
}
}
});
return;
}
Point allp = gc.textExtent(name, SWT.DRAW_DELIMITER);
-
+
String[] temp = name.split("\n");
int lineLength = temp.length;
- Point[] p = new Point[lineLength];
-
+ Point[] p = new Point[lineLength];
+
int startY = pixcelY - allp.y / 2;
-
- for(int i=0; i<lineLength; i++){
+
+ for (int i = 0; i < lineLength; i++) {
p[i] = gc.textExtent(temp[i]);
gc.drawText(temp[i], pixcelX - p[i].x / 2, startY, true);
startY += p[i].y;
public void setSelectCell(boolean selectCell) {
this.selectCell = selectCell;
+ if (true == selectCell) {
+ if (parent.getDepth() == 0) {
+ nameCell.setBackgroundImage(ImageResources.CHART_NAME_BG_SELECT);
+ } else {
+ nameCell.setBackgroundImage(ImageResources.CHART_NAME_CHILD_BG_SELECT);
+ }
+ } else {
+ if (parent.getDepth() == 0) {
+ nameCell.setBackgroundImage(ImageResources.CHART_NAME_BG_NORMAL);
+ } else {
+ nameCell.setBackgroundImage(ImageResources.CHART_NAME_CHILD_BG_NORMAL);
+ }
+ }
nameCell.redraw();
}
}
"chart_name_back_select_start", new RGB(180, 242, 254)); //$NON-NLS-1$\r
public static Color CHART_NAME_SELECT_BACK_END = getColor(\r
"chart_name_back_select_end", new RGB(56, 178, 208)); //$NON-NLS-1$\r
- public static Color CHART_NAME_CHILD_BACK = getColor(\r
- "chart_name_child_back", new RGB(103, 103, 103)); //$NON-NLS-1$\r
\r
public static Color UI_EVENT_CHART_SEPERATE_LINE = getColor(\r
"UI_event_chart_seperate_line", new RGB(189, 207, 213)); //$NON-NLS-1$\r
/* chart */
public static final Image CHART_EVENT_CALLEE_ARW = getPngImage("event_callee_arw"); //$NON-NLS-1$
public static final Image CHART_BG_SELECT = getPngImage("timeline_right_bg_selected"); //$NON-NLS-1$
+ public static final Image CHART_NAME_BG_NORMAL = getPngImage("timeline_left_bg_normal"); //$NON-NLS-1$
+ public static final Image CHART_NAME_BG_SELECT = getPngImage("timeline_left_bg_selected"); //$NON-NLS-1$
+ public static final Image CHART_NAME_CHILD_BG_NORMAL = getPngImage("timeline_left_child_bg_normal"); //$NON-NLS-1$
+ public static final Image CHART_NAME_CHILD_BG_SELECT = getPngImage("timeline_left_child_bg_selected"); //$NON-NLS-1$
/*** scale ***/
public static final Image SCALE_CONTROL_MINUS = getPngImage("scale_control_minus"); //$NON-NLS-1$
--- /dev/null
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<BaseLogCenter xmlns="org.tizen.dynamicanalyzer">
+ <id>14</id>
+ <name>synchronization</name>
+ <totalColumnCount>17</totalColumnCount>
+ <customColumn>false</customColumn>
+
+ <ColumnName>Rid</ColumnName>
+ <ColumnName>ID</ColumnName>
+ <ColumnName>SeqNumber</ColumnName>
+ <ColumnName>APIName</ColumnName>
+ <ColumnName>Time</ColumnName>
+
+ <ColumnName>Pid</ColumnName>
+ <ColumnName>Tid</ColumnName>
+ <ColumnName>InputParam</ColumnName>
+ <ColumnName>Return</ColumnName>
+ <ColumnName>PCAddr</ColumnName>
+ <!-- 10 -->
+ <ColumnName>Error</ColumnName>
+ <ColumnName>InternalCall</ColumnName>
+ <ColumnName>CallerPCAddr</ColumnName>
+ <ColumnName>SyncVal</ColumnName>
+ <ColumnName>SyncType</ColumnName>
+
+ <ColumnName>ApiType</ColumnName>
+ <ColumnName>Reserved</ColumnName>
+
+ <type>INTEGER</type>
+ <type>INTEGER</type>
+ <type>INTEGER PRIMARY KEY NOT NULL</type>
+ <type>TEXT</type>
+ <type>INTEGER</type>
+
+ <type>INTEGER</type>
+ <type>INTEGER</type>
+ <type>TEXT</type>
+ <type>TEXT</type>
+ <type>TEXT</type>
+
+ <type>INTEGER</type>
+ <type>INTEGER</type>
+ <type>INTEGER</type>
+ <type>INTEGER</type>
+ <type>INTEGER</type>
+
+ <type>INTEGER</type>
+ <type>TEXT</type>
+
+ <ColumnSize>100</ColumnSize>
+ <ColumnSize>0</ColumnSize>
+ <ColumnSize>0</ColumnSize>
+ <ColumnSize>0</ColumnSize>
+ <ColumnSize>0</ColumnSize>
+
+
+ <ColumnOrder>0</ColumnOrder>
+ <ColumnOrder>1</ColumnOrder>
+ <ColumnOrder>2</ColumnOrder>
+ <ColumnOrder>4</ColumnOrder>
+ <ColumnOrder>3</ColumnOrder>
+
+ <ColumnOrder>13</ColumnOrder>
+ <ColumnOrder>14</ColumnOrder>
+ <ColumnOrder>12</ColumnOrder>
+ <ColumnOrder>11</ColumnOrder>
+ <ColumnOrder>9</ColumnOrder>
+
+ <ColumnOrder>7</ColumnOrder>
+ <ColumnOrder>8</ColumnOrder>
+ <ColumnOrder>10</ColumnOrder>
+ <ColumnOrder>5</ColumnOrder>
+ <ColumnOrder>6</ColumnOrder>
+
+ <ColumnOrder>15</ColumnOrder>
+ <ColumnOrder>16</ColumnOrder>
+
+
+ <ColumnVisibility>false</ColumnVisibility>
+ <ColumnVisibility>false</ColumnVisibility>
+ <ColumnVisibility>true</ColumnVisibility>
+ <ColumnVisibility>true</ColumnVisibility>
+ <ColumnVisibility>true</ColumnVisibility>
+
+ <ColumnVisibility>true</ColumnVisibility>
+ <ColumnVisibility>true</ColumnVisibility>
+ <ColumnVisibility>true</ColumnVisibility>
+ <ColumnVisibility>true</ColumnVisibility>
+ <ColumnVisibility>false</ColumnVisibility>
+
+ <ColumnVisibility>true</ColumnVisibility>
+ <ColumnVisibility>true</ColumnVisibility>
+ <ColumnVisibility>true</ColumnVisibility>
+ <ColumnVisibility>false</ColumnVisibility>
+ <ColumnVisibility>false</ColumnVisibility>
+
+ <ColumnVisibility>false</ColumnVisibility>
+ <ColumnVisibility>false</ColumnVisibility>
+
+ <TableColumnName>Row Id</TableColumnName>
+ <TableColumnName>ID</TableColumnName>
+ <TableColumnName>#</TableColumnName>
+ <TableColumnName>API name</TableColumnName>
+ <TableColumnName>Time</TableColumnName>
+
+ <TableColumnName>Process id</TableColumnName>
+ <TableColumnName>Thread id</TableColumnName>
+ <TableColumnName>Input parm</TableColumnName>
+ <TableColumnName>Return</TableColumnName>
+ <TableColumnName>PC Addr</TableColumnName>
+
+ <TableColumnName>Errno</TableColumnName>
+ <TableColumnName>Internal Call</TableColumnName>
+ <TableColumnName>Caller PC Address</TableColumnName>
+ <TableColumnName>Sync val</TableColumnName>
+ <TableColumnName>Sync type</TableColumnName>
+
+ <TableColumnName>Api type</TableColumnName>
+ <TableColumnName>Reserved</TableColumnName>
+</BaseLogCenter>
\ No newline at end of file
<ColumnOrder>15</ColumnOrder>
<ColumnOrder>16</ColumnOrder>
<ColumnOrder>17</ColumnOrder>
- <ColumnOrder>18</ColumnOrder>
<ColumnVisibility>false</ColumnVisibility>
public static final int LOG_THREAD = 12;
// public static final int LOG_SYSTEM = 12;
public static final int LOG_CUSTOM_CHART = 13;
+ public static final int LOG_SYNC = 14;
public static final int TYPE_CALLSTACK = 99;
public static final int CUSTOM_CHART_COLOR = 15;
public static final int CUSTOM_CHART_VALUE = 16;
public static final int CUSTOM_CHART_RESERVED = 17;
+
+ /* synchronization log : 14 */
+ public static final int SYNC_VAL_INDEX = 12;
+ public static final int SYNC_TYPE_INDEX = 13;
+ public static final int SYNC_API_TYPE_INDEX = 14;
+
+ public static final int SYNC_TYPE_OSP_MUTEX = 0;
+ public static final int SYNC_TYPE_OSP_MONITOR = 1;
+ public static final int SYNC_TYPE_OSP_SEMAPHORE = 2;
+ public static final int SYNC_TYPE_PTHREAD_MUTEX = 3;
+ public static final int SYNC_TYPE_PTHREAD_COND_VARIABLE = 4;
+ public static final int SYNC_TYPE_PTHREAD_RWLOCK = 5;
+ public static final int SYNC_TYPE_PTHREAD_SPINLOCK = 6;
+ public static final int SYNC_TYPE_PTHREAD_BARRIER = 7;
+
+ public static final int SYNC_API_TYPE_NEW = 0;
+ public static final int SYNC_API_TYPE_ACQUIRE_WAIT_START = 1;
+ public static final int SYNC_API_TYPE_ACQUIRE_WAIT_END = 2;
+ public static final int SYNC_API_TYPE_RELEASE = 3;
+ public static final int SYNC_API_TYPE_TRY_ACQUIRE = 4;
+ public static final int SYNC_API_TYPE_COND_WAIT_START = 5;
+ public static final int SYNC_API_TYPE_COND_WAIT_END = 6;
+ public static final int SYNC_API_TYPE_NOTIFY = 7;
+ public static final int SYNC_API_TYPE_NOTIFY_ALL = 8;
+ public static final int SYNC_API_TYPE_OTHER = 9;
/* Common Column Size */
public static final int COMMON_COLUMN_SIZE_RID = 80;
public static String THREAD_ITEM_TYPE_OSP;
public static String THREAD_ITEM_TYPE_PTHREAD;
+ public static String SYNC_TYPE_OSP_MUTEX;
+ public static String SYNC_TYPE_OSP_MONITOR;
+ public static String SYNC_TYPE_OSP_SEMAPHORE;
+ public static String SYNC_TYPE_PTHREAD_MUTEX;
+ public static String SYNC_TYPE_PTHREAD_COND_VARIABLE;
+ public static String SYNC_TYPE_PTHREAD_RWLOCK;
+ public static String SYNC_TYPE_PTHREAD_SPINLOCK;
+ public static String SYNC_TYPE_PTHREAD_BARRIER;
+
public static String THREAD_API_JOIN;
public static String THREAD_CHART_NAME_PREFIX;
public static String THREAD_CHART_NAME_POSTFIX;
+
+ public static String THREAD_SYNC_CHART_SERIES_STATE;
/* Thread API List view */
public static String THREAD_API_LIST_VEIW_TITLE;
THREAD_ITEM_TYPE_OSP=OSP
THREAD_ITEM_TYPE_PTHREAD=pthread
+SYNC_TYPE_OSP_MUTEX=OSP mutex
+SYNC_TYPE_OSP_MONITOR=OSP monitor
+SYNC_TYPE_OSP_SEMAPHORE=OSP semaphore
+SYNC_TYPE_PTHREAD_MUTEX=pthread mutex
+SYNC_TYPE_PTHREAD_COND_VARIABLE=pthread \ncond variable
+SYNC_TYPE_PTHREAD_RWLOCK=pthread rwlock
+SYNC_TYPE_PTHREAD_SPINLOCK=pthread spinlock
+SYNC_TYPE_PTHREAD_BARRIER=pthread barrier
+
THREAD_API_JOIN=Thread::Join
THREAD_CHART_NAME_PREFIX=\n(
THREAD_CHART_NAME_POSTFIX=)
+THREAD_SYNC_CHART_SERIES_STATE=STATE
+
THREAD_API_LIST_VEIW_TITLE=Thread API List
THREAD_API_LIST_VIEW_INDEX=#
THREAD_API_LIST_VIEW_TIME=Time
THREAD_API_LIST_VIEW_ERRNO=Error Code
THREAD_DETAILS_TID=Thread ID :
-THREAD_DETAILS_TTYPE=Thread type :
\ No newline at end of file
+THREAD_DETAILS_TTYPE=Type :
\ No newline at end of file
public static final Image ADD_ITEMS_BAR = getPngImage("AddItems"); //$NON-NLS-1$\r
public static final Image MIN_ITEMS = getPngImage("MinItems"); //$NON-NLS-1$\r
public static final Image BG_GRADIENT = getPngImage("timeline_right_bg_normal"); //$NON-NLS-1$\r
+ public static final Image BG_CHILD_GRADIENT = getPngImage("timeline_right_child_bg_normal"); //$NON-NLS-1$\r
public static final Image TIMLINE_FULL = getPngImage("timeline_left_full_nor"); //$NON-NLS-1$\r
public static final Image TIMLINE_RESTORE = getPngImage("timeline_left_restore_nor"); //$NON-NLS-1$\r
public static final Image TIMLINE_SIZE_MIN_NORMAL = getPngImage("time_line_size_min_normal"); //$NON-NLS-1$\r
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
import org.tizen.dynamicanalyzer.model.TableInput;
import org.tizen.dynamicanalyzer.ui.thread.ThreadAPIListView;
-import org.tizen.dynamicanalyzer.ui.thread.ThreadPageThreadData;
-import org.tizen.dynamicanalyzer.ui.thread.ThreadPageThreadDataEvent;
+import org.tizen.dynamicanalyzer.ui.thread.ThreadPageData;
+import org.tizen.dynamicanalyzer.ui.thread.ThreadPageDataEvent;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableComposite;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableDataFormat;
import org.tizen.dynamicanalyzer.utils.Formatter;
if (!(view instanceof ThreadAPIListView)) {
return null;
}
- ThreadPageThreadData data = view.getPageData();
+ ThreadPageData data = view.getPageData();
if (null == data) {
return null;
List<TableInput> input = new ArrayList<TableInput>();
- List<ThreadPageThreadDataEvent> contents = data.getContents();
+ List<ThreadPageDataEvent> contents = data.getContents();
- ThreadPageThreadDataEvent content;
+ ThreadPageDataEvent content;
for (int i = 0; i < contents.size(); i++) {
content = contents.get(i);
List<String> contentTemp = content.getContents();
public class ThreadAPIListView extends DAView {
public static final String ID = ThreadAPIListView.class.getName();
- private ThreadPageThreadData data;
+ private ThreadPageData data;
int[] innerMaxWeight = { 0, 100 };
int[] outerMaxWeight = { 100, 0 };
@Override
public void updateView(DASelectionData data) {
- this.data = (ThreadPageThreadData) data.getData();
- if (!(this.data instanceof ThreadPageThreadData)) {
+ this.data = (ThreadPageData) data.getData();
+ if (!(this.data instanceof ThreadPageData)) {
return;
}
tableComp.getTable().removeAll();
data = null;
}
- public ThreadPageThreadData getPageData() {
+ public ThreadPageData getPageData() {
return data;
}
}
@Override
public void updateView(DASelectionData data) {
- ThreadPageThreadData item = (ThreadPageThreadData) data.getData();
- if (!(item instanceof ThreadPageThreadData)) {
+ String id = data.getViewId();
+ if (!(id.equals(ThreadChartView.ID))) {
+ return;
+ }
+ ThreadPageData item = (ThreadPageData) data.getData();
+ if (!(item instanceof ThreadPageData)) {
return;
}
select = true;
SashForm leftForm;
SashForm rightForm;
- // ThreadPageDataManager tManager = ThreadPageDataManager.getInstance();
-
public ThreadPage(Composite parent, int style) {
super(parent, style);
name = AnalyzerLabels.COOLBAR_AREA_THREAD;
{
SnapshotView snapshotView = new SnapshotView(
tabView.getContentComposite(), SWT.NONE, false);
- snapshotView.setObservingViews(new String[] { ThreadAPIListView.ID });
+ snapshotView
+ .setObservingViews(new String[] { ThreadAPIListView.ID });
tabView.addView(snapshotView);
CallstackView callstack = new CallstackView(
}
});
}
-
- // public void updateLog(LogPackage logPack) {
- // tManager.parsePageData(logPack);
- // }
}
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * yeongtaik byeon <yeongtaik.byeon@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+package org.tizen.dynamicanalyzer.ui.thread;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.tizen.dynamicanalyzer.widgets.chart.DACustomChart;
+import org.tizen.dynamicanalyzer.widgets.chartBoard.DACustomChartBoardItem;
+
+public abstract class ThreadPageData {
+ private int tid;
+ private String type;
+ private String name;
+ protected DACustomChartBoardItem item;
+ protected List<ThreadPageDataEvent> contents = new ArrayList<ThreadPageDataEvent>();
+ protected List<ThreadPageDataEvent> contentsQueue = new ArrayList<ThreadPageDataEvent>();
+ protected DACustomChart chart;
+ protected boolean hasUpdate = false;
+
+ public ThreadPageData(String type, String name, int tid) {
+ setType(type);
+ setName(name);
+ setTid(tid);
+ }
+
+ public int getTid() {
+ return tid;
+ }
+
+ public void setTid(int tid) {
+ this.tid = tid;
+ }
+
+ public String getType() {
+ return type;
+ }
+
+ public void setType(String type) {
+ this.type = type;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public DACustomChartBoardItem getItem() {
+ return item;
+ }
+
+ public DACustomChart getChart() {
+ return chart;
+ }
+
+ public void setChart(DACustomChart chart) {
+ this.chart = chart;
+ }
+
+ protected void pushEvent(ThreadPageDataEvent event) {
+ contentsQueue.add(event);
+ hasUpdate = true;
+ }
+
+ public void setHasUpdate() {
+ hasUpdate = true;
+ }
+
+
+
+ public List<ThreadPageDataEvent> getContents() {
+ return contents;
+ }
+ protected abstract void checkUpdate();
+ public abstract void setItem(DACustomChartBoardItem item);
+
+ protected abstract int createChartItem(ThreadPageDataEvent event);
+}
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * yeongtaik byeon <yeongtaik.byeon@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+package org.tizen.dynamicanalyzer.ui.thread;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class ThreadPageDataEvent {
+ private List<String> contents;
+
+ public ThreadPageDataEvent(List<String> contents) {
+ setContents(contents);
+ }
+
+ public List<String> getContents() {
+ if (null == contents) {
+ contents = new ArrayList<String>();
+ }
+ return contents;
+ }
+
+ public void setContents(List<String> contents) {
+ this.contents = contents;
+ }
+}
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * yeongtaik byeon <yeongtaik.byeon@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+package org.tizen.dynamicanalyzer.ui.thread;
+
+import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
+import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;
+import org.tizen.dynamicanalyzer.widgets.chart.DACustomChartSeries;
+import org.tizen.dynamicanalyzer.widgets.chart.DACustomChartSeriesItem;
+import org.tizen.dynamicanalyzer.widgets.chartBoard.DACustomChartBoardItem;
+
+public class ThreadPageSyncData extends ThreadPageData {
+ private DACustomChartSeries stateSeries;
+
+ public ThreadPageSyncData(String type, String name, int tid) {
+ super(type, name, tid);
+ }
+
+ public void setItem(DACustomChartBoardItem item) {
+ this.item = item;
+ setChart(item.getChart());
+ stateSeries = chart
+ .getSeries(ThreadPageLabels.THREAD_SYNC_CHART_SERIES_STATE);
+ }
+
+ private boolean isSyncApi(int apiType) {
+ switch (apiType) {
+ case LogCenterConstants.SYNC_API_TYPE_NEW:
+ case LogCenterConstants.SYNC_API_TYPE_ACQUIRE_WAIT_START:
+ case LogCenterConstants.SYNC_API_TYPE_RELEASE:
+ case LogCenterConstants.SYNC_API_TYPE_TRY_ACQUIRE:
+ case LogCenterConstants.SYNC_API_TYPE_COND_WAIT_START:
+ case LogCenterConstants.SYNC_API_TYPE_NOTIFY:
+ case LogCenterConstants.SYNC_API_TYPE_NOTIFY_ALL:
+ case LogCenterConstants.SYNC_API_TYPE_OTHER:
+ return true;
+ case LogCenterConstants.SYNC_API_TYPE_ACQUIRE_WAIT_END:
+ case LogCenterConstants.SYNC_API_TYPE_COND_WAIT_END:
+ return false;
+ default:
+ return false;
+ }
+ }
+
+ protected void checkUpdate() {
+ if (false == hasUpdate) {
+ return;
+ } else {
+ hasUpdate = false;
+ }
+ int size = contentsQueue.size();
+ if (size > 0) {
+ ThreadPageDataEvent event;
+ for (int i = 0; i < size; i++) {
+ event = contentsQueue.get(0);
+ if (true == (isSyncApi(createChartItem(event)))) {
+ contents.add(event);
+ }
+
+ contentsQueue.remove(0);
+ }
+ chart.redraw();
+ }
+ }
+
+ protected int createChartItem(ThreadPageDataEvent event) {
+ DACustomChartSeriesItem seriesItem;
+ ThreadPageSyncDataEvent syncEvent = (ThreadPageSyncDataEvent) event;
+ if (!(syncEvent instanceof ThreadPageSyncDataEvent)) {
+ System.out.println("error : createChartItem");
+ return -1;
+ }
+ seriesItem = new DACustomChartSeriesItem(syncEvent.getTime(), 0);
+ stateSeries.addSeriesItem(seriesItem);
+ return syncEvent.getApiType();
+ }
+}
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * yeongtaik byeon <yeongtaik.byeon@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+package org.tizen.dynamicanalyzer.ui.thread;
+
+import java.util.List;
+
+public class ThreadPageSyncDataEvent extends ThreadPageDataEvent {
+ private String syncVal;
+ private int tid = -1;
+ private int type = -1;
+ private int apiType = -1;
+ private double time = -1;
+
+ public ThreadPageSyncDataEvent(String syncVal, int type, int apiType,
+ double time, int tid, List<String> contents) {
+ super(contents);
+ setSyncVal(syncVal);
+ setType(type);
+ setApiType(apiType);
+ setTime(time);
+ setTid(tid);
+ setContents(contents);
+ }
+
+ public int getTid() {
+ return tid;
+ }
+
+ public void setTid(int tid) {
+ this.tid = tid;
+ }
+
+ public int getApiType() {
+ return apiType;
+ }
+
+ public void setApiType(int apiType) {
+ this.apiType = apiType;
+ }
+
+ public double getTime() {
+ return time;
+ }
+
+ public void setTime(double time) {
+ this.time = time;
+ }
+
+ public String getSyncVal() {
+ return syncVal;
+ }
+
+ public void setSyncVal(String syncVal) {
+ this.syncVal = syncVal;
+ }
+
+ public int getType() {
+ return type;
+ }
+
+ public void setType(int type) {
+ this.type = type;
+ }
+}
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;
import org.tizen.dynamicanalyzer.resources.ColorResources;
-import org.tizen.dynamicanalyzer.widgets.chart.DACustomChart;
import org.tizen.dynamicanalyzer.widgets.chart.DACustomChartSeries;
import org.tizen.dynamicanalyzer.widgets.chart.DACustomChartSeriesItem;
import org.tizen.dynamicanalyzer.widgets.chartBoard.DACustomChartBoardItem;
-public class ThreadPageThreadData {
- private ThreadPageThreadDataManager manager;
- private int tid;
- private String type;
- private String name;
- private String address;
- private List<ThreadPageThreadDataEvent> contents = new ArrayList<ThreadPageThreadDataEvent>();
- private List<ThreadPageThreadDataEvent> contentsQueue = new ArrayList<ThreadPageThreadDataEvent>();
- private DACustomChartBoardItem item;
- private DACustomChart chart;
+public class ThreadPageThreadData extends ThreadPageData {
+ private List<ThreadPageSyncData> syncs = new ArrayList<ThreadPageSyncData>();
private DACustomChartSeries loadSeries;
private DACustomChartSeries eventSeries;
private DACustomChartSeries apiSeries;
- public ThreadPageThreadData(ThreadPageThreadDataManager manager,
- String type, int tid, String address) {
- setManager(manager);
- setType(type);
- setName(String.valueOf(tid)+ThreadPageLabels.THREAD_CHART_NAME_PREFIX
- + type + ThreadPageLabels.THREAD_CHART_NAME_POSTFIX);
- setTid(tid);
- setAddress(address);
- }
-
- public ThreadPageThreadDataManager getManager() {
- return manager;
- }
-
- private void setManager(ThreadPageThreadDataManager manager) {
- this.manager = manager;
- }
-
- public int getTid() {
- return tid;
- }
-
- private void setTid(int tid) {
- this.tid = tid;
- }
-
- public String getAddress() {
- return address;
- }
-
- public void setAddress(String address) {
- this.address = address;
- }
-
- public String getName() {
- return name;
- }
-
- public void setName(String name) {
- this.name = name;
+ public ThreadPageThreadData(String type, int tid) {
+ super(type, String.valueOf(tid)
+ + ThreadPageLabels.THREAD_CHART_NAME_PREFIX + type
+ + ThreadPageLabels.THREAD_CHART_NAME_POSTFIX, tid);
}
public void addDataEvent(ThreadPageThreadDataEvent dataEvent) {
contentsQueue.add(dataEvent);
}
- public DACustomChartBoardItem getItem() {
- return item;
- }
-
public void setItem(DACustomChartBoardItem item) {
this.item = item;
chart = item.getChart();
apiSeries = chart.getSeries(ThreadPageLabels.THREAD_CHART_SERIES_API);
}
- // private DACustomChartBoardItem
- private int createChartItem(ThreadPageThreadDataEvent event) {
+ protected int createChartItem(ThreadPageDataEvent event) {
int ret = -1;
+ ThreadPageThreadDataEvent threadEvent = (ThreadPageThreadDataEvent) event;
+ if (!(threadEvent instanceof ThreadPageThreadDataEvent)) {
+ System.out.println("error : createChartItem");
+ return ret;
+ }
DACustomChartSeriesItem seriesItem;
- switch (event.getEventType()) {
+ switch (threadEvent.getEventType()) {
case ThreadPageThreadDataEvent.TYPE_LOAD:
ret = ThreadPageThreadDataEvent.TYPE_LOAD;
if (null == loadSeries) {
return ret;
}
- seriesItem = new DACustomChartSeriesItem(event.getTime(),
- (double) event.getThreadType());
+ seriesItem = new DACustomChartSeriesItem(threadEvent.getTime(),
+ (double) threadEvent.getThreadType());
loadSeries.addSeriesItem(seriesItem);
break;
return ret;
}
- int eventApiType = event.getApiType();
+ int eventApiType = threadEvent.getApiType();
if (eventApiType == LogCenterConstants.THREAD_API_TYPE_INTERNAL_START) {
- seriesItem = new DACustomChartSeriesItem(event.getTime(), -1);
- seriesItem.setBarWidth(event.getCallerTid());
+ seriesItem = new DACustomChartSeriesItem(threadEvent.getTime(),
+ -1);
+ seriesItem.setBarWidth(threadEvent.getCallerTid());
} else if (eventApiType == LogCenterConstants.THREAD_API_TYPE_WAIT_END) {
- if (event.getContents().get(LogCenterConstants.APINAME_INDEX)
+ if (threadEvent.getContents()
+ .get(LogCenterConstants.APINAME_INDEX)
.equals(ThreadPageLabels.THREAD_API_JOIN)) {
- seriesItem = new DACustomChartSeriesItem(event.getTime(),
- -1);
- seriesItem.setBarWidth(event.getCallerTid());
+ seriesItem = new DACustomChartSeriesItem(
+ threadEvent.getTime(), -1);
+ seriesItem.setBarWidth(threadEvent.getCallerTid());
} else {
- seriesItem = new DACustomChartSeriesItem(event.getTime(), 0);
+ seriesItem = new DACustomChartSeriesItem(
+ threadEvent.getTime(), 0);
}
} else if (eventApiType == LogCenterConstants.THREAD_API_TYPE_INTERNAL_STOP) {
- if (-1 != event.getCallerTid()) {
- seriesItem = new DACustomChartSeriesItem(event.getTime(), 1);
- seriesItem.setBarWidth(event.getCallerTid());
+ if (-1 != threadEvent.getCallerTid()) {
+ seriesItem = new DACustomChartSeriesItem(
+ threadEvent.getTime(), 1);
+ seriesItem.setBarWidth(threadEvent.getCallerTid());
} else {
- seriesItem = new DACustomChartSeriesItem(event.getTime(), 0);
+ seriesItem = new DACustomChartSeriesItem(
+ threadEvent.getTime(), 0);
}
} else {
- seriesItem = new DACustomChartSeriesItem(event.getTime(), 0);
+ seriesItem = new DACustomChartSeriesItem(threadEvent.getTime(),
+ 0);
}
eventSeries.addSeriesItem(seriesItem);
if (null == apiSeries) {
return ret;
}
- List<String> input = event.getContents();
+ List<String> input = threadEvent.getContents();
long errno = Long.parseLong(input
.get(LogCenterConstants.ERROR_INDEX));
if (0 == errno) {
- seriesItem = new DACustomChartSeriesItem(event.getTime(), 0);
+ seriesItem = new DACustomChartSeriesItem(threadEvent.getTime(),
+ 0);
} else {
- seriesItem = new DACustomChartSeriesItem(event.getTime(), 0,
- ColorResources.RED);
+ seriesItem = new DACustomChartSeriesItem(threadEvent.getTime(),
+ 0, ColorResources.RED);
}
apiSeries.addSeriesItem(seriesItem);
default:
return ret;
}
- event.setChartItem(seriesItem);
+ threadEvent.setChartItem(seriesItem);
return ret;
}
protected void checkUpdate() {
+ if (false == hasUpdate) {
+ return;
+ } else {
+ hasUpdate = false;
+ }
+
int size = contentsQueue.size();
if (size > 0) {
+ ThreadPageThreadDataEvent event;
for (int i = 0; i < size; i++) {
- ThreadPageThreadDataEvent event = contentsQueue.get(0);
- if (ThreadPageThreadDataEvent.TYPE_API == createChartItem(event)) {
- contents.add(event);
- } else {
- // do nothing
+ event = (ThreadPageThreadDataEvent) contentsQueue.get(0);
+ if ((event instanceof ThreadPageThreadDataEvent)) {
+ if (ThreadPageThreadDataEvent.TYPE_API == createChartItem(event)) {
+ contents.add(event);
+ } else {
+ // do nothing
+ }
}
contentsQueue.remove(0);
}
chart.redraw();
}
- }
-
- public DACustomChart getChart() {
- return chart;
- }
-
- public void setChart(DACustomChart chart) {
- this.chart = chart;
- }
-
- protected void pushEvent(ThreadPageThreadDataEvent event) {
- contentsQueue.add(event);
- }
- public List<ThreadPageThreadDataEvent> getContents() {
- return contents;
+ size = syncs.size();
+ if (size > 0) {
+ ThreadPageSyncData sync;
+ for (int i = 0; i < size; i++) {
+ sync = syncs.get(i);
+ sync.checkUpdate();
+ }
+ }
}
- public String getType() {
- return type;
+ protected void pushSync(ThreadPageSyncData sync) {
+ syncs.add(sync);
+ hasUpdate = true;
}
- public void setType(String type) {
- this.type = type;
+ protected ThreadPageSyncData findSyncData(String syncVal) {
+ int size = syncs.size();
+ ThreadPageSyncData sync;
+ for (int i = 0; i < size; i++) {
+ sync = syncs.get(i);
+ if (sync.getName().equals(syncVal)) {
+ return sync;
+ }
+ }
+ return null;
}
}
*/
package org.tizen.dynamicanalyzer.ui.thread;
-import java.util.ArrayList;
import java.util.List;
import org.tizen.dynamicanalyzer.widgets.chart.DACustomChartSeriesItem;
-public class ThreadPageThreadDataEvent {
+public class ThreadPageThreadDataEvent extends ThreadPageDataEvent {
public static final int TYPE_API = 0;
public static final int TYPE_EVENT = 1;
public static final int TYPE_LOAD = 2;
private ThreadPageThreadData data;
- private List<String> contents = new ArrayList<String>();
private int eventType = -1;
private int threadType = -1;
private int apiType = -1;
private String callID = null;
private int callerTid = -1;
- public ThreadPageThreadDataEvent(ThreadPageThreadDataManager manager,
- int eventType, int threadType, int apiType, double time, int tid,
- List<String> contents) {
+ public ThreadPageThreadDataEvent(int eventType, int threadType,
+ int apiType, double time, int tid, List<String> contents) {
+ super(contents);
setEventType(eventType);
setThreadType(threadType);
setApiType(apiType);
setTime(time);
setTid(tid);
- setContents(contents);
- // manager.pushEvent(this);
}
public int getEventType() {
this.eventType = eventType;
}
- public List<String> getContents() {
- return contents;
- }
-
- public void setContents(List<String> contents) {
- this.contents = contents;
- }
-
public DACustomChartSeriesItem getChartItem() {
return chartItem;
}
return data;
}
- public void setData(ThreadPageThreadData data) {
- this.data = data;
- data.pushEvent(this);
- }
-
public int getTid() {
return tid;
}
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
+import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.DASelectionData;
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
private boolean hasUpdate = false;
private List<ThreadPageThreadData> rows = new ArrayList<ThreadPageThreadData>();
private List<ThreadPageThreadData> rowsQueue = new ArrayList<ThreadPageThreadData>();
+ private List<ThreadPageSyncDataEvent> syncEventQueue = new ArrayList<ThreadPageSyncDataEvent>();
private List<ThreadPageThreadDataEvent> eventQueue = new ArrayList<ThreadPageThreadDataEvent>();
private List<ThreadPageThreadDataEvent> callEventQueue = new ArrayList<ThreadPageThreadDataEvent>();
- private List<ThreadPageThreadDataEvent> calleeEventQueue = new ArrayList<ThreadPageThreadDataEvent>();
protected void pushRow(ThreadPageThreadData data) {
rowsQueue.add(data);
callEventQueue.add(event);
}
+ protected void pushSyncEvent(ThreadPageSyncDataEvent syncEvent) {
+ syncEventQueue.add(syncEvent);
+ hasUpdate = true;
+ }
+
protected ThreadPageThreadDataManager(DACustomChartBoard board,
ThreadChartView view) {
this.setBoard(board);
chart.redraw();
}
+ private void initSyncChart(DACustomChart chart) {
+ if (null == chart) {
+ return;
+ }
+
+ DACustomChartSeries stateSeries = new DACustomChartSeries(
+ ThreadPageLabels.THREAD_SYNC_CHART_SERIES_STATE,
+ DACustomChartSeries.SERIES_STYLE_EVENT, ColorResources.RED);
+
+ chart.addSeries(stateSeries);
+
+ DACustomChartPlot plot = chart.getPlot();
+ if (null == plot) {
+ return;
+ }
+ plot.setBackgroundImage(ImageResources.BG_CHILD_GRADIENT);
+ plot.setAutoHeightRange(false);
+ plot.setAxisRangeY(0, 101);
+ plot.setAxisRangeX(board.getVisibleStartTime(),
+ board.getVisibleEndTime());
+
+ chart.redraw();
+ }
+
+ private boolean createSyncBoardItem(ThreadPageThreadData data,
+ ThreadPageSyncData sync) {
+ DACustomChartBoardItem parent = data.getItem();
+ if (null == parent) {
+ return false;
+ }
+ DACustomChartBoardItem item = new DACustomChartBoardItem(parent,
+ sync.getName() + ThreadPageLabels.THREAD_CHART_NAME_PREFIX
+ + sync.getType()
+ + ThreadPageLabels.THREAD_CHART_NAME_POSTFIX);
+ DACustomChart chart = item.getChart();
+ initSyncChart(chart);
+
+ sync.setItem(item);
+ item.setData(sync);
+ chart.setData(sync);
+ chart.redraw();
+ return true;
+ }
+
private void sendSelectionTimes(DACustomChart chart, double start,
double end) {
long startTime = (long) (start * TimelineConstants.MEGA);
chart.getData(), chart));
}
- // FIXME : chart range selection
- private Listener chartMouseListener = new Listener() {
+ // FIXME : chart range selection - change private
+ public Listener chartMouseListener = new Listener() {
@Override
public void handleEvent(Event event) {
isStart = false;
return;
}
- long startTime = 0;
- ThreadPageThreadData mainData = new ThreadPageThreadData(this,
- ThreadPageLabels.THREAD_ITEM_TYPE_MAIN,
- tid, null);
+ ThreadPageThreadData mainData = new ThreadPageThreadData(
+ ThreadPageLabels.THREAD_ITEM_TYPE_MAIN, tid);
pushRow(mainData);
-// ThreadPageThreadDataEvent mainEvent = new ThreadPageThreadDataEvent(
-// this, ThreadPageThreadDataEvent.TYPE_EVENT,
-// LogCenterConstants.THREAD_TYPE_MAIN,
-// LogCenterConstants.THREAD_API_TYPE_START, startTime, tid, null);
-// pushEvent(mainEvent);
}
public List<List<String>> getLogsFromLogPackage(LogPackage logPack,
/ TimelineConstants.MEGA;
ThreadPageThreadDataEvent event = new ThreadPageThreadDataEvent(
- this, ThreadPageThreadDataEvent.TYPE_LOAD, load, -1,
- time, tid, null);
+ ThreadPageThreadDataEvent.TYPE_LOAD, load, -1, time,
+ tid, null);
pushEvent(event);
}
}
case LogCenterConstants.THREAD_API_TYPE_EXIT:
case LogCenterConstants.THREAD_API_TYPE_WAIT_START:
case LogCenterConstants.THREAD_API_TYPE_OTHER:
- event = new ThreadPageThreadDataEvent(this,
+ event = new ThreadPageThreadDataEvent(
ThreadPageThreadDataEvent.TYPE_API,
LogCenterConstants.THREAD_TYPE_PTHREAD, apiType, time, tid,
input);
pushEvent(event);
break;
case LogCenterConstants.THREAD_API_TYPE_START:
- event = new ThreadPageThreadDataEvent(this,
+ event = new ThreadPageThreadDataEvent(
ThreadPageThreadDataEvent.TYPE_API,
LogCenterConstants.THREAD_TYPE_PTHREAD, apiType, time, tid,
input);
pushCallEvent(event);
break;
case LogCenterConstants.THREAD_API_TYPE_WAIT_END:
- event = new ThreadPageThreadDataEvent(this,
+ event = new ThreadPageThreadDataEvent(
ThreadPageThreadDataEvent.TYPE_EVENT,
LogCenterConstants.THREAD_TYPE_PTHREAD, apiType, time, tid,
input);
pushEvent(event);
+ break;
case LogCenterConstants.THREAD_API_TYPE_INTERNAL_STOP:
- event = new ThreadPageThreadDataEvent(this,
+ event = new ThreadPageThreadDataEvent(
ThreadPageThreadDataEvent.TYPE_EVENT,
LogCenterConstants.THREAD_TYPE_PTHREAD, apiType, time, tid,
input);
pushCallEvent(event);
break;
case LogCenterConstants.THREAD_API_TYPE_INTERNAL_START:
- String address = input
- .get(LogCenterConstants.THREAD_PTHREAD_ID_INDEX);
- ThreadPageThreadData data = new ThreadPageThreadData(this,
- ThreadPageLabels.THREAD_ITEM_TYPE_PTHREAD, tid,
- address);
+ ThreadPageThreadData data = new ThreadPageThreadData(
+ ThreadPageLabels.THREAD_ITEM_TYPE_PTHREAD, tid);
pushRow(data);
- event = new ThreadPageThreadDataEvent(this,
+ event = new ThreadPageThreadDataEvent(
ThreadPageThreadDataEvent.TYPE_EVENT,
LogCenterConstants.THREAD_TYPE_PTHREAD, apiType, time, tid,
input);
case LogCenterConstants.THREAD_API_TYPE_EXIT:
case LogCenterConstants.THREAD_API_TYPE_WAIT_START:
case LogCenterConstants.THREAD_API_TYPE_OTHER:
- event = new ThreadPageThreadDataEvent(this,
+ event = new ThreadPageThreadDataEvent(
ThreadPageThreadDataEvent.TYPE_API,
LogCenterConstants.THREAD_TYPE_OSP, apiType, time, tid,
input);
pushEvent(event);
break;
case LogCenterConstants.THREAD_API_TYPE_START:
- event = new ThreadPageThreadDataEvent(this,
+ event = new ThreadPageThreadDataEvent(
ThreadPageThreadDataEvent.TYPE_API,
LogCenterConstants.THREAD_TYPE_OSP, apiType, time, tid,
input);
pushCallEvent(event);
break;
case LogCenterConstants.THREAD_API_TYPE_WAIT_END:
- event = new ThreadPageThreadDataEvent(this,
- ThreadPageThreadDataEvent.TYPE_EVENT,
- LogCenterConstants.THREAD_TYPE_OSP, apiType, time, tid,
- input);
- pushEvent(event);
+ if (input.get(LogCenterConstants.APINAME_INDEX).equals(
+ ThreadPageLabels.THREAD_API_JOIN)) {
+ event = new ThreadPageThreadDataEvent(
+ ThreadPageThreadDataEvent.TYPE_EVENT,
+ LogCenterConstants.THREAD_TYPE_OSP, apiType, time, tid,
+ input);
+ pushEvent(event);
+ } else { // FIXME : do not shows sleep's wait end
+ }
break;
case LogCenterConstants.THREAD_API_TYPE_INTERNAL_STOP:
- event = new ThreadPageThreadDataEvent(this,
+ event = new ThreadPageThreadDataEvent(
ThreadPageThreadDataEvent.TYPE_EVENT,
LogCenterConstants.THREAD_TYPE_OSP, apiType, time, tid,
input);
pushCallEvent(event);
break;
case LogCenterConstants.THREAD_API_TYPE_INTERNAL_START:
- String address = input
- .get(LogCenterConstants.THREAD_PTHREAD_ID_INDEX);
ThreadPageThreadData data = new ThreadPageThreadData(
- this,
- ThreadPageLabels.THREAD_ITEM_TYPE_OSP,
- tid, address);
+ ThreadPageLabels.THREAD_ITEM_TYPE_OSP, tid);
pushRow(data);
- event = new ThreadPageThreadDataEvent(this,
+ event = new ThreadPageThreadDataEvent(
ThreadPageThreadDataEvent.TYPE_EVENT,
LogCenterConstants.THREAD_TYPE_OSP, apiType, time, tid,
input);
}
}
+ private void parseSync(LogPackage logPack) {
+ List<List<String>> inputs = getLogsFromLogPackage(logPack,
+ LogCenterConstants.LOG_SYNC);
+ int size;
+ if (null == inputs || 0 == (size = inputs.size())) {
+ return;
+ }
+ List<String> input;
+ for (int i = 0; i < size; i++) {
+ input = inputs.get(i);
+ // System.out.println("input : " + input);
+ double time = Double.parseDouble(input
+ .get(LogCenterConstants.TIME_INDEX))
+ / TimelineConstants.MEGA;
+ int tid = Integer.parseInt(input
+ .get(LogCenterConstants.THREAD_ID_INDEX));
+
+ // FIXME
+ int type = Integer.parseInt(input
+ .get(LogCenterConstants.SYNC_TYPE_INDEX));
+ int apiType = Integer.parseInt(input
+ .get(LogCenterConstants.SYNC_API_TYPE_INDEX));
+
+ String name = input.get(LogCenterConstants.SYNC_VAL_INDEX);
+ ThreadPageSyncDataEvent event;
+ switch (type) {
+ case LogCenterConstants.SYNC_TYPE_OSP_MUTEX:
+ case LogCenterConstants.SYNC_TYPE_OSP_MONITOR:
+ case LogCenterConstants.SYNC_TYPE_OSP_SEMAPHORE:
+ event = new ThreadPageSyncDataEvent(name, type, apiType, time,
+ tid, input);
+ pushSyncEvent(event);
+ // parseOSPSync(input, type);
+ break;
+ case LogCenterConstants.SYNC_TYPE_PTHREAD_MUTEX:
+ case LogCenterConstants.SYNC_TYPE_PTHREAD_COND_VARIABLE:
+ break;
+ case LogCenterConstants.SYNC_TYPE_PTHREAD_RWLOCK:
+ case LogCenterConstants.SYNC_TYPE_PTHREAD_SPINLOCK:
+ case LogCenterConstants.SYNC_TYPE_PTHREAD_BARRIER:
+ System.out.println("error : sync parse - type = " + type);
+ break;
+ default:
+ System.out.println("error : sync parse unknown - type = "
+ + type);
+ }
+ }
+ }
+
public void parsePageData(LogPackage logPack) {
parseLoad(logPack);
parseAPI(logPack);
- // parseEvent(logPack);
+ parseSync(logPack);
hasUpdate = true;
}
return true;
}
}
- // if(callEvent.getContents().)
}
}
return false;
return null;
}
+ private String getSyncTypeString(int syncType) {
+ switch (syncType) {
+ case LogCenterConstants.SYNC_TYPE_OSP_MUTEX:
+ return ThreadPageLabels.SYNC_TYPE_OSP_MUTEX;
+ case LogCenterConstants.SYNC_TYPE_OSP_MONITOR:
+ return ThreadPageLabels.SYNC_TYPE_OSP_MONITOR;
+ case LogCenterConstants.SYNC_TYPE_OSP_SEMAPHORE:
+ return ThreadPageLabels.SYNC_TYPE_OSP_SEMAPHORE;
+ case LogCenterConstants.SYNC_TYPE_PTHREAD_MUTEX:
+ return ThreadPageLabels.SYNC_TYPE_PTHREAD_MUTEX;
+ case LogCenterConstants.SYNC_TYPE_PTHREAD_COND_VARIABLE:
+ return ThreadPageLabels.SYNC_TYPE_PTHREAD_COND_VARIABLE;
+ case LogCenterConstants.SYNC_TYPE_PTHREAD_RWLOCK:
+ return ThreadPageLabels.SYNC_TYPE_PTHREAD_RWLOCK;
+ case LogCenterConstants.SYNC_TYPE_PTHREAD_SPINLOCK:
+ return ThreadPageLabels.SYNC_TYPE_PTHREAD_SPINLOCK;
+ case LogCenterConstants.SYNC_TYPE_PTHREAD_BARRIER:
+ return ThreadPageLabels.SYNC_TYPE_PTHREAD_BARRIER;
+ default:
+ return AnalyzerConstants.EMPTY;
+ }
+
+ }
+
protected void checkUpdate() {
if (false == hasUpdate) {
return;
}
int size = rowsQueue.size();
if (size > 0) {
+ ThreadPageThreadData data;
for (int i = 0; i < size; i++) {
- ThreadPageThreadData data = rowsQueue.get(0);
+ data = rowsQueue.get(0);
createBoardItem(data);
rows.add(data);
rowsQueue.remove(0);
}
}
}
+
+ size = syncEventQueue.size();
+ if (size > 0) {
+ ThreadPageThreadData data;
+ ThreadPageSyncDataEvent event;
+ ThreadPageSyncData sync;
+ for (int i = 0; i < size; i++) {
+ event = syncEventQueue.get(0);
+ data = findParentData(event.getTid());
+ if (null != data) {
+ sync = data.findSyncData(event.getSyncVal());
+ if (null == sync) {
+ sync = new ThreadPageSyncData(
+ getSyncTypeString(event.getType()),
+ event.getSyncVal(), event.getTid());
+ createSyncBoardItem(data, sync);
+ data.pushSync(sync);
+ }
+ sync.pushEvent(event);
+ data.setHasUpdate();
+ }
+ syncEventQueue.remove(0);
+ }
+ }
+
size = rows.size();
if (size > 0) {
ThreadPageThreadData data;
data.checkUpdate();
}
}
-
}
public void clear() {
rowsQueue.clear();
eventQueue.clear();
callEventQueue.clear();
- calleeEventQueue.clear();
isStart = false;
hasUpdate = false;
}
projects / sdk / tools / dynamic-analyzer.git / commitdiff
