public static Color FILE_ACCESS_WRITE = getColor("file_access_write"); //$NON-NLS-1$\r
public static Color FILE_ACCESS_CONCURRENT_READ = getColor("file_access_concurrent_read"); //$NON-NLS-1$\r
public static Color FILE_ACCESS_CONCURRENT_WRITE = getColor("file_access_concurrent_write"); //$NON-NLS-1$\r
- public static Color FILE_LOCK_ACQUIRED = getColor("file_lock_acquired"); //$NON-NLS-1$\r
+ public static Color FILE_LOCK = getColor("file_lock"); //$NON-NLS-1$\r
+ public static Color FILE_UNLOCK = getColor("file_unlock"); //$NON-NLS-1$file_unlock\r
public static Color FILE_LOCK_WAITING = getColor("file_lock_waiting"); //$NON-NLS-1$\r
public static Color FILE_OTHER_OPERATION = getColor("file_other_operation"); //$NON-NLS-1$\r
public static Color FILE_OPENED = getColor("file_opened"); //$NON-NLS-1$\r
setColor("file_access_write",new RGB(131, 207, 232)); //$NON-NLS-1$
setColor("file_access_concurrent_read", new RGB(40, 160, 198)); //$NON-NLS-1$
setColor("file_access_concurrent_write", new RGB(40, 160, 198)); //$NON-NLS-1$
- setColor("file_lock_acquired", new RGB(229, 123, 206)); //$NON-NLS-1$
+ setColor("file_lock", new RGB(229, 123, 206)); //$NON-NLS-1$
+ setColor("file_unlock", new RGB(125, 61, 204)); //$NON-NLS-1$
setColor("file_lock_waiting", new RGB(194, 79, 167)); //$NON-NLS-1$
setColor("file_other_operation", new RGB(173, 173, 173)); //$NON-NLS-1$
setColor("file_other_operation", new RGB(173, 173, 173)); //$NON-NLS-1$
/* special character */
public static final String EMPTY = ""; //$NON-NLS-1$
public static final String SPACE = " "; //$NON-NLS-1$
+ public static final String DOUBLE_SPACE = " "; //$NON-NLS-1$
public static final String TAB = " "; //$NON-NLS-1$
public static final String SLASH = "/"; //$NON-NLS-1$
public static final String BSLASH = "\\"; //$NON-NLS-1$
public static final String CMD_SPLIT_DOT = "\\."; //$NON-NLS-1$
public static final String NEW_LINE_CHAR = "\\n"; //$NON-NLS-1$
public static final String NEW_LINE = "\n"; //$NON-NLS-1$
+ public static final String DOUBLE_NEW_LINE = "\n\n"; //$NON-NLS-1$
public static final String DOT = "."; //$NON-NLS-1$
public static final String COMMA = ","; //$NON-NLS-1$
public static final String COLON = ":"; //$NON-NLS-1$
}
drawAxis(gc);
-
+
/*
* draw chart information
*/
gc.setForeground(ColorResources.CHART_INFO);
gc.setFont(FontResources.CHART_INFO_FONT);
gc.drawImage(ImageResources.CHART_INFO, r.x + 5, (r.y + r.height) / 2 - 4);
- gc.drawText(chart.getInformation(), r.x + 18,
+ gc.drawText(chart.getInformation(), r.x + 18,
(r.y + r.height / 2 - gc.textExtent(chart.getInformation()).y / 2), true);
}
}
int totalHeight;
if (plot instanceof DAUIEventChartPlot) {
- totalHeight = DAChartPlotTooltip.TOOLTIP_TEXT_HEIGHT
+ if (!tooltipTexts.isEmpty()) {
+ totalHeight = gc.textExtent(tooltipTexts.get(0)).y
+ + DAChartPlotTooltip.TOOLTIP_MARGIN + DAChartPlotTooltip.TOOLTIP_MARGIN;
+ } else {
+ totalHeight = DAChartPlotTooltip.TOOLTIP_TEXT_HEIGHT
+ DAChartPlotTooltip.TOOLTIP_MARGIN + DAChartPlotTooltip.TOOLTIP_MARGIN;
+ }
} else {
totalHeight = seriesCountPerColumn * DAChartPlotTooltip.TOOLTIP_TEXT_HEIGHT
+ DAChartPlotTooltip.TOOLTIP_MARGIN + DAChartPlotTooltip.TOOLTIP_BOTTOM_MARGIN
} else {
startY = (r.y + r.height / 2) - (totalHeight / 2);
}
-
- int tooltipBoxWidth = (preTextWidthMargin + textWidthMax)
- * (tooltipSize / seriesCountPerColumn) + DAChartPlotTooltip.TOOLTIP_MARGIN;
+ int rowCount = tooltipSize / seriesCountPerColumn;
+ if ((tooltipSize % seriesCountPerColumn) != 0) {
+ rowCount++;
+ }
+ int tooltipBoxWidth = (preTextWidthMargin + textWidthMax) * rowCount + DAChartPlotTooltip.TOOLTIP_MARGIN;
gc.setAlpha(150);
gc.setBackground(tooltip.getBackgroundColor());
gc.setForeground(tooltip.getForegroundColor());
Color colorB = series.getSecondColor();
float aAmount = (float) (1.0 - bAmount);
float r = colorA.getRed() * aAmount + colorB.getRed() * bAmount;
+ if (r < 0) {
+ r = 0;
+ }
float g = colorA.getGreen() * aAmount + colorB.getGreen() * bAmount;
+ if (g < 0) {
+ g = 0;
+ }
float b = colorA.getBlue() * aAmount + colorB.getBlue() * bAmount;
+ if (b < 0) {
+ b = 0;
+ }
return new Color(Display.getCurrent(), (int) r, (int) g, (int) b);
}
this.layout();
}
+ private void initWidget(String name, String fullName, Image icon, int chartStyle) {
+ heightRatio = getBoardItemHeightRatio();
+
+ this.setLayout(new FormLayout());
+ itemCell = new DAChartBoardItemCell(this, name, icon, chartStyle);
+ itemCell.setFullName(fullName);
+ itemCell.addExpandToggleButton();
+
+ FormData data = new FormData();
+ data.top = new FormAttachment(0, 0);
+ data.left = new FormAttachment(0, 0);
+ data.right = new FormAttachment(100, 0);
+ data.height = (int) (heightRatio * height);
+ itemCell.setLayoutData(data);
+ this.layout();
+ }
+
public DAChartBoardItem(DAChartBoard parent, String itemName) {
super(parent.getItemList(), SWT.NONE);
parentBoard = parent;
initWidget(itemName, null, DAChart.CHART_STYLE_NORMAL);
parentBoard.registerItem(this);
}
+
+ //to show full title
+ public DAChartBoardItem(DAChartBoard parent, String itemName, String fullName) {
+ super(parent.getItemList(), SWT.NONE);
+ parentBoard = parent;
+ height = parent.getItemHeight();
+ initWidget(itemName, fullName, null, DAChart.CHART_STYLE_NORMAL);
+ parentBoard.registerItem(this);
+ }
+
+ //to show full title
+ public DAChartBoardItem(DAChartBoardItem parent, String itemName, String fullName) {
+ super(parent.getChildItemList(), SWT.NONE);
+ parentItem = parent;
+ height = parent.getChartBoard().getItemHeight();
+ depth = parent.getDepth() + 1;
+ initWidget(itemName, fullName, null, DAChart.CHART_STYLE_NORMAL);
+ parentItem.registerItem(this);
+ }
+
// for sorting of chart items
public DAChartBoardItem(DAChartBoard parent, String itemName,
Object o, Comparator c) {
public DAChartBoardItem(DAChartBoardItem parent, String itemName) {
super(parent.getChildItemList(), SWT.NONE);
parentItem = parent;
- height = parent.getItemHeight();
+ height = parent.getChartBoard().getItemHeight();
depth = parent.getDepth() + 1;
initWidget(itemName, null, DAChart.CHART_STYLE_NORMAL);
parentItem.registerItem(this);
Object o, Comparator c) {
super(parent.getChildItemList(), SWT.NONE);
parentItem = parent;
- height = parent.getItemHeight();
+ height = parent.getChartBoard().getItemHeight();
depth = parent.getDepth() + 1;
sortObj = o;
initWidget(itemName, null, DAChart.CHART_STYLE_NORMAL);
int chartStyle) {
super(parent.getChildItemList(), SWT.NONE);
parentItem = parent;
- height = parent.getItemHeight();
+ height = parent.getChartBoard().getItemHeight();
depth = parent.getDepth() + 1;
initWidget(itemName, icon, chartStyle);
parentItem.registerItem(this);
private PaintListener nameCellPaintListener;
private boolean hasAdditionalInfo = false;
+ private String itemFullName = null;
+
//FIXME for debugging
public String getItemName() {
return itemName;
boolean bToggled = expandButton.isToggled();
parentItem.callbackSelect(true);
parentItem.callbackExpand(bToggled);
+
+ PaintListener fullNameCellPaintListener = (new PaintListener() {
+ @Override
+ public void paintControl(PaintEvent e) { // draw full name
+ Rectangle rect = ((Canvas) (e.widget)).getClientArea();
+ drawNameCellBackGround(e.gc, rect);
+ Point point = e.gc.textExtent(itemFullName, SWT.DRAW_DELIMITER);
+ int startY = rect.height / 2 - point.y / 2 + NAME_CELL_DEFAULT_MARGIN;
+ e.gc.setForeground(ColorResources.BLACK);
+ drawText(e.gc, itemFullName, rect, startY);
+ }
+ });
+ if(itemFullName != null) {
+ if(bToggled) {
+ nameCell.addPaintListener(fullNameCellPaintListener);
+ }else{
+ nameCell.addPaintListener(nameCellPaintListener);
+ }
+ }
nameCell.redraw();
}
});
nameCellCurrentBGColorEnd = endColor;
nameCell.redraw();
}
+
+ public void setFullName(String fullName) {
+ this.itemFullName = fullName;
+ }
}
<launcherArgs>
<programArgs>-data @noDefault</programArgs>
<vmArgs>-XX:MaxPermSize=64m
--Xms512m
--Xmx512m
+-Xms256m
+-Xmx1024m
-XX:+UseParNewGC
-XX:+UseConcMarkSweepGC</vmArgs>
<vmArgsMac>-XstartOnFirstThread -Dorg.eclipse.swt.internal.carbon.smallFonts</vmArgsMac>
public static final String IDE_FOLDER_NAME = "ide"; //$NON-NLS-1$
public static final String PLUGINS_FOLDER_NAME = "plugins"; //$NON-NLS-1$
public static final String BASE_PLATFORM_PLUGIN_FOLDER_NAME = "org.tizen.base.platform"; //$NON-NLS-1$
+ public static final String PLATFORM_IDE_PLUGIN_NAME = "org.tizen.nativeplatform"; //$NON-NLS-1$
public static final String WORKBENCH_PLUGIN_FOLDER_NAME = "org.tizen.dynamicanalyzer.workbench"; //$NON-NLS-1$
public static final String ABOUT_FILE_NAME = "about.mappings"; //$NON-NLS-1$
public static final String SINGLETON_LOCK_FILE = "active_da";//$NON-NLS-1$
public static final String DA_INSTALL_PATH = TIZEN_SDK_INSTALL_PATH + File.separator
+ PathConstants.TOOLS_FOLDER_NAME + File.separator
+ PathConstants.DYNAMIC_ANALYZER_FOLDER_NAME;
- public static final String DA_AUTOTEST_PATH = TIZEN_SDK_DATA_PATH + File.separator
- + "test" + File.separator + PathConstants.DYNAMIC_ANALYZER_FOLDER_NAME;
+ public static final String DA_AUTOTEST_PATH = TIZEN_SDK_DATA_PATH + File.separator + "test"
+ + File.separator + PathConstants.DYNAMIC_ANALYZER_FOLDER_NAME;
public static final String DA_READELF_PATH = DA_INSTALL_PATH + File.separator
+ PathConstants.TARGET_FOLDER_NAME;
public static final String DA_TOOL_FOLDER_PATH = DA_INSTALL_PATH + File.separator
+ PathConstants.TOOL_FOLDER_NAME;
- public static final String DA_DEBUG_DATA_CHANNEL_LOG_FILE = DA_LOG_PATH
- + File.separator + "data.log"; //$NON-NLS-1$
- public static final String DA_DEBUG_CONTROL_CHANNEL_LOG_FILE = DA_LOG_PATH
- + File.separator + "control.log"; //$NON-NLS-1$
+ public static final String DA_DEBUG_DATA_CHANNEL_LOG_FILE = DA_LOG_PATH + File.separator
+ + "data.log"; //$NON-NLS-1$
+ public static final String DA_DEBUG_CONTROL_CHANNEL_LOG_FILE = DA_LOG_PATH + File.separator
+ + "control.log"; //$NON-NLS-1$
public static final String DA_BINARY_AUTO_SAVE_FILE = DA_SAVE_PATH + File.separator
+ "BinarySettings.save";
String platformVersion = platform.replaceAll("[A-Za-z]", "");//$NON-NLS-1$
if (Double.parseDouble(platformVersion) < 2.1) {
- tizenHeaderSouecePath = String.format(tempPath, platformName,
- currentDevie, platformVersion + ".cpp");//$NON-NLS-1$
+ tizenHeaderSouecePath = String.format(tempPath, platformName, currentDevie,
+ platformVersion + ".cpp");//$NON-NLS-1$
} else {
- tizenHeaderSouecePath = String.format(tempPath, platformName,
- currentDevie, platformVersion + ".native");//$NON-NLS-1$
+ tizenHeaderSouecePath = String.format(tempPath, platformName, currentDevie,
+ platformVersion + ".native");//$NON-NLS-1$
}
}
// currently not used
public static String getTargetPath(String platform) {
if (null != platform && !platform.isEmpty()) {
- return TIZEN_SDK_INSTALL_PATH + File.separator
- + PathConstants.PLATFORM_FOLDER_NAME + File.separator + platform
- + File.separator + PathConstants.DYNAMIC_ANALYZER_FOLDER_NAME
- + File.separator;
+ return TIZEN_SDK_INSTALL_PATH + File.separator + PathConstants.PLATFORM_FOLDER_NAME
+ + File.separator + platform + File.separator
+ + PathConstants.DYNAMIC_ANALYZER_FOLDER_NAME + File.separator;
} else {
return DA_INSTALL_PATH + File.separator + PathConstants.TARGET_FOLDER_NAME
+ File.separator;
return aboutFilePath;
}
+ public static boolean checkPlatformPlugin() {
+ String idePluginPath = TIZEN_SDK_INSTALL_PATH + File.separator
+ + PathConstants.IDE_FOLDER_NAME + File.separator
+ + PathConstants.PLUGINS_FOLDER_NAME;
+
+ File dir = new File(idePluginPath);
+ String[] files;
+ if (dir.exists()) {
+ files = dir.list(new FilenameFilter() {
+
+ @Override
+ public boolean accept(File dir, String name) {
+ return name.contains(PathConstants.PLATFORM_IDE_PLUGIN_NAME);
+ }
+ });
+ } else {
+ return false;
+ }
+
+ if (null == files || files.length < 1) {
+ return false;
+ }
+
+ return true;
+ }
+
public static String getWorkbenchPluginPath() {
String aboutFolderPath = TIZEN_SDK_INSTALL_PATH + File.separator
+ PathConstants.TOOLS_FOLDER_NAME + File.separator
public static String getRootstrapsPath(String platform) {
if (platform != null) {
- return TIZEN_SDK_INSTALL_PATH + File.separator
- + PathConstants.PLATFORM_FOLDER_NAME + File.separator + platform
- + File.separator + PathConstants.TIZEN_FOLDER_ROOTSTRAPS;
+ return TIZEN_SDK_INSTALL_PATH + File.separator + PathConstants.PLATFORM_FOLDER_NAME
+ + File.separator + platform + File.separator
+ + PathConstants.TIZEN_FOLDER_ROOTSTRAPS;
} else {
return "";
}
returnstr = DA_TOOL_FOLDER_PATH + File.separator
+ PathConstants.WINDOW_ACTIVATOR_WINDOWS;
} else if (CommonUtil.isMac()) {
- returnstr = DA_TOOL_FOLDER_PATH + File.separator
- + PathConstants.WINDOW_ACTIVATOR_MACOS;
+ returnstr = DA_TOOL_FOLDER_PATH + File.separator + PathConstants.WINDOW_ACTIVATOR_MACOS;
} else if (CommonUtil.isLinux()) {
- returnstr = DA_TOOL_FOLDER_PATH + File.separator
- + PathConstants.WINDOW_ACTIVATOR_LINUX;
+ returnstr = DA_TOOL_FOLDER_PATH + File.separator + PathConstants.WINDOW_ACTIVATOR_LINUX;
} else {
returnstr = null;
}
return returnstr;
}
-
+
public static String getTestLogPath() {
String returnstr = null;
returnstr = getTizenSdkDataPath();
- if (returnstr == null) return returnstr;
- return returnstr + File.separator + PathConstants.DYNAMIC_ANALYZER_FOLDER_NAME
- + File.separator + PathConstants.TEST_FOLDER_NAME;
+ if (returnstr == null)
+ return returnstr;
+ return returnstr + File.separator + PathConstants.DYNAMIC_ANALYZER_FOLDER_NAME
+ + File.separator + PathConstants.TEST_FOLDER_NAME;
}
-
+
public static String getDebugInfoScript() {
String path = null;
-
+
if (CommonUtil.isLinux() || CommonUtil.isMac()) {
- path = DA_TOOL_FOLDER_PATH + File.separator
- + PathConstants.DEBUGINFO_LINUX_MAC;
+ path = DA_TOOL_FOLDER_PATH + File.separator + PathConstants.DEBUGINFO_LINUX_MAC;
} else if (CommonUtil.isWin()) {
- path = DA_TOOL_FOLDER_PATH + File.separator
- + PathConstants.DEBUGINFO_WINDOWS;
+ path = DA_TOOL_FOLDER_PATH + File.separator + PathConstants.DEBUGINFO_WINDOWS;
} else { // should never be here
- Logger.error("Unknown host OS!\n");
+ Logger.error("Unknown host OS!\n");
}
-
+
return path;
}
}
}
public V getByIndex(int index) {
- if (index < dataList.size()) {
+ if (index >= 0 && index < dataList.size()) {
return dataList.get(index);
} else {
return null;
public void start(BundleContext context) throws Exception {\r
super.start(context);\r
plugin = this;\r
+ \r
+ // check for platform sdk\r
+ Global.setPlatformSDK(PathManager.checkPlatformPlugin());\r
\r
// Adds workbench listener.\r
IWorkbench workbench = PlatformUI.getWorkbench();\r
public static final String CMD_UPLOAD_FILE_LIST = "du -b " + //$NON-NLS-1$
PathConstants.DA_REMOTE_PATH + AnalyzerConstants.READELF_BIN;
public static final String CMD_PROCESS_NAME = "ps -p %d -o comm=rcu_sched";
+ public static final String CMD_GET_FILE_SIZE = "stat -c %s";
// via da_command
- public static final String DACOMMAND_KILL_MANAGER = "da killmanager";
- public static final String DACOMMAND_RUN_MANAGER = "da runmanager";
- public static final String DACOMMAND_FIND_UNITTEST = "da findunittest";
- public static final String DACOMMAND_CHECK_VERSION = "da getversion";
- public static final String DACOMMAND_READLINK = "da readlink ";
+ public static final String DACOMMAND_KILL_MANAGER = "profile killmanager";
+ public static final String DACOMMAND_RUN_MANAGER = "profile runmanager";
+ public static final String DACOMMAND_FIND_UNITTEST = "profile findunittest";
+ public static final String DACOMMAND_CHECK_VERSION = "profile getversion";
+ public static final String DACOMMAND_READLINK = "profile readlink ";
// direct shell command
public static final String CMD_FIND_IME = "/usr/bin/pkginfo --arg-flt 10 http://tizen.org/category/ime";
public static final int MAX_BINARY_COUNT = (int) Math.pow(2, 16); // 65535
public static final int MAX_FUNCTION_COUNT = (int) Math.pow(2, 20); // 1,048,576
public static final int MAX_FUNCTION_ARGUMENTS_COUNT = FUNCTION_ARGUMENTS_FORMAT_LENGTH; // Because "MAX_FUNCTION_ARGUMENTS_COUNT < FUNCTION_ARGUMENTS_FORMAT_LENGTH" is always true
+ public static final long MAX_DAEMON_LOG_SIZE = 1024*1024; // 1 mega byte
// Leak
public static final int MAX_LEAK_CHECK_BUFFER_SIZE = (int) Math.pow(2, 20); // 1,048,576
public static final int MAX_FILE_ACCESS_COUNT = ((int) Math.pow(2, 10))*100; // 102400 // 102400
public static final int MAX_STRING_LENGTH = 16;
+ // Callstack
+ public static final int MAX_CALLSTACK_SEQTIMEMAP_SIZE = 100000;
public static void stopTraceAndOpenWarningDialog() {
// This class is for global information that can be accessed from anywhere in dynamic analyzer code.
// So this class contains only static methods and variables.
public class Global {
+ private static boolean isPlatformSDK = false;
+
private static DeviceInfo currentDevice = null;
private static PackageInfo currentApplication = null;
private static Project currentProject = null;
private static RunTimeConfiguration currentConfiguration = null;
+ public static boolean isPlatformSDK() {
+ return isPlatformSDK;
+ }
+
+ public static void setPlatformSDK(boolean isPlatformSDK) {
+ Global.isPlatformSDK = isPlatformSDK;
+ }
+
public static DeviceInfo getCurrentDeviceInfo() {
return currentDevice;
}
public static void setCurrentDeviceInfo(DeviceInfo device) {
- currentDevice = device;
+ Global.currentDevice = device;
}
public static PackageInfo getCurrentApplication() {
}
public static void setCurrentApplication(PackageInfo pkgInfo) {
- currentApplication = pkgInfo;
+ Global.currentApplication = pkgInfo;
}
public static RunTimeConfiguration getCurrentConfiguration() {
}
public static void setCurrentConfiguration(RunTimeConfiguration currentConfig) {
- currentConfiguration = currentConfig;
- }
-
- public static void setProject(Project p) {
- currentProject = p;
+ Global.currentConfiguration = currentConfig;
}
public static Project getProject() {
return currentProject;
}
+ public static void setProject(Project p) {
+ Global.currentProject = p;
+ }
+
public static String getFunctionName(int id) {
if (currentProject != null) {
return currentProject.getFunctionName(id);
ERR_READELF_UPLOAD_FAILED(-205, "readelf file size is different!!"),
- ERR_DEVICE_IS_NULL(-301, "current device is null"),
+ ERR_DEVICE_IS_NULL(-301, "Current device is not available"),
ERR_DEVICE_IS_OFFLINE(-302, "current device is offline"),
ERR_SELECTED_APP_IS_NULL(-401, "selected app is null"),
- ERR_MSG_START_FAIL(-501, "start message is not ok"),
+ ERR_MSG_START_FAIL(-501, "Current application is not available"),
ERR_MSG_STOP_FAIL(-502, "stop message is not ok"),
ERR_BIN_INFO_GET_FAIL(-507, "binary info get fail..."),
ERR_RECEIVE_ACK_FAIL(-508, "receiving ack message fail..."),
+
+ ERR_BY_SECURITY_REASON(-601, "error by security reason"),
ERR_DA_IS_EXIT(-901, "Dynamic Analyzer is closing"),
public static int getRemotePort(IDevice device) {
int remotePort = -1;
+
// add error check
- System.out.print("Getting Port Progress \n ");
long start = System.currentTimeMillis();
while ((System.currentTimeMillis() - start) < PORT_WAIT_TIME) {
try {
System.out.print("\n");
if (remotePort < 0) {
- Logger.debug("!!port get failed!!");
+ Logger.error("!!failed to get port number of da manager!!");
} else {
- Logger.debug("!!port get success!! : " + remotePort);
+ Logger.debug("!!succeeded to get port number!! : " + remotePort);
}
return remotePort;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.AnalyzerShellCommands;
+import org.tizen.dynamicanalyzer.common.DALimit;
import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.common.HostResult;
import org.tizen.dynamicanalyzer.common.path.PathConstants;
}
}
});
- processName = cmdResultMultiLines.get(1);
+ if (cmdResultMultiLines.size() == 1) {
+ processName = "unknow proccess";//$NON-NLS-1$
+ } else {
+ processName = cmdResultMultiLines.get(1);
+ }
+
return processName;
}
}
});
- Logger.debug("device disconnected : " + device.getSerialNumber());
- DeviceInfo deviceInfo = getDeviceByName(device.getSerialNumber());
- DeviceInfo selectedDevice = Global.getCurrentDeviceInfo();
- if (null != devices && !devices.isEmpty()) {
- devices.remove(deviceInfo);
- if (!AnalyzerManager.isRunning()) {
- updateToolbarDevice();
- }
- if (isRunning()) {
- if (selectedDevice.getIDevice().getSerialNumber()
- .equals(deviceInfo.getIDevice().getSerialNumber())) {
- Logger.debug("Disconnected while DA is running."); //$NON-NLS-1$
- DACommunicator.setRunning(false);
- }
- }
- }
+ onDisconnectedInternal(device);
Display.getDefault().syncExec(new Runnable() {
@Override
}
});
- Logger.debug("device connected : " + device.getSerialNumber());
- // addDevice(device);
- if (!AnalyzerManager.isRunning()) {
- DeviceInfo devInfo = new DeviceInfo(device);
- HostResult result = readVersion(devInfo);
- if (result.isSuccess()) {
- devInfo.initCommunicator();
- updateToolbarDevice();
- }
- }
- if (null != Global.getCurrentDeviceInfo() && null != Global.getCurrentApplication()) {
- Display.getDefault().syncExec(new Runnable() {
- @Override
- public void run() {
- ToolbarArea.getInstance().setStartButtonEnablement(true);
- }
- });
- }
+ onConnectedInternal(device);
Display.getDefault().syncExec(new Runnable() {
@Override
});
Logger.debug("device changed : " + device.getSerialNumber() + " " + changeMask);
- if (1 == changeMask) {
- if (!AnalyzerManager.isRunning()) {
- DeviceInfo devInfo = new DeviceInfo(device);
- HostResult result = readVersion(devInfo);
- if (result.isSuccess()) {
- devInfo.initCommunicator();
- updateToolbarDevice();
- }
- }
- if (null != Global.getCurrentDeviceInfo() && null != Global.getCurrentApplication()) {
- Display.getDefault().syncExec(new Runnable() {
- @Override
- public void run() {
- ToolbarArea.getInstance().setStartButtonEnablement(true);
- }
- });
- }
+ if (1 == changeMask) { // state changed (offline -> online, vice versa)
+ onDisconnectedInternal(device);
+ onConnectedInternal(device);
} else {
Logger.debug("device changed type :" + changeMask);
}
});
}
+ private void onDisconnectedInternal(IDevice device) {
+ Logger.debug("device disconnected : " + device.getSerialNumber());
+ DeviceInfo deviceInfo = getDeviceByName(device.getSerialNumber());
+ DeviceInfo selectedDevice = Global.getCurrentDeviceInfo();
+ if (null != devices && !devices.isEmpty()) {
+ devices.remove(deviceInfo);
+ if (!AnalyzerManager.isRunning()) {
+ updateToolbarDevice();
+ }
+ if (isRunning()) {
+ if (selectedDevice.getIDevice().getSerialNumber()
+ .equals(deviceInfo.getIDevice().getSerialNumber())) {
+ Logger.debug("Disconnected while DA is running."); //$NON-NLS-1$
+ DACommunicator.setRunning(false);
+ }
+ }
+ }
+ }
+
+ private void onConnectedInternal(IDevice device) {
+ Logger.debug("device connected : " + device.getSerialNumber());
+ // addDevice(device);
+ if (!AnalyzerManager.isRunning()) {
+ DeviceInfo devInfo = new DeviceInfo(device);
+ HostResult result = readVersion(devInfo);
+ if (result.isSuccess()) {
+ devInfo.initCommunicator();
+ updateToolbarDevice();
+ }
+ }
+ if (null != Global.getCurrentDeviceInfo() && null != Global.getCurrentApplication()) {
+ Display.getDefault().syncExec(new Runnable() {
+ @Override
+ public void run() {
+ ToolbarArea.getInstance().setStartButtonEnablement(true);
+ }
+ });
+ }
+ }
};
public static void updateToolbarDevice() {
public static void pullDaemonLog() {
final String from = PathConstants.DA_DAEMON_LOG_PATH;
- final String to = PathManager.DA_LOG_PATH + File.separator + DAEMONLOG_PREFIX
- + PathManager.getLogPostFix();//$NON-NLS-1$
- SyncResult res = CommunicatorUtils.pull(from, to);
- if (null != res && res.isOk()) {
- Logger.debug("daemon log copying success!!");//$NON-NLS-1$
- } else {
- Logger.debug("Failed to get " + from); //$NON-NLS-1$
+ String command = AnalyzerShellCommands.CMD_GET_FILE_SIZE + CommonConstants.SPACE + from;
+
+ cmdResultMultiLines.clear();
+ CommunicatorUtils.execShellCommand(command, new MultiLineReceiver() {
+ @Override
+ public void processNewLines(String[] lines) {
+ for (int i = 0; i < lines.length; i++) {
+ cmdResultMultiLines.add(lines[i]);
+ }
+ }
+ });
+
+ long filesize = -1;
+ if (cmdResultMultiLines.size() > 0) {
+ filesize = Long.parseLong(cmdResultMultiLines.get(0));
}
- AnalyzerUtil.checkLogs(PathManager.DA_LOG_PATH, DAEMONLOG_PREFIX, DAEMONLOG_COUNT);
+ if (filesize > 0 && filesize < DALimit.MAX_DAEMON_LOG_SIZE) {
+ final String to = PathManager.DA_LOG_PATH + File.separator + DAEMONLOG_PREFIX
+ + PathManager.getLogPostFix();//$NON-NLS-1$
+ SyncResult res = CommunicatorUtils.pull(from, to);
+ if (null != res && res.isOk()) {
+ Logger.debug("daemon log copying success!!");//$NON-NLS-1$
+ } else {
+ Logger.debug("Failed to get " + from); //$NON-NLS-1$
+ }
+
+ AnalyzerUtil.checkLogs(PathManager.DA_LOG_PATH, DAEMONLOG_PREFIX, DAEMONLOG_COUNT);
+ } else {
+ Logger.debug("daemon log file is too large or does not exist");
+ }
}
// public static String getLocalhost() {
import java.util.List;
import java.util.Map;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.project.AppInfo;
import org.tizen.dynamicanalyzer.project.PackageInfo;
pkgInfo.setPackageId(value);
} else if (key.equals(PackageInfo.VERSION)) {
pkgInfo.setVersion(value);
+ } else if (key.equals(PackageInfo.PRELOAD)) {
+ pkgInfo.setPreload(Integer.parseInt(value));
} else if (key.equals(PackageInfo.INSTALLTIME)) {
pkgInfo.setInstallTime(Long.parseLong(value));
}
}
-
- if (pkgInfo.getPackageId() != null) {
- return pkgInfo;
- } else {
+
+ if (pkgInfo.getPackageId() == null) {
return null;
+ } else if (!Global.isPlatformSDK() && pkgInfo.getPreload() != 0) {
+ return null;
+ } else {
+ return pkgInfo;
}
}
*/
// length of string type column
+ public static final int SHORT_TEXT_LEN = 64;
public static final int TEXT_LEN = 256;
public static final int BIG_TEXT_LEN = 1024;
+ public static final int LONG_TEXT_LEN = 4096;
public static final int BIGBIG_TEXT_LEN = 16384;
+ public static final String SHORT_TEXT = "VARCHAR(" + SHORT_TEXT_LEN + ")";//$NON-NLS-1$
public static final String TEXT = "VARCHAR(" + TEXT_LEN + ")";//$NON-NLS-1$
public static final String BIG_TEXT = "VARCHAR(" + BIG_TEXT_LEN + ")";//$NON-NLS-1$
public static final String BIGBIG_TEXT = "VARCHAR(" + BIGBIG_TEXT_LEN + ")";//$NON-NLS-1$
+ public static final String LONG_TEXT = "VARCHAR(" + LONG_TEXT_LEN + ")";//$NON-NLS-1$
public static final String TEXT_LIB_NAME = "VARCHAR(1024)";//$NON-NLS-1$
// types type constant
boolean isSuccess = true;
List<List<Object>> profilingChilds = FunctionUsageProfiler.getInstance()
.getProfilingChildDataTable().getProfilingChildDataFromDB();
- if (null == profilingChilds) {
+ if (null == profilingChilds || 0 == profilingChilds.size()) {
Logger.debug("failed - loadProfilingChildData");
isSuccess = false;
} else {
- for (int i = 0; i < profilingChilds.size(); i++) {
+ int size = profilingChilds.size();
+ for (int i = 0; i < size; i++) {
List<Object> data = profilingChilds.get(i);
int parentID = (Integer) data.get(ProfilingChildDataDBTable.COLUMN.PROFILINGDATAID.index);
int pid = (Integer) data.get(ProfilingChildDataDBTable.COLUMN.PID.index);
- int childID = (Integer) data.get(ProfilingChildDataDBTable.COLUMN.CHILDDATAID.index);
+ @SuppressWarnings("unchecked")
+ List<Integer> childSeqList =
+ (List<Integer>) data.get(ProfilingChildDataDBTable.COLUMN.CHILDSEQARRAY.index);
+
ProfileDataMaker profiler = FunctionUsageProfiler.getInstance()
.getProfileDataMakerByPid(pid);
ProfilingData parent = profiler.getProfilingDataMap().get(parentID);
ProfilingChildData child = parent.getChildData();
- child.getChildren().add(childID);
+ child.getChildren().addAll(childSeqList);
}
}
return isSuccess;
public static final int FD_API_TYPE_LOCK_START = 14;
public static final int FD_API_TYPE_LOCK_END = 15;
public static final int FD_API_TYPE_UNLOCK = 16;
- public static final int FD_API_TYPE_LOCK_WAIT_START = 17;
- public static final int FD_API_TYPE_LOCK_WAIT_END = 18;
+ public static final int FD_API_TYPE_LOCK_AUTORELEASE = 17;
+ public static final int FD_API_TYPE_FAIL = 18;
/* network api type */
public static final int SOCKET_API_FD_OPEN = 0;
public static String FILE_CHART_TOOLTIP_READ;
public static String FILE_CHART_TOOLTIP_CONCURRENT_READ;
public static String FILE_CHART_TOOLTIP_LOCK;
+ public static String FILE_CHART_TOOLTIP_UNLOCK;
+ public static String FILE_CHART_TOOLTIP_LOCK_AUTORELEASE;
public static String FILE_CHART_TOOLTIP_LOCK_WAIT;
+ public static String FILE_CHART_TOOLTIP_FAIL;
+
public static String FILE_API_DB;
public static String FILE_STATUS_DB;
public static String FILE_ACCESS_DB;
+ public static String FILE_ACCESSOR_DB;
public static String FILE_CHART_LOCK;
FILE_CHART_TOOLTIP_CONCURRENT_WRITE=CONCURRENT WRITE
FILE_CHART_TOOLTIP_READ=READ
FILE_CHART_TOOLTIP_CONCURRENT_READ=CONCURRENT READ
-FILE_CHART_TOOLTIP_LOCK=LOCKED
+FILE_CHART_TOOLTIP_LOCK=LOCK
+FILE_CHART_TOOLTIP_UNLOCK=UNLOCK
FILE_CHART_TOOLTIP_LOCK_WAIT=LOCK WAITING
+FILE_CHART_TOOLTIP_LOCK_AUTORELEASE=AUTO RELEASE
+FILE_CHART_TOOLTIP_FAIL=FAIL
FILE_API_DB=FILE_API_DB
FILE_STATUS_DB=FILE_STATUS_DB
FILE_ACCESS_DB=FILE_ACCESS_DB
+FILE_ACCESSOR_DB=FILE_ACCESSOR_DB
TIME_MS = ms
public class ThreadPageLabels extends NLS {
private static final String BUNDLE_NAME = "org.tizen.dynamicanalyzer.nl.ThreadPageLabels"; //$NON-NLS-1$
public static String THREAD_CHART_THREAD;
+ public static String THREAD_CHART_SYNC;
public static String THREAD_CHART_TITLE;
public static String THREAD_DETAILS_TITLE;
public static String SYNC_CHART_TITLE;
THREAD_CHART_THREAD=Thread
+THREAD_CHART_SYNC=Sync
THREAD_CHART_TITLE=Thread Chart
THREAD_DETAILS_TITLE=Thread Details
SYNC_CHART_TITLE=Sync Chart
public static String ERROR_LIB_NOT_FOUND_INRPM;
public static String ERROR_NO_APPID_FOR_LAUNCHPAD;
public static String ERROR_DEVICE_CONNECTION;
+
+ public static String ERROR_BY_SECURITY_REASON;
public static String WARNING_PATH_NOT_FOUND;
public static String WARNING_FILE_NOT_FOUND;
ERROR_NO_APPID_FOR_LAUNCHPAD=There is no appid for launch_app.
ERROR_DEVICE_CONNECTION=Failed to connect with the device.\nPlease re-run Dynamic Analyzer and reboot the device.
+ERROR_BY_SECURITY_REASON=You cannot analyze this application for the security reason.
+
WARNING_PATH_NOT_FOUND=Path cannot be found.
WARNING_FILE_NOT_FOUND=File cannot be found.
private ElfSymbolExtractor symbolExtractor = new ElfSymbolExtractor();
+ // temporary information
+ private String execPath = null;
private String execFileName = null;
+
private List<String> localPackagePath = null;
private Map<Integer, String> runningProcesses = null;
- private String execPath = null;
private static List<String> readlinkResult = new ArrayList<String>();
private List<String> properties = new ArrayList<String>();
public void setInfo(int index, String data) {
properties.set(index, data);
+ if (index == PROPERTY.EXEC.index) {
+ execFileName = null;
+ execPath = null;
+ }
}
public String getInfo(int index) {
public String getPackageId() {
return properties.get(PROPERTY.PACKAGE.index);
}
-
+
public String getLabel() {
return properties.get(PROPERTY.LABEL.index);
}
readlinkResult.add(appLines[i]);
}
}
- }); // get actual file path using da readlink command (inside target
- // platform)
+ }); // get actual file path using da readlink command (inside target platform)
- if (readlinkResult.isEmpty() || readlinkResult.size() > 1) { // fail
- // to
- // get
- // path
+ if (readlinkResult.isEmpty() || readlinkResult.size() > 1) {
+ // fail to get path
if (getAppType().contains(APPTYPE_CPP)) {
exec = exec.replaceFirst(AnalyzerConstants.TIZEN_APP_PATH,
AnalyzerConstants.TIZEN_USR_APP_PATH);
public static final String PKGTYPE = "pkg_type";
public static final String PKGID = "pkgid";
public static final String VERSION = "version";
+ public static final String PRELOAD = "preload";
public static final String INSTALLTIME = "installed_time";
private String id = null;
private String pkgType = null;
private String version = null;
+ private int preload = 0; // 1 for preload, otherwise 0
private long installTime = 0;
private List<AppInfo> appInfos = new ArrayList<AppInfo>();
public void setVersion(String version) {
this.version = version;
}
+
+ public int getPreload() {
+ return preload;
+ }
+
+ public void setPreload(int preload) {
+ this.preload = preload;
+ }
public long getInstallTime() {
return installTime;
}
protected ConcurrentHashMap<Integer, ConcurrentHashMap<Long, CallStackUnit>> callstackApiAddrByPidMap = new ConcurrentHashMap<Integer, ConcurrentHashMap<Long, CallStackUnit>>();
- protected ConcurrentHashMap<Long, CallStackData> callstackDataBySeqMap = new ConcurrentHashMap<Long, CallStackData>();
+ protected ConcurrentSkipListMap<Long, CallStackData> callstackDataBySeqMap = new ConcurrentSkipListMap<Long, CallStackData>();
protected String userFunctionBin = null;
protected HashMap<Integer, List<CallStackItem>> userCallstackByTidMap = new HashMap<Integer, List<CallStackItem>>();
protected HashMap<Integer, DuplicateUserCall> dupUserCallByTidMap = new HashMap<Integer, DuplicateUserCall>();
abstract public void makeUserCallstackforRange(LogData log, ProfileDataMaker profiler);
abstract public void makeCallstackWithoutBacktrace(LogData inputData);
+ abstract public long getSeqOfUserCallstackForTime(int tid, long time);
+ abstract public List<Long> getCallstackAddrListFromSeq(long seq);
+ abstract public List<List<Long>> getArrayOfAddrListFromSeq(List<Long> seqs);
public void offerCallStackUnit(CallStackUnit csu) {
if (callstackInserter != null) {
return;
}
- public List<Integer> getPidsOfCallstackApiAddrMap() {
- ArrayList<Integer> pids = new ArrayList<Integer>();
- pids.addAll(callstackApiAddrByPidMap.keySet());
-
- return pids;
- }
-
public Map<Long, CallStackUnit> getCallStackApiAddrByPidMap(int pid) {
if (null == callstackApiAddrByPidMap) {
callstackApiAddrByPidMap = new ConcurrentHashMap<Integer, ConcurrentHashMap<Long, CallStackUnit>>();
return callstackApiByAddrMap;
}
- public Map<Long, CallStackData> getCallStackDataBySeqMap() {
+ public NavigableMap<Long, CallStackData> getCallStackDataBySeqMap() {
if (null == callstackDataBySeqMap) {
- callstackDataBySeqMap = new ConcurrentHashMap<Long, CallStackData>();
+ callstackDataBySeqMap = new ConcurrentSkipListMap<Long, CallStackData>();
}
return callstackDataBySeqMap;
}
}
return seqByTimeMap;
}
+
+ public List<Integer> getTidsOfSeqTimeMap() {
+ ArrayList<Integer> tids = new ArrayList<Integer>();
+ tids.addAll(seqTimeByTidMap.keySet());
+
+ return tids;
+ }
public String getUserFunctionPosition() {
if (userFunctionBin == null || userFunctionBin.isEmpty()) {
import java.util.List;
import java.util.Map;
import java.util.NavigableMap;
+import java.sql.ResultSet;
+import java.sql.SQLException;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.Global;
+import org.tizen.dynamicanalyzer.database.SqlConnectionManager;
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
import org.tizen.dynamicanalyzer.project.BinaryInfo;
import org.tizen.dynamicanalyzer.project.LibraryObject;
import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackItem;
import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackUnit;
import org.tizen.dynamicanalyzer.ui.summary.profiling.ProfileDataMaker;
+import org.tizen.dynamicanalyzer.ui.timeline.calltrace.FunctionEntryDBTable;
+import org.tizen.dynamicanalyzer.ui.timeline.calltrace.FunctionExitDBTable;
import org.tizen.dynamicanalyzer.util.Logger;
public class SWAPCallStackManager extends BaseCallstackManager {
return;
}
- List<CallStackItem> probeCallstack = new ArrayList<CallStackItem>(getUserCallstack(tid));
- int size = probeCallstack.size();
+ long userCallstackSeq = getSeqOfUserCallstackForTime(tid, time);
+ List<Long> addrs = null;
+ int size = 0;
+
+ if (-1 != userCallstackSeq) { // seq for usercallstack is found
+ addrs = getCallstackAddrListFromSeq(userCallstackSeq);
+ if (null != addrs) { // callstack data for seq is found
+ size = addrs.size();
+ }
+ }
CallStackData callstackData = new CallStackData(seq);
offerCallStackUnit(callbackApi);
addrMap.put(LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_ADDR, callbackApi);
}
- probeCallstack.add(new CallStackItem(callbackApi));
+ if (null == addrs) {
+ addrs = new ArrayList<Long>();
+ }
+ addrs.add(0, LogCenterConstants.USER_FUNCTION_CALLBACK_FUNC_ADDR);
} else {
CallStackUnit callerCallstackUnit = addrMap.get(callerAddr);
if (null == callerCallstackUnit) {
addrMap.put(callerAddr, callerCallstackUnit);
}
- CallStackUnit topUserCallstack = probeCallstack.get(size - 1).getCallStackUnit();
+ CallStackUnit topUserCallstack = addrMap.get(addrs.get(0));
if (callerCallstackUnit.getFunctionId() == topUserCallstack.getFunctionId()) {
- probeCallstack.set(size - 1, new CallStackItem(callerCallstackUnit));
+ addrs.set(0, callerAddr);
} else {
Logger.debug("probe caller is not the same as top of user callstack"); //$NON-NLS-1$
}
}
- size = probeCallstack.size();
- for (int i = size - 1; i >= 0; i--) {
- callstackData.getAddrs().add(probeCallstack.get(i).getCallStackUnit().getAddr());
+ size = addrs.size();
+ for (int i = 0; i < size; i++) {
+ callstackData.getAddrs().add(addrs.get(i));
}
offerCallStackData(callstackData);
getCallStackDataBySeqMap().put(seq, callstackData);
}
+ // to make callstack for sample, probe
+ public long getSeqOfUserCallstackForTime(int tid, long time) {
+ long seq = -1;
+ String query;
+ long entrySeq = -1, exitSeq = -1;
+ ResultSet rs;
+ NavigableMap<Long, Long> seqByTimeMap = getSeqTimeByTidMap(tid);
+ Long callstackTime = seqByTimeMap.floorKey(time);
+
+ if (null != callstackTime) { // found from memory
+ seq = seqByTimeMap.get(callstackTime);
+ } else { // select from database
+ try {
+ query = String.format(FunctionEntryDBTable.USERCALLSTACK_QUERY, time);
+ rs = SqlConnectionManager.executeQueryRS(query);
+ if (rs.next()) {
+ entrySeq = rs.getLong(1);
+ }
+ SqlConnectionManager.releaseResultSet(rs);
+
+ query = String.format(FunctionExitDBTable.USERCALLSTACK_QUERY, time);
+ rs = SqlConnectionManager.executeQueryRS(query);
+ if (rs.next()) {
+ exitSeq = rs.getLong(1);
+ }
+ SqlConnectionManager.releaseResultSet(rs);
+ if (entrySeq < exitSeq) { // greater seq which time is less than sample/probe time
+ seq = exitSeq;
+ } else {
+ seq = entrySeq;
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+ }
+
+ return seq;
+ }
+
+ public List<Long> getCallstackAddrListFromSeq(long seq) {
+ List<Long> addrs = null;
+ CallStackData csd = getCallStackDataBySeqMap().get(seq);
+
+ if (null == csd) { // callstackdata is not in memory, find from DB
+ List<List<Object>> callStackAddrs = CallStackInserter.getInstance()
+ .getCallStackDataTable().getCallStackAddrsFromDB(seq);
+
+ if (null == callStackAddrs || 0 == callStackAddrs.size()
+ || null == callStackAddrs.get(0)) { // not found
+ Logger.debug("CallStackData is not found for seq : " + seq);
+ return null;
+ }
+
+ @SuppressWarnings("unchecked")
+ List<Long> addressList = (List<Long>) callStackAddrs.get(0).get(0);
+
+ addrs = new ArrayList<Long>();
+ addrs.addAll(addressList);
+ } else { // callstackdata is in memory
+ addrs = csd.getAddrs();
+ }
+ return addrs;
+ }
+//TODO: 1. execute select query once 2. change return type - <seq, List<Long>>
+//TODO: 3. additional discussion with leak analysis implementer if needed
+ public List<List<Long>> getArrayOfAddrListFromSeq(List<Long> seqs) {
+ List<List<Long>> addrsList = null;
+ if (null == seqs) {
+ return null;
+ }
+
+ addrsList = new ArrayList<List<Long>>();
+ int size = seqs.size();
+ for (int i = 0; i < size; i++) {
+ List<Long> addrs = getCallstackAddrListFromSeq(seqs.get(i));
+ if (null != addrs) {
+ addrsList.add(addrs);
+ }
+ }
+
+ return addrsList;
+ }
+
public void clear() {
callstackApiAddrByPidMap.clear();
callstackDataBySeqMap.clear();
}
+ // FIXME: black list hard coded.
+ // function instrumentation black list
+ public static boolean isInBlacklist(String funcname) {
+ if (funcname.equals("_start")) {
+ return true;
+ }
+
+ if (funcname.contains("get_pc_thunk")) {
+ return true;
+ }
+
+ return false;
+ }
+
}
--- /dev/null
+package org.tizen.dynamicanalyzer.swap.communicator;
+
+import static org.tizen.dynamicanalyzer.constant.CommonConstants.INT_SIZE;
+
+import java.util.Arrays;
+
+import org.tizen.dynamicanalyzer.util.ByteUtil;
+
+public class AckMessage {
+ private int msgID = -1;
+ private int payloadLength = -1;
+ private int returnCode = -1;
+ private byte[] payload = null; // this payload include returnCode
+
+ public static AckMessage NOACK = new AckMessage(SwapErrorCode.SUCCESS);
+
+ public AckMessage() {
+
+ }
+
+ private AckMessage(SwapErrorCode errorcode) {
+ this.msgID = 0;
+ this.returnCode = errorcode.getErrorNumber();
+ }
+
+ public int getMsgID() {
+ return msgID;
+ }
+
+ public int getPayloadLength() {
+ return payloadLength;
+ }
+
+ public int getReturnCode() {
+ return returnCode;
+ }
+
+ public byte[] getPayload() {
+ return payload;
+ }
+
+ public boolean isSuccess() {
+ if (returnCode == SwapErrorCode.SUCCESS.getErrorNumber()) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ public boolean isCorrectID(int msgid) {
+ if (this.msgID == msgid) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ public void parseAck(byte[] message) {
+ int index = 0;
+ this.msgID = ByteUtil.toInt(message, index);
+ index += INT_SIZE;
+ this.payloadLength = ByteUtil.toInt(message, index);
+ index += INT_SIZE;
+ if (message.length > index) {
+ this.payload = Arrays.copyOfRange(message, index, message.length);
+
+ // the first value of payload is usually return code
+ this.returnCode = ByteUtil.toInt(this.payload, 0);
+ }
+ }
+}
import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_START_ACK;
import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_STOP_ACK;
import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_TARGET_INFO_ACK;
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_GET_PROCESS_ADD_INFO_ACK;
import static org.tizen.dynamicanalyzer.constant.CommonConstants.INT_SIZE;
import static org.tizen.dynamicanalyzer.constant.CommonConstants.LONG_SIZE;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.AnalyzerShellCommands;
import org.tizen.dynamicanalyzer.common.ElfSymbolExtractor;
-import org.tizen.dynamicanalyzer.common.ErrorCode;
import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.common.HostResult;
import org.tizen.dynamicanalyzer.common.path.PathManager;
import org.tizen.dynamicanalyzer.model.AddrSymbolPair;
import org.tizen.dynamicanalyzer.model.DeviceInfo;
import org.tizen.dynamicanalyzer.nl.ConfigureLabels;
+import org.tizen.dynamicanalyzer.nl.UserErrorWarningLabels;
import org.tizen.dynamicanalyzer.project.AppInfo;
import org.tizen.dynamicanalyzer.project.BinaryInfo;
import org.tizen.dynamicanalyzer.project.DeviceStatusInfo;
UserSpaceInst userSpaceInst = getUserSpaceInst();
Logger.performance("TEST", "Start Trace", "Set application inst");
- if (userSpaceInst == null) {
+ if (userSpaceInst == null || userSpaceInst.getAppInstList().isEmpty()) {
+ StartProcessManager.getInstance().setValue(100); // set progress bar to 100%
Logger.error("cannot get user space inst");
return HostResult.ERR_MSG_START_FAIL;
}
}
}
- // data receive thread create and start
- Thread dataThread = new Thread(null, new DataChannelThread(),
- AnalyzerConstants.COMMUNICATOR_RECEIVE_THREAD);
// start message send
- HostResult result = handleControlMessage(curDev, ret);
+ AckMessage result = handleControlMessage(curDev, ret);
Logger.performance("TEST", "Start Trace", "Make and Send start message");
// FIX
StartProcessManager.getInstance().setValue(100);
}
- if (result.isSuccess()) {
- if (!isCorrectAck(MSG_START_ACK, result)) {
- HostResult failResult = HostResult.ERR_MSG_START_FAIL;
- failResult.setMessage(ErrorCode.getError(getReturnId(result.getRet())).toString());
- DACommunicator.setRunning(false);
- dataThread = null;
- return failResult;
- } else { // right ack for start
- byte[] data = result.getRet();
- int index = 0;
- index += INT_SIZE; // message id
- index += INT_SIZE; // payload length
- index += INT_SIZE; // return id
- int sec = ByteUtil.toInt(data, index);
- index += INT_SIZE;
- int nano = ByteUtil.toInt(data, index);
-
- Global.getProject().setProfilingStartTime(new DATime(sec, nano));
- }
+ if (result != null && result.isCorrectID(MSG_START_ACK) && result.isSuccess()) {
+ byte[] payload = result.getPayload();
+ int index = INT_SIZE; // return code
+ int sec = ByteUtil.toInt(payload, index);
+ index += INT_SIZE;
+ int nano = ByteUtil.toInt(payload, index);
+ index += INT_SIZE;
+
+ Global.getProject().setProfilingStartTime(new DATime(sec, nano));
+
+ // data receive thread create and start
+ Thread dataThread = new Thread(null, new DataChannelThread(),
+ AnalyzerConstants.COMMUNICATOR_RECEIVE_THREAD);
+ dataThread.start();
+ Logger.performance("TEST", "Start Trace", "Start data receiving thread");
+
+ ToolbarArea.getInstance().startTimer();
+ Logger.performance("TEST", "Start Trace", "Start Timer");
+ SWAPLogParser.startLogParser();
+ Logger.performance("TEST", "Start Trace", "Start SWAP log parser thread");
+
+ // start registered data manager thread
+ DataManagerRegistry.startThreads();
+ Logger.performance("TEST", "Start Trace", "Start DataManager threads");
+
+ /* Timeline */
+ UpdateViewTimer.start();
+ Logger.performance("TEST", "Start Trace", "Start Update view timer");
+
+ Logger.debug("Start recorder, timer, log parser, file, thread, ui, profile , update timer");
+ return HostResult.SUCCESS;
} else {
DACommunicator.setRunning(false);
- dataThread = null;
- return result;
+ return HostResult.ERR_MSG_START_FAIL;
}
-
- dataThread.start();
- Logger.performance("TEST", "Start Trace", "Start data receiving thread");
-
- // success start trace!!
- byte[] payload = getMessagePayload(result.getRet());
- DATime profilingStartTime = new DATime();
- int index = 0;
- int sec = ByteUtil.toInt(payload, index);
- index += INT_SIZE;
- int nano = ByteUtil.toInt(payload, index);
- index += INT_SIZE;
- profilingStartTime.setSec(sec);
- profilingStartTime.setNano(nano);
-
- ToolbarArea.getInstance().startTimer();
- Logger.performance("TEST", "Start Trace", "Start Timer");
- SWAPLogParser.startLogParser();
- Logger.performance("TEST", "Start Trace", "Start SWAP log parser thread");
- // start registered data manager thread
- DataManagerRegistry.startThreads();
- Logger.performance("TEST", "Start Trace", "Start DataManager threads");
-
- /* Timeline */
- UpdateViewTimer.start();
- Logger.performance("TEST", "Start Trace", "Start Update view timer");
- Logger.debug("Start recorder, timer, log parser, file, thread, ui, profile , update timer");
- return result;
}
private UserSpaceInst getUserSpaceInst() {
for (int i = 0; i < size; i++) {
AddrSymbolPair addrSymbol = symbols.get(i);
String symbol = addrSymbol.getSymbol();
- // FIXME: black list hard coded.
- if (symbol.contains("__i686.get_pc_thunk")) {
+
+ if (FunctionInst.isInBlacklist(symbol)) {
continue;
}
int length = preMsg.length;
byte[] msg = ByteUtil.getByte(msgBinInfo, length, preMsg);
- HostResult result = handleControlMessage(curDevice, msg);
-
- if (!result.isSuccess() || !isCorrectAck(MSG_BINARY_INFO_ACK, result)) {
- return HostResult.ERR_BIN_INFO_GET_FAIL;
- }
+ AckMessage result = handleControlMessage(curDevice, msg);
- // parse binary info
- byte[] payload = getMessagePayload(result.getRet());
- List<BinaryInfo> bininfos = new ArrayList<BinaryInfo>();
+ if (result != null && result.isCorrectID(MSG_BINARY_INFO_ACK)) {
+ if (result.isSuccess()
+ || (result.getReturnCode() == SwapErrorCode.ERR_WRONG_MESSAGE_DATA
+ .getErrorNumber() && result.getPayloadLength() > INT_SIZE)) {
- parseBinaryInfo(payload, paths, bininfos);
+ // parse binary info
+ List<BinaryInfo> bininfos = new ArrayList<BinaryInfo>();
+ parseBinaryInfo(result.getPayload(), paths, bininfos);
+ return HostResult.SUCCESS;
+ }
+ }
- return result;
+ return HostResult.ERR_BIN_INFO_GET_FAIL;
}
private String getFileName(String fullPath) {
}
private HostResult pullTheFile(String from, String to) {
+ boolean becomeSuper = false;
try {
- Global.getCurrentDeviceInfo().getIDevice().becomeSuperUser(true);
+ becomeSuper = Global.getCurrentDeviceInfo().getIDevice().becomeSuperUser(true);
} catch (TimeoutException e) {
e.printStackTrace();
} catch (SdbCommandRejectedException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
+ } finally {
+ if (!becomeSuper) {
+ return HostResult.ERR_BY_SECURITY_REASON;
+ }
}
SyncResult res = CommunicatorUtils.pull(from, to);
.getSelectedFeatureValue(ConfigureLabels.FEATURE_DETAIL_VALUE_FUNCTION_PROFILING_SAMPLING_RATE);
if (samplingPeriod < 0) {
samplingPeriod = target.getAvailableFeature(
- ConfigureLabels.FEATURE_DETAIL_VALUE_FUNCTION_PROFILING_SAMPLING_RATE).getDefaultValue();
+ ConfigureLabels.FEATURE_DETAIL_VALUE_FUNCTION_PROFILING_SAMPLING_RATE)
+ .getDefaultValue();
}
rt.setSystemTracePeriod(systemPeriod);
rt.setSamplingPeriod(samplingPeriod);
int length = rtByte.length;
byte[] msg = ByteUtil.getByte(config, length, rtByte);
- // ByteUtils.printByteArrayForStart(msg);
+ AckMessage result = handleControlMessage(devInfo, msg);
- HostResult result = handleControlMessage(devInfo, msg);
+ if (result != null && result.isCorrectID(MSG_CONFIG_ACK) && result.isSuccess()) {
+ if (AnalyzerManager.isRunning()) {
+ rt.setApplyTime(ToolbarArea.getInstance().getTime());
+ Global.getProject().addConfigHistory(rt);
+ } else {
+ rt.setApplyTime(0); // set time of configuration to zero
+ }
- if (result.isSuccess()) {
- if (isCorrectAck(MSG_CONFIG_ACK, result)) {
- if (AnalyzerManager.isRunning()) {
- rt.setApplyTime(ToolbarArea.getInstance().getTime());
- Global.getProject().addConfigHistory(rt);
- } else {
- rt.setApplyTime(0); // set time of configuration to zero
+ Global.setCurrentConfiguration(rt);
+ return HostResult.SUCCESS;
+ } else {
+ Display.getDefault().asyncExec(new Runnable() {
+ @Override
+ public void run() {
+ final Shell shell = WorkbenchUtil.getWorkbenchWindow().getShell();
+ DADialog dialog = new DADialog(shell, SWT.NONE, 550, 153);
+ dialog.setIcon(ImageResources.DIALOG_WARNING_ICON);
+ dialog.setMessage("Configuration failed..");
+ dialog.open();
}
-
- Global.setCurrentConfiguration(rt);
- return result;
- }
+ });
+ return HostResult.ERR_MSG_RUNTIME_FAIL;
}
- Display.getDefault().asyncExec(new Runnable() {
- @Override
- public void run() {
- final Shell shell = WorkbenchUtil.getWorkbenchWindow().getShell();
- DADialog dialog = new DADialog(shell, SWT.NONE, 550, 153);
- dialog.setIcon(ImageResources.DIALOG_WARNING_ICON);
- dialog.setMessage("Configuration failed..");
- dialog.open();
- }
- });
- return HostResult.ERR_MSG_RUNTIME_FAIL;
}
@Override
byte[] stop = ByteUtil.toBytes(AnalyzerConstants.MSG_STOP_SWAP);
int length = 0;
byte[] stopMsg = ByteUtil.getByte(stop, length);
- HostResult result = handleControlMessage(stopMsg);
+ AckMessage result = handleControlMessage(stopMsg);
- if (result.isSuccess()) {
- if (isCorrectAck(MSG_STOP_ACK, result)) {
- return result;
- }
+ if (result != null && result.isCorrectID(MSG_STOP_ACK) && result.isSuccess()) {
+ return HostResult.SUCCESS;
}
}
+
return HostResult.ERR_MSG_STOP_FAIL;
}
}
}
- public HostResult handleControlMessage(byte[] message) {
+ public AckMessage handleControlMessage(byte[] message) {
DeviceInfo curDev = Global.getCurrentDeviceInfo();
if (curDev != null) {
return handleControlMessage(curDev, message);
} else {
- return HostResult.ERR_DEVICE_IS_NULL;
+ return null;
}
}
- public HostResult handleControlMessage(DeviceInfo device, byte[] message) {
+ public AckMessage handleControlMessage(DeviceInfo device, byte[] message) {
if (device != null) {
return handleControlMessage(device, message, true,
AnalyzerConstants.CONTROL_SOCKET_TIMEOUT);
} else {
- return HostResult.ERR_DEVICE_IS_NULL;
+ return null;
}
}
* when wait for ack message, time limit of waiting by millisec
* @return HostResult
*/
- public HostResult handleControlMessage(DeviceInfo device, byte[] message, boolean waitack,
+ public AckMessage handleControlMessage(DeviceInfo device, byte[] message, boolean waitack,
int timeout) {
- HostResult result = null;
+ AckMessage retack = null;
Socket controlSock = device.getControlSock();
try {
synchronized (controlSock) {
controlSock.getOutputStream().write(message);
if (!waitack) {
- return HostResult.SUCCESS;
+ return AckMessage.NOACK;
}
Logger.debug("wait for ack of message [" + ByteUtil.toInt(message) + "]");
if (readsize > 0) {
byte[] buf = new byte[readsize];
System.arraycopy(cbuf, 0, buf, 0, readsize);
- result = HostResult.SUCCESS;
int ackId = ByteUtil.toInt(buf);
// for debug
- System.out.print("ack id : ");
- AnalyzerUtil.printHexdecimal(ackId);
- Logger.debug();
+ Logger.debug("ack id : " + AnalyzerUtil.toHexdecimal(ackId));
- result.setRet(buf);
+ retack = new AckMessage();
+ retack.parseAck(buf);
} else {
- result = HostResult.ERR_RECEIVE_ACK_FAIL;
- result.setMessage(result.getMessage());
+ Logger.warning("Read size for ack message is zero");
}
} else {
- result = HostResult.ERR_CONTROL_SOCKET_CONNECTION_CLOSED;
- result.setMessage("Control socket connection is closed");
+ Logger.warning("Control socket connection is closed");
}
} catch (SocketException e) {
- result = HostResult.ERR_EXCEPTION_OCCURRED;
- result.setMessage(e.getMessage());
e.printStackTrace();
} catch (SocketTimeoutException e) {
- result = HostResult.ERR_EXCEPTION_OCCURRED;
- result.setMessage(e.getMessage());
e.printStackTrace();
} catch (IOException e) {
- result = HostResult.ERR_EXCEPTION_OCCURRED;
- result.setMessage(e.getMessage());
e.printStackTrace();
} finally {
blocked = false;
}
- return result;
+
+ return retack;
}
private HostResult createControlSocket(DeviceInfo device) {
public HostResult getTargetInfo(DeviceInfo device) {
Logger.debug("Send target info...");
- HostResult result = handleControlMessage(device,
+ AckMessage result = handleControlMessage(device,
ByteUtil.getByte(AnalyzerConstants.MSG_TARGET_INFO, 0));
- if (result.isSuccess()) {
- // FIXME : log parsing
- byte[] data = result.getRet();
- int index = INT_SIZE * 3;
-
- if (isCorrectAck(MSG_TARGET_INFO_ACK, result)) {
- processTargetInfo(data, index, device.getDeviceStatusInfo());
- return result;
+ if (result != null && result.isCorrectID(MSG_TARGET_INFO_ACK)) {
+ if (result.isSuccess()) {
+ processTargetInfo(result.getPayload(), INT_SIZE, device.getDeviceStatusInfo());
+ return HostResult.SUCCESS;
}
}
+
return HostResult.ERR_TARGET_INFO_GET_FAIL;
}
@Override
public HostResult sendKeepAliveMessage(DeviceInfo device) {
Logger.debug("Send keep alive message...");
- HostResult result = handleControlMessage(device,
+ AckMessage result = handleControlMessage(device,
ByteUtil.getByte(AnalyzerConstants.MSG_KEEP_ALIVE, 0));
- if (result.isSuccess()) {
- Logger.debug("keep alive message ack :" + result.getMessage());
-
- if (isCorrectAck(MSG_KEEP_ALIVE_ACK, result)) {
- return result;
- }
- }
- return HostResult.ERR_KEEP_ALIVE;
- }
-
- private boolean isCorrectAck(int ackType, HostResult result) {
- byte[] data = result.getRet();
- int index = 0;
- int msgId = ByteUtil.toInt(data, index);
- index += INT_SIZE;
- int paylen = ByteUtil.toInt(data, index);
- index += INT_SIZE;
- int retId = ByteUtil.toInt(data, index);
- index += INT_SIZE;
-
- if (ackType == msgId) {
- if (paylen != INT_SIZE || retId == ErrorCode.SUCCESS.getErrorNumber()) {
- return true;
- }
+ if (result != null && result.isCorrectID(MSG_KEEP_ALIVE_ACK) && result.isSuccess()) {
+ return HostResult.SUCCESS;
+ } else {
+ return HostResult.ERR_KEEP_ALIVE;
}
- return false;
}
@Override
Global.getCurrentDeviceInfo().releaseDataSock();
}
- private int getReturnId(byte[] data) {
- int index = INT_SIZE * 2;
- return ByteUtil.toInt(data, index);
- }
-
- private byte[] getMessagePayload(byte[] data) {
- int index = INT_SIZE;
- int size = ByteUtil.toInt(data, index);
- index += INT_SIZE * 2;
- size -= INT_SIZE;
- byte[] payload = new byte[size];
- System.arraycopy(data, index, payload, 0, size);
- return payload;
- }
-
private byte[] getFunctionArgs(String symbol) {
int start = symbol.indexOf(CommonConstants.OPEN_BRACKET);
int end = symbol.indexOf(CommonConstants.CLOSE_BRACKET);
public HostResult sendScreenShotRequest() {
byte[] msg = ByteUtil.getByte(AnalyzerConstants.MSG_GET_SCREENSHOT, 0);
- return handleControlMessage(Global.getCurrentDeviceInfo(), msg, false, 0);
+ AckMessage result = handleControlMessage(Global.getCurrentDeviceInfo(), msg, false, 0);
+ if (result != null && result.isSuccess()) {
+ return HostResult.SUCCESS;
+ } else {
+ return HostResult.ERR_MSG_SEND_FAIL;
+ }
}
public HostResult sendSWAPMessage(int messageId, List<BinarySettingData> settings) {
FunctionInst functionInst = new FunctionInst();
AddrSymbolPair addrSymbol = symbols.get(i);
String symbol = addrSymbol.getSymbol();
- // FIXME: black list hard coded.
- if (symbol.contains("__i686.get_pc_thunk")) {
+
+ if (FunctionInst.isInBlacklist(symbol)) {
exSize++;
continue;
}
+
functionInst.setAddr(addrSymbol.getAddr());
functionInst.setArgs(getFunctionArgs(addrSymbol.getSymbol()));
functionInstList.add(functionInst);
-
- // for debug
- // System.out.print("LIB : addr ");
- // AnalyzerUtil.printHexdecimal(addrSymbol.getAddr());
- // System.out.print(" symbol " + addrSymbol.getSymbol()
- // + " args ");
- // ByteUtils.printByteArray(functionInst.getArgs());
- // System.out.println();
}
size = size - exSize;
libInst = ByteUtil.getByte(libInst, binaryPath, size);
msg = ByteUtil.getByte(msg, length, libInst);
// ByteUtils.printByteArrayForStart(msg);
- HostResult result = handleControlMessage(curDev, msg);
+ AckMessage result = handleControlMessage(curDev, msg);
int ackMsg = AnalyzerConstants.MSG_SWAP_INST_ADD_ACK;
if (messageId == AnalyzerConstants.MSG_SWAP_INST_REMOVE) {
ackMsg = AnalyzerConstants.MSG_SWAP_INST_REMOVE_ACK;
}
- if (!result.isSuccess() || !isCorrectAck(ackMsg, result)) {
+
+ if (result != null && result.isCorrectID(ackMsg) && result.isSuccess()) {
+ return HostResult.SUCCESS;
+ } else {
return HostResult.ERR_BIN_INFO_GET_FAIL;
}
-
- return HostResult.SUCCESS;
}
public Map<Integer, String> sendProcessAddInfoMessage(List<Integer> pids) {
int length = sendbin.length;
byte[] msg = ByteUtil.getByte(AnalyzerConstants.MSG_GET_PROCESS_ADD_INFO, length,
sendbin);
- HostResult result = handleControlMessage(curDev, msg, true,
+ AckMessage result = handleControlMessage(curDev, msg, true,
AnalyzerConstants.PROC_ADD_INFO_TIMEOUT);
- if (result.isSuccess()
- && isCorrectAck(AnalyzerConstants.MSG_GET_PROCESS_ADD_INFO_ACK, result)) {
- // parse binary info
- byte[] payload = getMessagePayload(result.getRet());
- int index = 0;
+ if (result != null && result.isCorrectID(MSG_GET_PROCESS_ADD_INFO_ACK)) {
+ if (result.isSuccess() || result.getPayloadLength() > INT_SIZE) {
+ // parse binary info
+ byte[] payload = result.getPayload();
+ int index = INT_SIZE;
- int count = ByteUtil.toInt(payload, index);
- index += INT_SIZE;
+ int count = ByteUtil.toInt(payload, index);
+ index += INT_SIZE;
- if (count > 0) {
- infoMap = new HashMap<Integer, String>();
+ if (count > 0) {
+ infoMap = new HashMap<Integer, String>();
- for (int i = 0; i < count; i++) {
- int pid = ByteUtil.toInt(payload, index);
- index += INT_SIZE;
- String cmdname = ByteUtil.getString(payload, index);
- index += ByteUtil.getStringLength(payload, index);
+ for (int i = 0; i < count; i++) {
+ int pid = ByteUtil.toInt(payload, index);
+ index += INT_SIZE;
+ String cmdname = ByteUtil.getString(payload, index);
+ index += ByteUtil.getStringLength(payload, index);
- infoMap.put(Integer.valueOf(pid), cmdname);
+ infoMap.put(Integer.valueOf(pid), cmdname);
+ }
}
}
}
int length = sendBin.length;
byte[] msg = ByteUtil.getByte(AnalyzerConstants.MSG_BINARY_INFO, length, sendBin);
- HostResult result = handleControlMessage(msg);
-
- if (!result.isSuccess() || !isCorrectAck(MSG_BINARY_INFO_ACK, result)) {
- return HostResult.ERR_BIN_INFO_GET_FAIL;
- }
+ AckMessage result = handleControlMessage(msg);
- // parse binary info
- byte[] payload = getMessagePayload(result.getRet());
- List<BinaryInfo> bininfos = new ArrayList<BinaryInfo>();
+ if (result != null && result.isCorrectID(MSG_BINARY_INFO_ACK)) {
+ if (result.isSuccess()
+ || (result.getReturnCode() == SwapErrorCode.ERR_WRONG_MESSAGE_DATA
+ .getErrorNumber() && result.getPayloadLength() > INT_SIZE)) {
- parseBinaryInfo(payload, binPaths, bininfos);
+ // parse binary info
+ List<BinaryInfo> bininfos = new ArrayList<BinaryInfo>();
+ parseBinaryInfo(result.getPayload(), binPaths, bininfos);
+ return HostResult.SUCCESS;
+ }
+ }
- return result;
+ return HostResult.ERR_BIN_INFO_GET_FAIL;
}
private void parseBinaryInfo(byte[] payload, List<String> targetPaths,
List<BinaryInfo> outBinaries) {
HostResult result;
- int index = 0;
+ int index = INT_SIZE;
DeviceInfo curDevice = Global.getCurrentDeviceInfo();
result = pullTheFile(targetPath, localBinaryPath);
if (result.isSuccess()) {
binInfo.setTempBinaryPath(localBinaryPath);
+ } else if (result.equals(HostResult.ERR_BY_SECURITY_REASON)) {
+ // popup by security reason
+ Display.getDefault().syncExec(new Runnable() {
+ @Override
+ public void run() {
+ final Shell shell = WorkbenchUtil.getWorkbenchWindow().getShell();
+ DADialog dialog = new DADialog(shell, SWT.NONE, 480, 153);
+ dialog.setIcon(ImageResources.DIALOG_ERROR_ICON);
+ dialog.setMessage(UserErrorWarningLabels.ERROR_BY_SECURITY_REASON);
+ dialog.open();
+ }
+ });
+
+ return;
}
} else {
// if local binary exist already, then check for md5sum
result = pullTheFile(targetPath, localBinaryPath);
if (result.isSuccess()) {
binInfo.setTempBinaryPath(localBinaryPath);
+ } else if (result.equals(HostResult.ERR_BY_SECURITY_REASON)) {
+ // popup by security reason
+ Display.getDefault().syncExec(new Runnable() {
+ @Override
+ public void run() {
+ final Shell shell = WorkbenchUtil.getWorkbenchWindow().getShell();
+ DADialog dialog = new DADialog(shell, SWT.NONE, 480, 153);
+ dialog.setIcon(ImageResources.DIALOG_ERROR_ICON);
+ dialog.setMessage(UserErrorWarningLabels.ERROR_BY_SECURITY_REASON);
+ dialog.open();
+ }
+ });
+
+ return;
}
} else {
binInfo.setTempBinaryPath(localBinaryPath);
} else if (CommonUtil.isMac()) {
cmd = AnalyzerShellCommands.CMD_MAC_MD_5_SUM;
} else if (CommonUtil.isWin()) {
- cmd = PathManager.DA_TOOL_FOLDER_PATH + File.separator + AnalyzerShellCommands.CMD_WIN_MD_5_SUM;
+ cmd = PathManager.DA_TOOL_FOLDER_PATH + File.separator
+ + AnalyzerShellCommands.CMD_WIN_MD_5_SUM;
} else { // should never be here
Logger.error("Unknown host OS!\n");
}
* - S-Core Co., Ltd
*
*/
-package org.tizen.dynamicanalyzer.common;
+package org.tizen.dynamicanalyzer.swap.communicator;
-public enum ErrorCode {
+public enum SwapErrorCode {
SUCCESS(0, "Success"),
ERR_LOCKFILE_CREATE_FAILED(-101, "Lock file create failed"),
ERR_INITIALIZE_SYSTEM_INFO_FAILED(-103, "Initialize system info failed"),
- ERR_HOST_SERVER_SOCKET_CREATE_FAILED(-104,
- "host server socket create failed"),
+ ERR_HOST_SERVER_SOCKET_CREATE_FAILED(-104, "host server socket create failed"),
- ERR_TARGET_SERVER_SOCKET_CREATE_FAILED(-105,
- "target server socket create failed"),
+ ERR_TARGET_SERVER_SOCKET_CREATE_FAILED(-105, "target server socket create failed"),
ERR_WRONG_MESSAGE_FORMAT(-201, "Wrong message format"),
ERR_CANNOT_START_PROFILING(-204, "cannot start profiling"),
+ ERR_SER_SOCK_CREATE(-900, "Server socket creation failed"),
+
+ ERR_SER_SOCK_BIND(-901, "Server socket bind failed"),
+
+ ERR_SER_SOCK_LISTEN(-902, "Server socket listen failed"),
+
ERR_NOT_DEFINED(-999, "Unknown error");
private final String message;
private final int errNo;
- public static final int ERROR_MSG_INDEX = 0;
- public static final int ERROR_LENGTH_INDEX = 1;
- public static final int ERROR_NUMBER_INDEX = 2;
-
- private ErrorCode(int num, String msg) {
+ private SwapErrorCode(int num, String msg) {
errNo = num;
message = msg;
}
return message;
}
- public static ErrorCode getError(int num) {
- ErrorCode[] errors = values();
+ public static SwapErrorCode getError(int num) {
+ SwapErrorCode[] errors = values();
for (int i = 0; i < errors.length; i++) {
if (errors[i].getErrorNumber() == num) {
return errors[i];
}
}
- return ErrorCode.ERR_NOT_DEFINED;
+ return SwapErrorCode.ERR_NOT_DEFINED;
}
}
import org.tizen.dynamicanalyzer.swap.model.data.LogData;
import org.tizen.dynamicanalyzer.swap.model.data.LogDataFactory;
import org.tizen.dynamicanalyzer.swap.model.data.LogDataUtils;
-import org.tizen.dynamicanalyzer.ui.thread.ThreadChartManager;
+import org.tizen.dynamicanalyzer.ui.thread.data.ThreadDataManager;
import org.tizen.dynamicanalyzer.ui.toolbar.StartProcessManager;
import org.tizen.dynamicanalyzer.ui.toolbar.StopLogProcessor;
import org.tizen.dynamicanalyzer.ui.toolbar.StopProcessManager;
import org.tizen.dynamicanalyzer.util.CommonUtil;
import org.tizen.dynamicanalyzer.util.Logger;
import org.tizen.dynamicanalyzer.util.UnsignedInt;
-import org.tizen.dynamicanalyzer.util.WorkbenchUtil;
import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
public class MessageParser {
static final int MSG_BUFFER_MAX = 5000;
static final int MSG_BUFFER_TIMER_DELAY = 5;
static final int MSG_BUFFER_TIMER_PERIOD = 1000; // 1 second
- static final int WAITING_TIME = 100;
+ static final int WAITING_TIME = 10;
public static final int MSG_HEADER_SIZE = 20;
final int MSG_PAYLOAD_SIZE_INDEX = 16;
AnalyzerManager.setProcessInfoArrived(true);
- ThreadChartManager.getInstance().getThreadDataManager().createMainThreadItem(pid);
+ ThreadDataManager.getInstance().getThreadDataMaker().createMainThreadItem(pid);
}
private void memoryMapChanged(byte[] data) {
LibraryObject obj = null;
ProcessMemoryMap pmap = process.getProcessMemoryMap(time);
if (pmap == null || (obj = pmap.getLibraryByAddress(pcAddr)) == null) {
+ Logger.error("cannot find library for the pid and address : " + pid + ", " + pcAddr);
binaryId = -1;
} else {
binaryId = obj.getBinaryID();
+++ /dev/null
-/*
- * Dynamic Analyzer
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * Jaewon Lim <jaewon81.lim@samsung.com>
- * Juyoung Kim <j0.kim@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-
-package org.tizen.dynamicanalyzer.swap.platform.ui.DeviceExplorer;
-
-import org.eclipse.nebula.widgets.grid.GridItem;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.widgets.Composite;
-import org.tizen.dynamicanalyzer.swap.platform.ui.ExplorerUtil;
-import org.tizen.dynamicanalyzer.util.Logger;
-import org.tizen.sdblib.service.FileEntry;
-import org.tizen.sdblib.service.FileEntryType;
-
-public class DADeviceExplorer extends DeviceExplorer {
- public DADeviceExplorer(Composite parent) {
- super(parent);
- }
-
- @Override
- public void updateData() {
- if (null == current) {
- if (null == root) {
- Logger.debug("Root is empty");
- return;
- }
- current = root;
- }
- table.removeAll();
- inputText.setText(current.getFullPath());
-
- if (!current.getFullPath().equals(root.getFullPath())) {
- GridItem parentItem = new GridItem(table, SWT.NONE);
- parentItem.setText(ExplorerUtil.PARENT_STR);
- parentItem.setData(ExplorerUtil.DATA_FIEL_KEY, current.getParent());
- }
- FileEntry[] children = current.getChildren();
- int selectionIndex = -1;
-
- if (null != children) {
- int size = children.length;
- // dirs
- for (int i = 0; i < size; i++) {
- FileEntry child = children[i];
- if (!child.isDirectory()
- || child.getType() == FileEntryType.DirectoryLink) {
- continue;
- }
-
- GridItem item = new GridItem(table, SWT.NONE);
- item.setText(child.getName());
- item.setData(ExplorerUtil.DATA_FIEL_KEY, child);
- if (null != selectionStr
- && selectionStr.equals(child.getFullPath())) {
- int index = table.indexOf(item);
- // table.getVerticalBar().setSelection(index);
- table.setSelection(index);
- selected = child;
- inputText.setText(child.getFullPath());
- selectionIndex = index;
- }
- }
-
- // files
- for (int i = 0; i < size; i++) {
- FileEntry child = children[i];
- if (child.isDirectory()
- || child.getType() == FileEntryType.Link) {
- continue;
- }
-
- if (null != filter && !child.getName().contains(filter)) {
- continue;
- }
- GridItem item = new GridItem(table, SWT.NONE);
- item.setText(child.getName());
- item.setData(ExplorerUtil.DATA_FIEL_KEY, child);
- if (null != selectionStr
- && selectionStr.equals(child.getFullPath())) {
- int index = table.indexOf(item);
- table.setSelection(index);
- selected = child;
- inputText.setText(child.getFullPath());
- selectionIndex = index;
- }
- }
- table.getVerticalBar().setMaximum(size);
- table.getVerticalBar().setSelection(selectionIndex);
- }
- table.update();
- }
-
-}
import org.tizen.dynamicanalyzer.resources.ImageResources;
import org.tizen.dynamicanalyzer.swap.platform.BinarySettingData;
import org.tizen.dynamicanalyzer.swap.platform.BinarySettingManager;
-import org.tizen.dynamicanalyzer.swap.platform.ui.FileExplorer.FileExplorerDialog;
+import org.tizen.dynamicanalyzer.ui.common.explorer.FileExplorerDialog;
import org.tizen.dynamicanalyzer.util.CommonUtil;
import org.tizen.dynamicanalyzer.widgets.button.DACustomButton;
import org.tizen.dynamicanalyzer.widgets.button.DACustomButtonClickEventListener;
*
*/
-package org.tizen.dynamicanalyzer.swap.platform.ui.FileExplorer;
+package org.tizen.dynamicanalyzer.ui.common.explorer;
import java.io.File;
import java.util.ArrayList;
import org.eclipse.swt.widgets.Composite;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.resources.ColorResources;
-import org.tizen.dynamicanalyzer.swap.platform.ui.ExplorerUtil;
import org.tizen.dynamicanalyzer.ui.widgets.DAGrid;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableHeaderRenderer;
import org.tizen.dynamicanalyzer.util.Logger;
*
*/
-package org.tizen.dynamicanalyzer.swap.platform.ui.FileExplorer;
+package org.tizen.dynamicanalyzer.ui.common.explorer;
import org.eclipse.nebula.widgets.grid.Grid;
import org.eclipse.swt.SWT;
* - S-Core Co., Ltd
*
*/
-package org.tizen.dynamicanalyzer.swap.platform.ui.FileExplorer;
+package org.tizen.dynamicanalyzer.ui.common.explorer;
import java.io.File;
import org.tizen.dynamicanalyzer.resources.ColorResources;
import org.tizen.dynamicanalyzer.resources.FontResources;
import org.tizen.dynamicanalyzer.resources.ImageResources;
-import org.tizen.dynamicanalyzer.swap.platform.ui.ExplorerUtil;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableCellRenderer;
import org.tizen.sdblib.service.FileEntry;
* - S-Core Co., Ltd
*
*/
-package org.tizen.dynamicanalyzer.swap.platform.ui;
+package org.tizen.dynamicanalyzer.ui.common.explorer;
import java.util.HashMap;
*
*/
-package org.tizen.dynamicanalyzer.swap.platform.ui;
+package org.tizen.dynamicanalyzer.ui.common.explorer;
import org.eclipse.nebula.widgets.grid.GridItem;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableCellRenderer;
* - S-Core Co., Ltd
*
*/
-package org.tizen.dynamicanalyzer.swap.platform.ui;
+package org.tizen.dynamicanalyzer.ui.common.explorer;
import org.eclipse.nebula.widgets.grid.GridItem;
import org.eclipse.swt.graphics.Font;
*
*/
-package org.tizen.dynamicanalyzer.swap.platform.ui.DeviceExplorer;
+package org.tizen.dynamicanalyzer.ui.common.explorer;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.swt.widgets.Composite;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.resources.ColorResources;
-import org.tizen.dynamicanalyzer.swap.platform.ui.ExplorerUtil;
-import org.tizen.dynamicanalyzer.swap.platform.ui.FileExplorer.DAFileExplorerEmptyCellRenderer;
-import org.tizen.dynamicanalyzer.swap.platform.ui.FileExplorer.DAFileExplorerTableRenderer;
import org.tizen.dynamicanalyzer.ui.widgets.DAGrid;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableHeaderRenderer;
import org.tizen.dynamicanalyzer.util.Logger;
protected static int FILE = 1;
protected static int DIRECTORY = 2;
+ private static int PERMISSION_STR_LENGTH = 10;
+ private static int PERMISSION_FILTER_LENGTH = 3;
+
protected Grid table = null;
protected DAText inputText = null;
protected DACustomButton goButton = null;
protected IDevice device = null;
protected FileEntry root = null;
- protected FileEntry current = null;
+ protected FileEntry currentDir = null;
protected FileEntry selected = null;
- protected String filter = null;
+ protected String nameFilter = null;
+ protected String permissionFilterStr = null;
+ private int permissionFilter = 0; // all permission is allowed
protected String selectionStr = null;
public void widgetSelected(SelectionEvent e) {
GridItem[] selections = table.getSelection();
GridItem selection = selections[0];
- FileEntry file = (FileEntry) selection
- .getData(ExplorerUtil.DATA_FIEL_KEY);
+ FileEntry file = (FileEntry) selection.getData(ExplorerUtil.DATA_FIEL_KEY);
+
Logger.debug("Selected : " + file.getFullPath());
selected = file;
- inputText.setText(selected.getFullPath());
- inputText.setBackground(ColorResources.WHITE);
- int length = inputText.getText().length();
- inputText.getControl().setSelection(length, length);
+ // inputText.setText(selected.getFullPath());
+ inputText.setBackground(ColorResources.WHITE);
+ inputText.getControl().setSelection(inputText.getText().length());
}
@Override
@Override
public void mouseUp(MouseEvent e) {
- // TODO Auto-generated method stub
}
@Override
public void mouseDown(MouseEvent e) {
- // TODO Auto-generated method stub
}
@Override
public void mouseDoubleClick(MouseEvent e) {
if (selected.isDirectory() || selected.isRoot()) {
- current = selected;
+ currentDir = selected;
updateData();
}
}
@Override
public void keyReleased(KeyEvent e) {
- if (e.keyCode == 13) {
+ if (e.keyCode == 13) { // press enter
adjustInput();
- inputText.getControl().setSelection(
- inputText.getText().length());
+ inputText.getControl().setSelection(inputText.getText().length());
} else {
}
@Override
public void focusLost(FocusEvent e) {
- // TODO Auto-generated method stub
}
@Override
public void focusGained(FocusEvent e) {
+ // remove selection
GridItem[] selections = new GridItem[0];
table.setSelection(selections);
}
};
- public DeviceExplorer(Composite parent) {
+ public DeviceExplorer(Composite parent, boolean multiSelection) {
super(parent, SWT.NONE);
this.setLayout(new FormLayout());
this.setBackground(ColorResources.DIALOG_BG_UPPER);
goButton.setText("Go");
goButton.addClickListener(goButtonClickListener);
- table = new DAGrid(this, SWT.MULTI | SWT.BORDER | SWT.V_SCROLL);
+ int style = SWT.BORDER | SWT.V_SCROLL;
+ if (multiSelection) {
+ style |= SWT.MULTI;
+ } else {
+ style |= SWT.SINGLE;
+ }
+
+ table = new DAGrid(this, style);
table.setBackground(ColorResources.TABLE_CONTENTS_NORMAL);
table.setForeground(ColorResources.TABLE_CONTENTS_FONT_COLOR);
setColumns();
table.setEmptyCellRenderer(new DAFileExplorerEmptyCellRenderer());
- table.setItemHeight(46);
+ table.setItemHeight(32);
data = new FormData();
data.top = new FormAttachment(inputText.getControl(), 7);
table.addMouseListener(tableMouseListener);
}
- public void setColumns() {
+ private void setColumns() {
GridColumn fileColumn = new GridColumn(table, SWT.NONE);
- fileColumn.setCellRenderer(new DAFileExplorerTableRenderer());
+ fileColumn.setCellRenderer(new DeviceExplorerTableRenderer());
fileColumn.setHeaderRenderer(new DATableHeaderRenderer());
fileColumn.setText("File");
fileColumn.setWidth(450);
}
public void updateData() {
- if (null == current) {
+ if (null == currentDir) {
if (null == root) {
Logger.debug("Root is empty");
return;
}
- current = root;
+ currentDir = root;
}
table.removeAll();
- inputText.setText(current.getFullPath());
+ inputText.setText(currentDir.getFullPath());
- if (!current.getFullPath().equals(root.getFullPath())) {
+ if (!currentDir.getFullPath().equals(root.getFullPath())) {
GridItem parentItem = new GridItem(table, SWT.NONE);
parentItem.setText(ExplorerUtil.PARENT_STR);
- parentItem.setData(ExplorerUtil.DATA_FIEL_KEY, current.getParent());
+ parentItem.setData(ExplorerUtil.DATA_FIEL_KEY, currentDir.getParent());
}
- FileEntry[] children = current.getChildren();
+ FileEntry[] children = currentDir.getChildren();
int selectionIndex = -1;
if (null != children) {
// dirs
for (int i = 0; i < size; i++) {
FileEntry child = children[i];
- if (!child.isDirectory()) {
+ if (!child.isDirectory() || child.getType() == FileEntryType.DirectoryLink) {
continue;
}
GridItem item = new GridItem(table, SWT.NONE);
item.setText(child.getName());
item.setData(ExplorerUtil.DATA_FIEL_KEY, child);
- if (null != selectionStr
- && selectionStr.equals(child.getFullPath())) {
+ if (null != selectionStr && selectionStr.equals(child.getFullPath())) {
int index = table.indexOf(item);
- // table.getVerticalBar().setSelection(index);
table.setSelection(index);
selected = child;
inputText.setText(child.getFullPath());
// files
for (int i = 0; i < size; i++) {
FileEntry child = children[i];
- if (child.isDirectory()) {
+ if (child.isDirectory() || child.getType() == FileEntryType.Link) {
continue;
}
- if (null != filter && !child.getName().contains(filter)) {
+ if (null != nameFilter && !child.getName().contains(nameFilter)) {
continue;
}
+
+ if (permissionFilter != 0) {
+ int permission = getPermission(child.getPermissions());
+ if((permission & permissionFilter) != permissionFilter) {
+ continue;
+ }
+ }
+
GridItem item = new GridItem(table, SWT.NONE);
item.setText(child.getName());
item.setData(ExplorerUtil.DATA_FIEL_KEY, child);
- if (null != selectionStr
- && selectionStr.equals(child.getFullPath())) {
+ if (null != selectionStr && selectionStr.equals(child.getFullPath())) {
int index = table.indexOf(item);
- // table.getVerticalBar().setSelection(index);
table.setSelection(index);
selected = child;
inputText.setText(child.getFullPath());
public void setRoot(String r) {
if (null != device && null != r && !r.isEmpty()) {
FileEntry rootDir = device.getFileEntry(r);
- if (null == rootDir
- || (!rootDir.isDirectory() && !rootDir.isRoot())) {
+ if (null == rootDir || (!rootDir.isDirectory() && !rootDir.isRoot())) {
Logger.debug("root path is invalid");
return;
} else {
}
}
- public Grid getTable() {
- return table;
+ public void addTableMouseListener(MouseListener listener) {
+ table.addMouseListener(listener);
}
public List<FileEntry> getSelection() {
continue;
}
- FileEntry entry = (FileEntry) selection
- .getData(ExplorerUtil.DATA_FIEL_KEY);
+ FileEntry entry = (FileEntry) selection.getData(ExplorerUtil.DATA_FIEL_KEY);
fileEntries.add(entry);
}
- } else if (null != inputText.getText()
- && !inputText.getText().isEmpty()) {
+ } else if (null != inputText.getText() && !inputText.getText().isEmpty()) {
String path = inputText.getText();
FileEntry file = device.getFileEntry(path);
if (null != file) {
Logger.debug("invalid path");
return result;
} else if (!file.isDirectory() && !file.isRoot()) {
- current = file.getParent();
+ currentDir = file.getParent();
selectionStr = file.getFullPath();
result = FILE;
} else {
- current = file;
+ currentDir = file;
selectionStr = CommonConstants.EMPTY;
result = DIRECTORY;
}
updateData();
- return result;
}
return result;
}
private void adjustInput() {
+ String errorstr = null;
+
String path = inputText.getText();
- if (null == path || path.isEmpty()) {
- Logger.debug("path must not empty");
- // inputText.setBackground(ColorResources.RED);
- // info.setText("Empty path");
- inputText.setText(current.getFullPath());
- return;
+ if (null != path && !path.isEmpty()) {
+ if (path.contains(root.getFullPath())) {
+ if (setCurrent(path) != FAIL) {
+ inputText.setBackground(ColorResources.WHITE);
+ } else {
+ errorstr = "Failed to set current directory";
+ }
+ } else {
+ errorstr = "Out of root range";
+ }
+ } else {
+ errorstr = "path must not empty";
}
- if (!path.contains(root.getFullPath())) {
- Logger.debug("Out of root range");
+ if (errorstr != null) {
+ Logger.debug(errorstr);
// inputText.setBackground(ColorResources.RED);
- // info.setText("Out of root range");
- inputText.setText(current.getFullPath());
- return;
+ // info.setText(errorstr);
+ inputText.setText(currentDir.getFullPath());
}
-
- int ret = setCurrent(path);
- if (ret != FAIL) {
- inputText.setBackground(ColorResources.WHITE);
- } else {
- // inputText.setBackground(ColorResources.RED);
- // info.setText("Invalid path");
- inputText.setText(current.getFullPath());
+ }
+
+ private int getPermission(String permissionStr) {
+ int permission = 0;
+ if(permissionStr != null && permissionStr.length() == PERMISSION_STR_LENGTH) {
+ for (int i = 1; i < permissionStr.length(); i++) {
+ permission = permission << 1;
+ switch (permissionStr.charAt(i)) {
+ case 'r':
+ case 'w':
+ case 'x':
+ permission = permission | 1;
+ break;
+ default:
+ // other letter is possible for permission string
+ // but it is not necessary to parsing
+ break;
+ }
+ }
}
+
+ return permission;
+ }
+
+ /**
+ * set filename filter to filter file entry by file name
+ *
+ * @param filter
+ * file name filter string
+ */
+ public void setNameFilter(String filter) {
+ this.nameFilter = filter;
}
- public void setFilterString(String filter) {
- this.filter = filter;
+ /**
+ * set permission filter to filter file entry by permission
+ *
+ * @param filter
+ * permission filter string (ex. 755)
+ */
+ public void setPermissionFilter(String filter) {
+ if (filter == null || filter.length() == PERMISSION_FILTER_LENGTH) {
+ this.permissionFilterStr = filter;
+
+ if (filter != null) {
+ int userclass = filter.charAt(0) - '0';
+ int groupclass = filter.charAt(1) - '0';
+ int otherclass = filter.charAt(2) - '0';
+ permissionFilter = userclass << 6 | groupclass << 3 | otherclass;
+ } else {
+ permissionFilter = 0;
+ }
+ }
}
}
*
*/
-package org.tizen.dynamicanalyzer.swap.platform.ui.DeviceExplorer;
+package org.tizen.dynamicanalyzer.ui.common.explorer;
import java.util.ArrayList;
import java.util.List;
import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.nl.WidgetLabels;
import org.tizen.dynamicanalyzer.resources.ColorResources;
-import org.tizen.dynamicanalyzer.swap.platform.ui.ExplorerUtil;
import org.tizen.dynamicanalyzer.widgets.button.DACustomButton;
import org.tizen.dynamicanalyzer.widgets.button.DACustomButtonClickEventListener;
import org.tizen.dynamicanalyzer.widgets.da.base.DAButton;
import org.tizen.dynamicanalyzer.widgets.da.base.DAMessageBox;
import org.tizen.sdblib.service.FileEntry;
-public class DeviceExplorerDilaog extends DAMessageBox {
+public class DeviceExplorerDialog extends DAMessageBox {
private DeviceExplorer explorer = null;
private DACustomButton okButton = null;
private DACustomButton cancelButton = null;
- public DeviceExplorerDilaog(Shell parentShell) {
+ public DeviceExplorerDialog(Shell parentShell, boolean multiSelection) {
super(parentShell);
shell.setLayout(new FormLayout());
shell.setSize(446, 600);
shell.setBackground(ColorResources.DIALOG_BG_UPPER);
shell.setText("Select binary");
- explorer = new DADeviceExplorer(shell);
+ explorer = new DeviceExplorer(shell, multiSelection);
FormData data = new FormData();
data.top = new FormAttachment(0, 17);
data.left = new FormAttachment(0, 6);
}
});
- explorer.getTable().addMouseListener(new MouseListener() {
+ explorer.addTableMouseListener(new MouseListener() {
@Override
public void mouseUp(MouseEvent e) {
return explorer;
}
- public void setFilter(String filter) {
- explorer.setFilterString(filter);
+ public void setNameFilter(String filter) {
+ explorer.setNameFilter(filter);
+ }
+
+ public void setPermissionFilter(String filter) {
+ explorer.setPermissionFilter(filter);
}
}
--- /dev/null
+package org.tizen.dynamicanalyzer.ui.common.explorer;
+
+import java.io.File;
+
+import org.eclipse.nebula.widgets.grid.GridItem;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.graphics.Color;
+import org.eclipse.swt.graphics.GC;
+import org.eclipse.swt.graphics.Image;
+import org.eclipse.swt.graphics.Rectangle;
+import org.tizen.dynamicanalyzer.resources.ColorResources;
+import org.tizen.dynamicanalyzer.resources.FontResources;
+import org.tizen.dynamicanalyzer.resources.ImageResources;
+import org.tizen.dynamicanalyzer.ui.widgets.table.DATableCellRenderer;
+import org.tizen.sdblib.service.FileEntry;
+
+public class DeviceExplorerTableRenderer extends DATableCellRenderer {
+ @Override
+ public void paint(GC gc, Object value) {
+ textTopMargin = 8;
+
+ GridItem item = (GridItem) value;
+
+ gc.setFont(item.getFont(getColumn()));
+
+ boolean drawAsSelected = isSelected();
+
+ boolean drawBackground = true;
+
+ if (isCellSelected()) {
+ drawAsSelected = true;// (!isCellFocus());
+ }
+
+ if (drawAsSelected) {
+ gc.setForeground(ColorResources.EXPLORER_SELECT_START);
+ gc.setBackground(ColorResources.EXPLORER_SELECT_END);
+ } else {
+ if (item.getParent().isEnabled()) {
+ gc.setBackground(ColorResources.EXPLORER_CELL_BG);
+ } else {
+ gc.setBackground(getDisplay().getSystemColor(
+ SWT.COLOR_WIDGET_BACKGROUND));
+ }
+ }
+
+ if (drawBackground && drawAsSelected) {
+ gc.fillGradientRectangle(getBounds().x, getBounds().y,
+ getBounds().width, getBounds().height, true);
+ } else if (drawBackground) {
+ gc.fillRectangle(getBounds().x, getBounds().y + 1,
+ getBounds().width, getBounds().height);
+ }
+
+ int x = leftMargin;
+
+ if (isCheck()) {
+ checkRenderer.setChecked(item.getChecked(getColumn()));
+ checkRenderer.setGrayed(item.getGrayed(getColumn()));
+ if (!item.getParent().isEnabled()) {
+ checkRenderer.setGrayed(true);
+ }
+ checkRenderer.setHover(getHoverDetail().equals("check")); //$NON-NLS-1$
+
+ checkRenderer.setBounds(getBounds().x + x,
+ (getBounds().height - checkRenderer.getBounds().height) / 2
+ + getBounds().y, checkRenderer.getBounds().width,
+ checkRenderer.getBounds().height);
+ checkRenderer.paint(gc, null);
+
+ x += checkRenderer.getBounds().width + insideMargin;
+ }
+
+ int width = getBounds().width - x - rightMargin;
+
+ String text = item.getText(getColumn());
+
+ if (getAlignment() == SWT.RIGHT) {
+ int len = gc.stringExtent(text).x;
+ if (len < width) {
+ x += width - len;
+ }
+ } else if (getAlignment() == SWT.CENTER) {
+ int len = gc.stringExtent(text).x;
+ if (len < width) {
+ x += (width - len) / 2;
+ }
+ }
+
+ if (drawAsSelected) {
+ gc.setForeground(ColorResources.BLACK);
+ } else {
+ Color fontColor = item.getForeground();
+ if (null != fontColor) {
+ gc.setForeground(item.getForeground());
+ } else {
+ gc.setForeground(ColorResources.BLACK);
+ }
+ }
+
+ Image image = null;
+ Object object = item.getData(ExplorerUtil.DATA_FIEL_KEY);
+ if (object instanceof File) {
+ File file = (File) object;
+ if (file.isDirectory()) {
+ image = ImageResources.FILE_TYPE_DIR;
+ } else if (file.isFile()) {
+ image = ImageResources.FILE_TYPE_FILE;
+ } else {
+ image = ImageResources.FILE_TYPE_ETC;
+ }
+ } else if (object instanceof FileEntry) {
+ FileEntry entry = (FileEntry) object;
+ switch (entry.getType()) {
+ case File:
+ image = ImageResources.FILE_TYPE_FILE;
+ break;
+ case Link:
+ image = ImageResources.FILE_TYPE_FILE_LINK;
+ break;
+ case Directory:
+ image = ImageResources.FILE_TYPE_DIR;
+ break;
+ case DirectoryLink:
+ image = ImageResources.FILE_TYPE_DIR_LINK;
+ break;
+ case RootEmulator:
+ image = ImageResources.FILE_TYPE_EMULATOR;
+ break;
+ case RootDevice:
+ image = ImageResources.FILE_TYPE_DEVICE;
+ break;
+ default:
+ image = ImageResources.FILE_TYPE_ETC;
+ break;
+ }
+ }
+
+ int imageTopMargin = 0;
+ int imageLeftMargin = 16;
+ int textLeftMargin = 66;
+ Rectangle rect = getBounds();
+ gc.drawImage(image, rect.x + imageLeftMargin, rect.y + imageTopMargin);
+ gc.setFont(FontResources.getDADefaultFont());
+ gc.drawText(text, rect.x + textLeftMargin, rect.y + textTopMargin, true);
+
+ if (item.getParent().getLinesVisible()) {
+ gc.setForeground(ColorResources.EXPLORER_CELL_LINE);
+ gc.drawLine(rect.x, rect.y + rect.height,
+ rect.x + rect.width - 1, rect.y
+ + rect.height);
+ // gc.drawLine(getBounds().x + getBounds().width - 1, getBounds().y,
+ // getBounds().x + getBounds().width - 1, getBounds().y
+ // + getBounds().height);
+ }
+
+ if (isCellFocus()) {
+ Rectangle focusRect = new Rectangle(getBounds().x - 1,
+ getBounds().y - 1, getBounds().width,
+ getBounds().height + 1);
+
+ gc.setForeground(ColorResources.RED);
+ gc.drawRectangle(focusRect);
+
+ if (isFocus()) {
+ focusRect.x++;
+ focusRect.width -= 2;
+ focusRect.y++;
+ focusRect.height -= 2;
+
+ gc.drawRectangle(focusRect);
+ }
+ }
+ }
+}
*
*/
-package org.tizen.dynamicanalyzer.swap.platform.ui;
+package org.tizen.dynamicanalyzer.ui.common.explorer;
import java.io.File;
* - S-Core Co., Ltd
*
*/
-package org.tizen.dynamicanalyzer.swap.platform.ui.FileExplorer;
+package org.tizen.dynamicanalyzer.ui.common.explorer;
import java.io.File;
import java.util.ArrayList;
import org.tizen.dynamicanalyzer.appearance.DesignConstants;
import org.tizen.dynamicanalyzer.nl.WidgetLabels;
import org.tizen.dynamicanalyzer.resources.ColorResources;
-import org.tizen.dynamicanalyzer.swap.platform.ui.ExplorerUtil;
import org.tizen.dynamicanalyzer.widgets.button.DACustomButton;
import org.tizen.dynamicanalyzer.widgets.button.DACustomButtonClickEventListener;
import org.tizen.dynamicanalyzer.widgets.da.base.DAButton;
* - S-Core Co., Ltd
*
*/
-package org.tizen.dynamicanalyzer.swap.platform.ui;
+package org.tizen.dynamicanalyzer.ui.common.explorer;
import org.eclipse.nebula.widgets.grid.Grid;
import org.eclipse.nebula.widgets.grid.GridItem;
import org.tizen.dynamicanalyzer.widgets.da.base.DAMessageBox;
import org.tizen.sdblib.service.FileEntry;
-public class FileExplorerDialog extends DAMessageBox {
+public class FileTreeExplorerDialog extends DAMessageBox {
private DAFileTreeExplorer explorerTree = null;
private DACustomButton okButton = null;
private DACustomButton cancelButton = null;
- public FileExplorerDialog(Shell parentShell) {
+ public FileTreeExplorerDialog(Shell parentShell) {
super(parentShell);
shell.setLayout(new FormLayout());
shell.setSize(500, 600);
package org.tizen.dynamicanalyzer.ui.file;
+import java.sql.ResultSet;
+import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import org.tizen.dynamicanalyzer.common.DASelectionData;
import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
+import org.tizen.dynamicanalyzer.database.SqlConnectionManager;
import org.tizen.dynamicanalyzer.error.ErrorCodeManager;
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
import org.tizen.dynamicanalyzer.model.TableInput;
import org.tizen.dynamicanalyzer.swap.model.data.FileData;
import org.tizen.dynamicanalyzer.ui.file.manager.FileDataManager;
+import org.tizen.dynamicanalyzer.ui.file.model.FileAccessor;
import org.tizen.dynamicanalyzer.ui.file.model.FileEvent;
+import org.tizen.dynamicanalyzer.ui.file.model.FileSelectedData;
import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants;
import org.tizen.dynamicanalyzer.ui.widgets.table.DAApiListTableComposite;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableDataFormat;
public class FileApiListTable extends DAApiListTableComposite {
+ private FileDataManager fileDataManager = FileDataManager.getInstance();
+
public FileApiListTable(Composite parent, int compStyle, int tableStyle) {
super(parent, compStyle, tableStyle);
table.addSelectionListener(new SelectionListener() {
long rangeEndTime = view.getRangeEndTime();
HashMap<String, Integer> findStartAPITableIndexHashMap = new HashMap<String, Integer>();
+ HashMap<Integer, Long> findStartTimeHashMap = new HashMap<Integer, Long>();
List<Integer> removeTableIndex = new ArrayList<Integer>();
List<TableInput> input = new ArrayList<TableInput>();
- List<FileEvent> contents = FileDataManager.getInstance().getSelectedTableAPIList();
- if(contents == null) {
- return null;
- }
- for (int i = 0; i < contents.size(); i++) {
- FileEvent contentTemp = contents.get(i);
- List<String> contentText = new ArrayList<String>();
- List<String> contentData = new ArrayList<String>();
-
- Integer startLogIndex = 0;
- int fdApiType = contentTemp.getFdApiType();
+ FileSelectedData selectedData = fileDataManager.getSelectedData();
+ ResultSet rs = fileDataManager.getApiDB().selectAPI(
+ selectedData.getFileId(),
+ selectedData.getAccessorId(),
+ selectedData.isParentChart());
+ FileAccessor accessor = selectedData.getFileAccessor();
+ boolean isParentChart = selectedData.isParentChart();
+ String filePath = null;
+ int pid = -1;
+ int tid = -1;
+ if (rs != null) {
+ try {
+ int i = -1;
+ int index = 0;
+ while (rs.next()) {
+ i++;
+ index++;
+
+ List<String> contentText = new ArrayList<String>();
+ List<String> contentData = new ArrayList<String>();
+ Integer startLogIndex = 0;
- long seq = contentTemp.getSeq();
- contentText.add(0, Long.toString(seq));
- contentData.add(Long.toString(seq));
- long time = contentTemp.getTime();
+ long seq = rs.getLong(1);
+ long fd = rs.getLong(2);
+ int fdApiType = rs.getInt(3);
+ long time = rs.getLong(4);
+ int apiId = rs.getInt(5);
+ long errno = rs.getLong(6);
+ long fileSize = rs.getLong(7);
+ long ioSize = rs.getLong(8);
+ String returns = rs.getString(9);
+ String args = rs.getString(10);
+
+ if(isParentChart){
+ filePath = rs.getString(11);
+ pid = rs.getInt(12);
+ tid = rs.getInt(13);
+ }else{
+ filePath = accessor.getFilePath();
+ pid = accessor.getPid();
+ tid = accessor.getTid();
+ }
+
+ FileEvent fileEvent = new FileEvent(seq, filePath, pid,
+ tid, fd, fdApiType, apiId, time, fileSize, ioSize,
+ args, returns, errno);
+
+ String apiName = Global.getFunctionName(apiId);
+ long startTime = 0;
+
+ boolean isExistStartTimeLog = false;
+ if (fdApiType == LogCenterConstants.FD_API_TYPE_READ_START
+ || fdApiType == LogCenterConstants.FD_API_TYPE_WRITE_START
+ || fdApiType == LogCenterConstants.FD_API_TYPE_LOCK_START) {
+ String keString = apiName + pid + tid + fd;
+ findStartAPITableIndexHashMap.put(keString, i);
+ findStartTimeHashMap.put(i, time);
+ index--;
+ } else if (fdApiType == LogCenterConstants.FD_API_TYPE_READ_END
+ || fdApiType == LogCenterConstants.FD_API_TYPE_WRITE_END
+ || fdApiType == LogCenterConstants.FD_API_TYPE_LOCK_END) {
+ String keString = apiName + pid + tid + fd;
+ startLogIndex = findStartAPITableIndexHashMap.get(keString);
+ findStartAPITableIndexHashMap.remove(keString);
+ if (null != startLogIndex) {
+ contentText.add(input.get(startLogIndex.intValue())
+ .getText().get(1)); // start time
+ contentData.add(input.get(startLogIndex.intValue())
+ .getText().get(1));
- boolean isExistStartTimeLog = false;
- if (fdApiType == LogCenterConstants.FD_API_TYPE_READ_START
- || fdApiType == LogCenterConstants.FD_API_TYPE_WRITE_START
- || fdApiType == LogCenterConstants.FD_API_TYPE_LOCK_START) {
- String keString = contentTemp.getApiName()
- + contentTemp.getPid() + contentTemp.getTid() + contentTemp.getFdValue();
- findStartAPITableIndexHashMap.put(keString, i);
+ startTime = findStartTimeHashMap.get(startLogIndex);
+ String timeFormat = Formatter
+ .toTimeFormat(time - startTime);
+ String removeTimeFormat = timeFormat.replace(
+ "00:", CommonConstants.EMPTY);//$NON-NLS-1$
- } else if (fdApiType == LogCenterConstants.FD_API_TYPE_READ_END
- || fdApiType == LogCenterConstants.FD_API_TYPE_WRITE_END
- || fdApiType == LogCenterConstants.FD_API_TYPE_LOCK_END) {
- String keString = contentTemp.getApiName()
- + contentTemp.getPid() + contentTemp.getTid() + contentTemp.getFdValue();
- startLogIndex = findStartAPITableIndexHashMap.get(keString);
- findStartAPITableIndexHashMap.remove(keString);
- if (null != startLogIndex) {
- contentText.add(input.get(startLogIndex.intValue())
- .getText().get(1)); // start time
- contentData.add(input.get(startLogIndex.intValue())
- .getText().get(1));
+ contentText.add(removeTimeFormat); // elapsed time
+ contentData.add(Long.toString(time - startTime));
+
+ isExistStartTimeLog = true;
+ removeTableIndex.add(startLogIndex.intValue());
+ } else {
+ contentText.add(Formatter.toTimeFormat(time)); // start//
+ contentData.add(Long.toString(time));
+ contentText.add("00.000");//$NON-NLS-1$
+ contentData.add("00.000");//$NON-NLS-1$
+ }
+ }
- long startTime = contents.get(startLogIndex.intValue()).getTime();
- String timeFormat = Formatter
- .toTimeFormat(time - startTime);
- String removeTimeFormat = timeFormat.replace(
- "00:", CommonConstants.EMPTY);//$NON-NLS-1$
+ if (!isExistStartTimeLog) {
+ contentText.add(Formatter.toTimeFormat(time)); // start time
+ contentData.add(Long.toString(time));
+ contentText.add("00.000");//$NON-NLS-1$ //elapsed time
+ contentData.add("00.000");//$NON-NLS-1$
+ }
- contentText.add(removeTimeFormat); // elapsed time
- contentData.add(Long.toString(time - startTime));
+ contentText.add(0, Integer.toString(index));
+ contentData.add(0, Integer.toString(index));
- isExistStartTimeLog = true;
- removeTableIndex.add(startLogIndex.intValue());
- } else {
- contentText.add(Formatter.toTimeFormat(contentTemp
- .getTime())); // start//
- contentData.add(Long.toString(contentTemp.getTime()));
- contentText.add("00.000");//$NON-NLS-1$
- contentData.add("00.000");//$NON-NLS-1$
- }
- }
-
- if (!isExistStartTimeLog) {
- contentText.add(Formatter.toTimeFormat(time)); // start time
- contentData.add(Long.toString(time));
- contentText.add("00.000");//$NON-NLS-1$ //elapsed time
- contentData.add("00.000");//$NON-NLS-1$
- }
-
- contentText.add(Integer.toString(contentTemp.getPid()));
- contentData.add(Integer.toString(contentTemp.getPid()));
+ contentText.add(Integer.toString(pid));
+ contentData.add(Integer.toString(pid));
- contentText.add(Integer.toString(contentTemp.getTid()));
- contentData.add(Integer.toString(contentTemp.getTid()));
-
- contentText.add(Long.toString(contentTemp.getFdValue()));
- contentData.add(Long.toString(contentTemp.getFdValue()));
-
- contentText.add(Global.getFunctionName(contentTemp.getApiId()));
- contentData.add(Global.getFunctionName(contentTemp.getApiId()));
+ contentText.add(Integer.toString(tid));
+ contentData.add(Integer.toString(tid));
+
+ contentText.add(Long.toString(fd));
+ contentData.add(Long.toString(fd));
- contentText.add(contentTemp.getArgs());
- contentData.add(contentTemp.getArgs());
+ contentText.add(apiName);
+ contentData.add(apiName);
- contentText.add(contentTemp.getReturn());
- contentData.add(contentTemp.getReturn());
+ contentText.add(args);
+ contentData.add(args);
+
+ contentText.add(returns);
+ contentData.add(returns);
+
+ contentText.add(Long.toString(seq));
+ contentData.add(Long.toString(seq));
- String errMsg = ErrorCodeManager.getInatance()
- .getErrorCode(contentTemp.getErrno()).name();
- if (null == errMsg) {
- errMsg = "undefined error code"; //$NON-NLS-1$
- }
- contentText.add(errMsg);
- contentData.add(errMsg);
- contentText.add(Long.toString(contentTemp.getFileSize()));
- contentData.add(Long.toString(contentTemp.getFileSize()));
+ String errMsg = ErrorCodeManager.getInatance()
+ .getErrorCode(errno).name();
+ if (null == errMsg) {
+ errMsg = "undefined error code"; //$NON-NLS-1$
+ }
- DATableDataFormat tableData = new DATableDataFormat(
- contentTemp.getSeq());
- tableData.setLogData(contentTemp);
- tableData.getData().addAll(contentData);
- TableInput tableInput = new TableInput();
- tableInput.setText(contentText);
- tableInput.setData(tableData);
- if (!errMsg.contains("SUCCESS")) {//$NON-NLS-1$
- tableInput.setFailed(true);
- }
- input.add(tableInput);
+ // create DATableDataFormat
+ DATableDataFormat tableData = new DATableDataFormat(seq);
+ tableData.setLogData(fileEvent);
+ tableData.getData().addAll(contentData);
+ TableInput tableInput = new TableInput();
+ tableInput.setText(contentText);
+ tableInput.setData(tableData);
+ if (!errMsg.contains("SUCCESS")) {//$NON-NLS-1$
+ tableInput.setFailed(true);
+ }
+ input.add(tableInput);
- if (time >= rangeStartTime && time <= rangeEndTime) {
- tableInput.setInRange(true);
+ if (time >= rangeStartTime && time <= rangeEndTime) {
+ tableInput.setInRange(true);
+ }
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ } finally {
+ SqlConnectionManager.releaseResultSet(rs);
}
}
+
int removeCount = 0;
for (int index : removeTableIndex) {
int removeIndex = index - removeCount;
package org.tizen.dynamicanalyzer.ui.file;
-import java.util.List;
-
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Composite;
import org.tizen.dynamicanalyzer.nl.FilePageLabels;
import org.tizen.dynamicanalyzer.resources.ColorResources;
import org.tizen.dynamicanalyzer.ui.file.manager.FileDataManager;
-import org.tizen.dynamicanalyzer.ui.file.model.FileEvent;
import org.tizen.dynamicanalyzer.ui.file.model.FileSelectedData;
import org.tizen.dynamicanalyzer.ui.range.RangeDataManager;
import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
}
// if new event is put from swap, update table
- List<FileEvent> events = manager.getApiDB().selectAPITable(
- selectedData.getFilePath(), selectedData.getPid(),
- selectedData.getTid(),
- selectedData.isParentChart());
- if(events != null) {
- if (tableComp.getTable().getItemCount() > 0
- && events.size() != tableComp.getTable().getItemCount()) {
- manager.setSelectedTableAPIList(events);
- isUpdate = true;
- }
- }
+ /*int newTotal = manager.getApiDB().getTotal();
+ if(tableComp.getTable().getItemCount() > 0 && newTotal > currentTotal) {
+ manager.setSelectedData(selectedData);
+ isUpdate = true;
+ }*/
return isUpdate;
}
if (null == selectedData) {
return;
}
- manager.setSelectedTableAPIList(
- manager.getApiDB().
- selectAPITable(selectedData.getFilePath(),
- selectedData.getPid(),
- selectedData.getTid(),
- selectedData.isParentChart()));
+
+ manager.setSelectedData(selectedData);
tableComp.updateTable();
tableComp.setSelectionByTime(selectionStartTime,
import java.util.ArrayList;
import java.util.List;
-import org.eclipse.swt.graphics.Color;
-import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
import org.tizen.dynamicanalyzer.nl.FilePageLabels;
import org.tizen.dynamicanalyzer.resources.ColorResources;
import org.tizen.dynamicanalyzer.ui.file.model.FileAccess;
-import org.tizen.dynamicanalyzer.ui.file.model.FileEvent;
+import org.tizen.dynamicanalyzer.ui.file.model.FileAccessor;
import org.tizen.dynamicanalyzer.ui.file.model.FileStatus;
import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants;
import org.tizen.dynamicanalyzer.utils.Formatter;
private DAChartSeries accessSeries;
private String filePath = null;
- private int pid = -1;
- private int tid = -1;
- private long fd = -1;
- private long fileSize = 0;
- //private int parentChartIndex = -1;
+ private int fileId = -1;
+
+ private FileAccessor fileAccessor = null;
private int chartIndex = -1;
private boolean isTarget = false;
- public FileChart(String filePath) {
- this.filePath = filePath;
- }
-
- public FileChart(String filePath, int pid, int tid, long fd) {
+ public FileChart(String filePath, int fileId) {
this.filePath = filePath;
- this.pid = pid;
- this.tid = tid;
- this.fd = fd;
+ this.fileId = fileId;
}
- public FileChart(int pid, int tid, long fd, String filePath, long fileSize,
- boolean isTarget, int chartIndex) {
- this.filePath = filePath;
- this.pid = pid;
- this.tid = tid;
- this.fd = fd;
- this.fileSize = fileSize;
- this.isTarget = isTarget;
+ public FileChart(FileAccessor fileAccessor, int chartIndex, boolean isTarget) {
+ this.fileAccessor = fileAccessor;
this.chartIndex = chartIndex;
+ this.isTarget = isTarget;
}
public void setItem(DAChartBoardItem item) {
}
/**
- * Update API series chart
- * @param apiList
- */
- public void updateApiSeries(List<FileEvent> apiList){
- for(int i=0; i < apiList.size(); i++) {
- FileEvent event = apiList.get(i);
- if(!event.getFilePath().equals(this.filePath) ||
- event.getPid() != this.pid ||
- event.getTid() != this.tid) {
- continue;
- }
- double time = event.getTime() / TimelineConstants.MEGA_DOUBLE;
- String apiName = Global.getFunctionName(event.getApiId());
- Color color = ColorResources.FILE_API_FAILED;
-
- DAChartSeriesItem seriesItem = new DAChartSeriesItem(time,
- DAChartSeriesItem.SERIES_AREA_BAR, color, color, apiName);
- accessSeries.addSeriesItem(seriesItem);
- }
- chart.redraw();
- }
-
- /**
* Update access series chart - read/write/lock event
* @param accessList
*/
public void updateAccessSeries(List<FileAccess> accessList) {
for(int i=0; i < accessList.size(); i++) {
FileAccess data = accessList.get(i);
- if(!data.getFilePath().equals(this.filePath) ||
- data.getPid() != this.pid ||
- data.getTid() != this.tid ||
- data.getErroNo() != 0) {
+ if(data.getAccessorId() != this.fileAccessor.getAccessorId()) {
continue;
}
-
double startTime = data.getStartTime() / TimelineConstants.MEGA_DOUBLE;
double endTime = data.getEndTime() / TimelineConstants.MEGA_DOUBLE;
startTime, DAChartSeriesItem.SERIES_AREA_START,
ColorResources.FILE_ACCESS_CONCURRENT_READ,
ColorResources.FILE_ACCESS_CONCURRENT_READ, false,
- FilePageLabels.FILE_CHART_TOOLTIP_CONCURRENT_READ));
+ data.getTooltip()));
if(endTime > 0) {
accessSeries.addSeriesItem(new DAChartSeriesItem(
endTime, DAChartSeriesItem.SERIES_AREA_END,
ColorResources.FILE_ACCESS_CONCURRENT_READ,
ColorResources.FILE_ACCESS_CONCURRENT_READ, false,
- FilePageLabels.FILE_CHART_TOOLTIP_CONCURRENT_READ));
+ data.getTooltip()));
} // else, if endTime <=0, still accessing
}else{
// the file has been read by only one process or thread
startTime, DAChartSeriesItem.SERIES_AREA_START,
ColorResources.FILE_ACCESS_READ,
ColorResources.FILE_ACCESS_READ, false,
- FilePageLabels.FILE_CHART_TOOLTIP_READ));
+ data.getTooltip()));
if(endTime > 0) {
accessSeries.addSeriesItem(new DAChartSeriesItem(
endTime, DAChartSeriesItem.SERIES_AREA_END,
ColorResources.FILE_ACCESS_READ,
ColorResources.FILE_ACCESS_READ, false,
- FilePageLabels.FILE_CHART_TOOLTIP_READ));
+ data.getTooltip()));
} // else, if endTime <=0, still accessing
}
break;
startTime, DAChartSeriesItem.SERIES_AREA_START,
ColorResources.FILE_ACCESS_CONCURRENT_WRITE,
ColorResources.FILE_ACCESS_CONCURRENT_WRITE, false,
- FilePageLabels.FILE_CHART_TOOLTIP_CONCURRENT_WRITE));
+ data.getTooltip()));
if(endTime > 0) {
accessSeries.addSeriesItem(new DAChartSeriesItem(
endTime, DAChartSeriesItem.SERIES_AREA_END,
ColorResources.FILE_ACCESS_CONCURRENT_WRITE,
ColorResources.FILE_ACCESS_CONCURRENT_WRITE, false,
- FilePageLabels.FILE_CHART_TOOLTIP_CONCURRENT_WRITE));
+ data.getTooltip()));
} // else, if endTime <=0, still accessing
}else{
// the file has been written by only one process or thread
startTime, DAChartSeriesItem.SERIES_AREA_START,
ColorResources.FILE_ACCESS_WRITE,
ColorResources.FILE_ACCESS_WRITE, false,
- FilePageLabels.FILE_CHART_TOOLTIP_WRITE));
+ data.getTooltip()));
if(endTime > 0) {
accessSeries.addSeriesItem(new DAChartSeriesItem(
endTime, DAChartSeriesItem.SERIES_AREA_END,
ColorResources.FILE_ACCESS_WRITE,
ColorResources.FILE_ACCESS_WRITE, false,
- FilePageLabels.FILE_CHART_TOOLTIP_WRITE));
+ data.getTooltip()));
}// else, if endTime <=0, still accessing
}
break;
case LogCenterConstants.FD_API_TYPE_LOCK_START:
lockSeries.addSeriesItem(new DAChartSeriesItem(
startTime, DAChartSeriesItem.SERIES_AREA_START,
- ColorResources.FILE_LOCK_ACQUIRED,
- ColorResources.FILE_LOCK_ACQUIRED, false,
- FilePageLabels.FILE_CHART_TOOLTIP_LOCK));
+ ColorResources.FILE_LOCK,
+ ColorResources.FILE_LOCK, false,
+ data.getTooltip()));
if(endTime > 0){
lockSeries.addSeriesItem(new DAChartSeriesItem(
endTime, DAChartSeriesItem.SERIES_AREA_END,
- ColorResources.FILE_LOCK_ACQUIRED,
- ColorResources.FILE_LOCK_ACQUIRED, false,
- FilePageLabels.FILE_CHART_TOOLTIP_LOCK));
+ ColorResources.FILE_LOCK,
+ ColorResources.FILE_LOCK, false,
+ data.getTooltip()));
}// else, if endTime <=0, still accessing
break;
- case LogCenterConstants.FD_API_TYPE_LOCK_WAIT_START:
- lockSeries.addSeriesItem(new DAChartSeriesItem(startTime,
- DAChartSeriesItem.SERIES_AREA_START,
- ColorResources.FILE_LOCK_WAITING,
- ColorResources.FILE_LOCK_WAITING, false,
- FilePageLabels.FILE_CHART_TOOLTIP_LOCK_WAIT));
- if (endTime > 0) {
- lockSeries.addSeriesItem(new DAChartSeriesItem(endTime,
- DAChartSeriesItem.SERIES_AREA_END,
- ColorResources.FILE_LOCK_WAITING,
- ColorResources.FILE_LOCK_WAITING, false,
- FilePageLabels.FILE_CHART_TOOLTIP_LOCK_WAIT));
- }// else, if endTime <=0, still accessing
+ case LogCenterConstants.FD_API_TYPE_UNLOCK:
+ lockSeries.addSeriesItem(new DAChartSeriesItem(
+ startTime, DAChartSeriesItem.SERIES_AREA_BAR,
+ ColorResources.FILE_UNLOCK, ColorResources.FILE_UNLOCK,
+ data.getTooltip()));
+ break;
+ case LogCenterConstants.FD_API_TYPE_LOCK_AUTORELEASE:
+ lockSeries.addSeriesItem(new DAChartSeriesItem(
+ startTime, DAChartSeriesItem.SERIES_AREA_BAR,
+ ColorResources.FILE_UNLOCK, ColorResources.FILE_UNLOCK,
+ data.getTooltip()));
+ break;
+ case LogCenterConstants.FD_API_TYPE_FAIL:
+ accessSeries.addSeriesItem(new DAChartSeriesItem(
+ startTime, DAChartSeriesItem.SERIES_AREA_BAR,
+ ColorResources.FILE_API_FAILED, ColorResources.FILE_API_FAILED,
+ data.getTooltip()));
break;
}
}
for(int i =0; i < statusList.size(); i++) {
FileStatus data = statusList.get(i);
- if(!data.getFilePath().equals(this.filePath)
- || data.getErrNo() != 0) {
+ if(data.getFileId() != this.fileId) {
continue;
}
double time = Formatter.longTimeToDoubleTime(data.getEventTime());
}
}
- public FileChart getChildChart(FileEvent event) {
+ public FileChart getChildChart(FileAccessor accessor) {
int size = child.size();
FileChart row;
for (int i = 0; i < size; i++) {
row = child.get(i);
- if (row.getPid() == event.getPid()
- && row.getTid() == event.getTid()){
+ if (row.getFileAccessor().equals(accessor)){
return row;
}
}
return null;
}
+
public DAChartBoardItem getItem() {
return item;
}
this.filePath = filePath;
}
- public int getPid() {
- return pid;
- }
-
- public void setPid(int pid) {
- this.pid = pid;
- }
-
- public int getTid() {
- return tid;
- }
-
- public void setTid(int tid) {
- this.tid = tid;
- }
-
- public long getFileSize() {
- return fileSize;
- }
-
- public void getFileSize(long fileSize) {
- this.fileSize = fileSize;
- }
-
- public long getFd() {
- return fd;
- }
-
- public void setFd(long fd) {
- this.fd = fd;
- }
-
public void setTarget(boolean isTarget) {
this.isTarget = isTarget;
}
public void setChartIndex(int index) {
this.chartIndex = index;
}
+
+ public int getFileId() {
+ return fileId;
+ }
+
+ public void setFileId(int fileId) {
+ this.fileId = fileId;
+ }
+
+ public void setFileAccessor(FileAccessor fileAccessor) {
+ this.fileAccessor = fileAccessor;
+ }
+
+ public FileAccessor getFileAccessor() {
+ return fileAccessor;
+ }
}
\ No newline at end of file
import java.util.ArrayList;
import java.util.HashMap;
-import java.util.HashSet;
import java.util.List;
import java.util.Map;
import org.eclipse.swt.widgets.Composite;
-import org.tizen.dynamicanalyzer.common.DALimit;
import org.tizen.dynamicanalyzer.communicator.DACommunicator;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.nl.FilePageLabels;
import org.tizen.dynamicanalyzer.ui.common.PopupStartMenuItemClickListener;
import org.tizen.dynamicanalyzer.ui.common.TimelineChartMouseEventListener;
import org.tizen.dynamicanalyzer.ui.common.TimelineChartMouseTrackAdapter;
-import org.tizen.dynamicanalyzer.ui.file.data.FileApiDB;
import org.tizen.dynamicanalyzer.ui.file.manager.FileDataMaker;
import org.tizen.dynamicanalyzer.ui.file.manager.FileDataManager;
import org.tizen.dynamicanalyzer.ui.file.model.FileAccess;
-import org.tizen.dynamicanalyzer.ui.file.model.FileEvent;
+import org.tizen.dynamicanalyzer.ui.file.model.FileAccessor;
import org.tizen.dynamicanalyzer.ui.file.model.FileSelectedData;
import org.tizen.dynamicanalyzer.ui.file.model.FileStatus;
+import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
import org.tizen.dynamicanalyzer.util.Logger;
import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
import org.tizen.dynamicanalyzer.utils.Formatter;
private List<FileChart> chartList = new ArrayList<FileChart>();
private FileDataManager fileChartManager = FileDataManager.getInstance();
private FileDataMaker dataMaker;
- private FileApiDB apiDB;
private int parentChartIndex = -1;
- private Map<HashSet<Object>, int[]> chartIndexMap = new HashMap<HashSet<Object>, int[]>();
+ private int preSelectionPId = -1;
+ private Map<Integer, int[]> chartIndexMap = new HashMap<Integer, int[]>();
+ public static final int FILE_NAME_MAX_LENGTH = 12;
+ public static final int FILE_NAME_SHOW_LINENUM = 2;
+ public static final int PROCESS_NAME_MAX_LENGTH = 16;
+ public static final int PROCESS_NAME_SHOW_LINENUM = 1;
+ public static final int MAX_LINE = 10;
public FileChartBoard(Composite parent, String title) {
super(parent, title);
dataMaker = fileChartManager.getFileChartDataMaker();
- apiDB = fileChartManager.getApiDB();
}
@Override
addNewFileChartRows();
updateStatusSeries();
updateAccessSeries();
- updateApiSeries();
+ chartFilteringByPId();
}
public void clear() {
}
}
- /**
- * create chart rows
- */
+ private void chartFilteringByPId() {
+ if (null == getItemList()) {
+ return;
+ }
+ int selectedPid = ToolbarArea.getInstance().getSelectedPid();
+ if (preSelectionPId != -1 && preSelectionPId != selectedPid) {
+ return;
+ }
+
+ int parentIndex = 0;
+ for (FileChart chart : chartList) {
+ if (!chart.isParentChart()) {
+ continue;
+ }
+ if (selectedPid == 0) {
+ showItem(parentIndex);
+ } else if (selectedPid == chart.getFileAccessor().getPid()) {
+ showItem(parentIndex);
+ } else {
+ hideItem(parentIndex);
+ }
+ parentIndex++;
+ }
+ preSelectionPId = selectedPid;
+ }
+
private void addNewFileChartRows() {
FileChart parent = null;
FileChart child = null;
String filePath = null;
-
- List<FileEvent> eventList = dataMaker.getFileEventList();
- if (eventList == null) {
- // no file event at all.
- if(dataMaker.getFileApiList() != null) {
- eventList = dataMaker.getFileApiList();
+ boolean isTarget = false;
+ int fileId = 0;
+
+ // 1. get accessorlist from data maker
+ List<FileAccessor> accessorList = dataMaker.getFileAccessor();
+ if (accessorList == null) {
+ if(dataMaker.getFileAccessorList() != null) {
+ accessorList = dataMaker.getFileAccessorList();
}else {
return;
}
}
- for (FileEvent event : eventList) {
- filePath = event.getFilePath();
- parent = getParentChart(filePath);
+ for (FileAccessor accessor : accessorList) {
+ filePath = accessor.getFilePath();
+ fileId = accessor.getFileId();
+ isTarget = accessor.isTarget();
+ parent = getParentChart(fileId);
+
if (parent == null) {
parentChartIndex++;
- parent = new FileChart(filePath);
- child = new FileChart(event.getPid(), event.getTid(),
- event.getFdValue(), event.getFilePath(),
- event.getFileSize(), event.isTarget(), parentChartIndex);
+ parent = new FileChart(filePath, fileId);
+ child = new FileChart(accessor, parentChartIndex, isTarget);
parent.addChild(child);
parent.setChartIndex(parentChartIndex);
createChartItem(null, parent);
chartList.add(child);
putChartIndextoMap(child, parent);
} else {
- child = parent.getChildChart(event);
+ child = parent.getChildChart(accessor);
if (child == null) {
- child = new FileChart(event.getPid(), event.getTid(),
- event.getFdValue(), event.getFilePath(),
- event.getFileSize(), event.isTarget(), parent.getChartIndex());
+ child = new FileChart(accessor, parent.getChartIndex(), isTarget);
parent.addChild(child);
createChartItem(parent, child);
chartList.add(child);
}
}
+
/**
* Drawing the chart title 1. parent: file name: max 2line, last: ... 2.
* child: "pid(PID) \n tid(TID)"
private void createChartItem(FileChart parent, FileChart fileChart) {
DAChartBoardItem item;
DAChart chart;
-
if (parent != null) { // child chart row
DAChartBoardItem parentItem = parent.getItem();
StringBuffer title = new StringBuffer();
- int pid = fileChart.getPid();
+ //StringBuffer fullTitle = new StringBuffer();
+ int pid = fileChart.getFileAccessor().getPid();
String processName = null;
- if(fileChart.isTarget()) {
- processName = AnalyzerUtil.getProcessName(fileChart.getPid());
+ String porcessInfo = fileChart.getFileAccessor().getPid() + "(PID)"//$NON-NLS-1$
+ + CommonConstants.NEW_LINE + fileChart.getFileAccessor().getTid() + "(TID)";//$NON-NLS-1$
+ if(fileChart.getFileAccessor().isTarget()) {
+ processName = AnalyzerUtil.getProcessName(fileChart.getFileAccessor().getPid());
} else {
processName = DACommunicator.getProcessNameFromTarget(pid);
}
if(processName!=null){
- processName = splitTitle(processName, DALimit.MAX_STRING_LENGTH);
- title.append(processName + CommonConstants.NEW_LINE);
+ title.append(processName + CommonConstants.NEW_LINE + porcessInfo);
}else{
- title.append("unKnown process" + CommonConstants.NEW_LINE);
+ title.append("unKnown process" + CommonConstants.NEW_LINE + porcessInfo);
}
- title.append(fileChart.getPid() + "(PID)"
- + CommonConstants.NEW_LINE + fileChart.getTid() + "(TID)");
- item = new DAChartBoardItem(parentItem, title.toString());
+ String name = splitTitle(title.toString(), PROCESS_NAME_MAX_LENGTH, false, PROCESS_NAME_SHOW_LINENUM);
+ String fullName = splitTitle(title.toString(), PROCESS_NAME_MAX_LENGTH, false, MAX_LINE);
+ item = new DAChartBoardItem(parentItem, name, fullName);
chart = item.getChart();
- item.setData(new FileSelectedData(fileChart.getFilePath(), fileChart.getPid(),
- fileChart.getTid(), fileChart.getFd(), false));
+ // add a selected data
+ item.setData(new FileSelectedData(fileChart.getFileAccessor(), false));
// disable non-target rows
if(!fileChart.isTarget()) {
item.setSelectable(false);
initFileChart(chart, false);
} else { // parent chart row
String fileName = fileChart.getFileName();
- String title = splitTitle(fileName, DALimit.MAX_STRING_LENGTH);
- item = new DAChartBoardItem(this, title);
- item.setData(new FileSelectedData(fileChart.getFilePath(),
- fileChart.getPid(), fileChart.getTid(), fileChart.getFd(),
- fileChart.getFileSize(), true));
+ String title = splitTitle(fileName, FILE_NAME_MAX_LENGTH, true, FILE_NAME_SHOW_LINENUM);
+ String fullName = splitTitle(fileName, FILE_NAME_MAX_LENGTH, true, MAX_LINE);
+ item = new DAChartBoardItem(this, title, fullName);
+ // add a selected data
+ item.setData(new FileSelectedData(fileChart.getFileId(), true));
chart = item.getChart();
initFileChart(chart, true);
}
chart.redraw();
}
- private String splitTitle(String name, int maxLen) {
- String title = name;
- if (name.length() > maxLen ) {
- title = name.substring(0, maxLen) + "...";
- }
- return title;
- }
-
/**
* update file open status
*/
if (chartList.size() > 0) {
List<FileAccess> accessList = getVisibleAccessList();
for (FileChart chart : chartList) {
- chart.updateAccessSeries(accessList);
- }
- }
- }
-
- /**
- * update file api
- */
- private void updateApiSeries() {
- if (chartList.size() > 0) {
- /*List<FileEvent> apiList = apiDB.selectAPISeries(
- getVisibleStartTime(), getVisibleEndTime());*/
- List<FileEvent> apiList = apiDB.selectFailedAPISeries(
- getVisibleStartTime(), getVisibleEndTime());
- if (null == apiList) {
- // no file event within the selected time range.
- return;
- }
- for (FileChart chart : chartList) {
- if (chart.isParentChart()) {
- continue;
+ if(!chart.isParentChart()) {
+ chart.updateAccessSeries(accessList);
}
- chart.updateApiSeries(apiList);
}
- } else { // chartList.size() <= 0
- // no data at all
}
}
- private FileChart getParentChart(String filePath) {
+ private FileChart getParentChart(int id) {
for (FileChart chart : chartList) {
- if (chart.getFilePath().equals(filePath) && chart.isParentChart()) {
+ if (chart.getFileId()==id && chart.isParentChart()) {
return chart;
}
}
}
private void putChartIndextoMap(FileChart childChart, FileChart parentChart ) {
- HashSet<Object> set = new HashSet<Object>();
- set.add(childChart.getFilePath());
- set.add(childChart.getPid());
- set.add(childChart.getTid());
- chartIndexMap.put(set, new int[] { parentChart.getChartIndex(),
- parentChart.getLastChildChartIndex() });
+ chartIndexMap.put(childChart.getFileAccessor().getAccessorId(),
+ new int[] { parentChart.getChartIndex(), parentChart.getLastChildChartIndex() });
}
- public int[] getChartIndex(FileEvent event) {
- HashSet<Object> set = new HashSet<Object>();
- set.add(event.getFilePath());
- set.add(event.getPid());
- set.add(event.getTid());
- if(chartIndexMap.containsKey(set)) {
- return chartIndexMap.get(set);
+ public int[] getChartIndex(int accessorId) {
+ if(chartIndexMap.containsKey(accessorId)) {
+ return chartIndexMap.get(accessorId);
}
- Logger.error("couldn't find index:" + event.getFilePath() + ","
- + event.getPid() + "," + event.getTid());
+ Logger.error("couldn't find index:" + accessorId );
return new int[]{0, 0};
}
+ private String splitTitle(String name, int maxLen, boolean isParent, int line) {
+ String titleString = null;
+ String title[] = null;
+ int i = 1;
+ int len = name.length();
+ if (!isParent) {
+ title = name.split("\n");
+ name = title[0];
+ }
+ if (len > maxLen) {
+ String slice = splitTitle(name, maxLen);
+ String spare = name.substring(maxLen, name.length());
+ titleString = slice;
+ if (spare.length() <= maxLen) {
+ if (line > 1) {
+ titleString += (CommonConstants.NEW_LINE + spare);
+ } else {
+ titleString += "...";//$NON-NLS-1$
+ }
+ } else {
+ while (spare.length() > maxLen) {
+ i++;
+ slice = splitTitle(spare, maxLen);
+ spare = spare.substring(maxLen, spare.length());
+ titleString += (CommonConstants.NEW_LINE + slice);
+ if (i >= line) {
+ break;
+ }
+ }
+ if (i < line) {
+ titleString += (CommonConstants.NEW_LINE + spare);
+ } else {
+ String temp = (titleString.substring(titleString.length()
+ - maxLen, titleString.length() - 3) + "...");//$NON-NLS-1$
+ String text = titleString.substring(0, titleString.length()
+ - maxLen);
+ text += temp;
+ titleString = text;
+ }
+ }
+ } else {
+ titleString = name;
+ }
+ if (!isParent) {
+ titleString += (CommonConstants.NEW_LINE + title[1]
+ + CommonConstants.NEW_LINE + title[2]);
+ }
+ return titleString;
+ }
+
+ private String splitTitle(String text, int maxLen) {
+ String spare = null;
+ int len = text.length();
+ if(len > maxLen) {
+ spare = text.substring(0, maxLen);
+ }else{
+ spare = text;
+ }
+ return spare;
+ }
+
+
private void initFileChart(DAChart chart, boolean isParent) {
if (null == chart) {
return;
}
DAChartPlot plot = chart.getPlot();
-
+ chart.setChartRenderer(new FileChartRenderer()); // need to custom Chart Render for file chart
if (isParent) {
DAChartSeries statusSeries = new DAChartSeries(
FilePageLabels.FILE_CHART_SERIES,
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Hyeran kim <hyearn74.kim@samsung.com>
+ * Jungwook Ryu <jungwook.ryu@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+
+package org.tizen.dynamicanalyzer.ui.file;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.graphics.Color;
+import org.eclipse.swt.graphics.GC;
+import org.tizen.dynamicanalyzer.widgets.chart.DAChart;
+import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlotTooltip;
+import org.tizen.dynamicanalyzer.widgets.chart.DAChartRenderer;
+import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeries;
+import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeriesItem;
+import org.tizen.dynamicanalyzer.widgets.helper.ColorResources;
+
+public class FileChartRenderer extends DAChartRenderer {
+ @Override
+ protected void drawToGc(GC gc, DAChart chart) {
+ if (!preDraw(gc, chart)) {
+ return;
+ }
+ for (int i = 0; i < seriesList.size(); i++) {
+ drawSeries(gc, seriesList.get(i), i, seriesList.size());
+ }
+ }
+
+ /*
+ * This method is one of Chart renderer. Real chart using this method is
+ * File Analysis chart. This renderer draws Rectangle and bar in multi line
+ * and need specific seriesItem type. Type is possible SERIES_AREA_START,
+ * SERIES_AREA_END, SERIES_AREA_BAR.
+ */
+ private void drawSeries(GC gc, DAChartSeries series, int seriesIndex, int seriesSize) {
+ List<DAChartSeriesItem> seriesItems = series.getSeriesItemList();
+ if (null == seriesItems) {
+ return;
+ }
+
+ int seriesItemSize = seriesItems.size();
+ if (seriesItemSize < 1) {
+ return;
+ }
+ int index = series.getPrevIndexByXvalue(plot.getVisibleStartX());
+ if (index < 0) {
+ index = 0;
+ }
+
+ final int MARGIN_PERCENT = 20; // It's mean 20%
+ final int STATE_AREA_BAR_WIDTH = 1;
+ final int DIAGONAL_DIVIDE = 16; // divided in 16 pieces for diagonal box
+ // size.
+ final Color DIAGONAL_BOX_COLOR = ColorResources.WHITE;
+ /*
+ * Formula to divide in equal series heights.
+ */
+ int margin = (int) ((r.height * (MARGIN_PERCENT / 100.0)) / (seriesSize + 1));
+ int areaHeight = (r.height - margin * (seriesSize + 1)) / seriesSize;
+ int pixcelStartY = (margin * (seriesIndex + 1)) + (areaHeight * seriesIndex);
+
+ List<DAChartSeriesItem> barSeriesItems = new ArrayList<DAChartSeriesItem>();
+ /*
+ * 1. Draw Start/End Status Area.
+ */
+ for (int i = 0; i < seriesItemSize; i++) {
+ DAChartSeriesItem seriesItem = seriesItems.get(i);
+ DAChartSeriesItem endSeriesItem = null;
+
+ int type = (int) seriesItem.getY();
+ if (DAChartSeriesItem.SERIES_AREA_START == type) {
+ int startCount = 1;
+ /*
+ * Find end series item matched with start series item.
+ */
+ for (int ii = i + 1; ii < seriesItemSize; ii++) {
+ DAChartSeriesItem nextSeriesItem = seriesItems.get(ii);
+ int nextType = (int) nextSeriesItem.getY();
+ if (nextType == DAChartSeriesItem.SERIES_AREA_START) {
+ startCount += 1;
+ } else if (nextType == DAChartSeriesItem.SERIES_AREA_END) {
+ --startCount;
+ if (startCount == 0) {
+ endSeriesItem = nextSeriesItem;
+ break;
+ }
+ }
+ }
+ Color foreGroundColor = seriesItem.getGradationForegroundColor();
+ Color backGroundcolor = seriesItem.getColor();
+ gc.setForeground(foreGroundColor);
+ gc.setBackground(backGroundcolor);
+
+ int pixcelStartX = plot.getXPixcelFromX(seriesItem.getX(), r);
+ int pixcelWidth;
+ if (endSeriesItem != null) {
+ pixcelWidth = plot.getXPixcelFromX(endSeriesItem.getX(), r) - pixcelStartX;
+ } else {
+ /*
+ * endSeriesItem is null when end series is not exist. this
+ * case, draw it as much as getValidEndX.
+ */
+ pixcelWidth = plot.getXPixcelFromX(plot.getValidEndX(), r) - pixcelStartX;
+ }
+ if (pixcelWidth == 0) { // If diffence is less than 1 second.
+ // draw 1 pixcel force.
+ pixcelWidth = 1;
+ }
+ gc.fillRectangle(pixcelStartX, pixcelStartY, pixcelWidth, areaHeight);
+
+ /*
+ * If it's needed, draw diagonal line. diagonal line is composed
+ * of square boxes. Direction of diagonal line is right top to
+ * left down like "/".
+ */
+ if (seriesItem.getDiagonal()) {
+ int diagonalBoxSize = areaHeight / DIAGONAL_DIVIDE;
+ gc.setForeground(DIAGONAL_BOX_COLOR);
+ gc.setBackground(DIAGONAL_BOX_COLOR);
+ for (int j = 0; j < 16; j++) {
+ int boxY = pixcelStartY + (diagonalBoxSize * j);
+ // Formula to draw diagonal line like "/"
+ for (int k = 3 - (j % 4) - (j / 4); k < pixcelWidth; k = k + 3) {
+ int boxX = diagonalBoxSize * k + pixcelStartX;
+ if (pixcelStartX <= boxX && boxX <= pixcelWidth + pixcelStartX - diagonalBoxSize) {
+ gc.fillRectangle(boxX, boxY, diagonalBoxSize, diagonalBoxSize);
+ }
+ }
+ }
+ }
+ } else if (DAChartSeriesItem.SERIES_AREA_BAR == type) {
+ barSeriesItems.add(seriesItem);
+ }
+ }
+
+ /*
+ * 2. Draw Bar series
+ */
+ for (int i = 0; i < barSeriesItems.size(); i++) {
+ DAChartSeriesItem barSeriesItem = barSeriesItems.get(i);
+ Color foreGroundColor = barSeriesItem.getGradationForegroundColor();
+ Color backGroundcolor = barSeriesItem.getColor();
+ gc.setForeground(foreGroundColor);
+ gc.setBackground(backGroundcolor);
+ int pixcelStartX = plot.getXPixcelFromX(barSeriesItem.getX(), r);
+ gc.fillRectangle(pixcelStartX, pixcelStartY, STATE_AREA_BAR_WIDTH, areaHeight);
+ }
+ }
+
+ @Override
+ protected void drawTooltip(GC gc) {
+ DAChartPlotTooltip tooltip = plot.getTooltip();
+ if (tooltip == null || tooltip.shouldBeDrawn() == false || tooltip.getStartVal() == -1) {
+ return;
+ }
+
+ gc.setFont(tooltip.getFont());
+
+ List<String> tooltipTexts = new ArrayList<String>();
+ List<String> tooltipTimes = new ArrayList<String>();
+ List<Color> tooltipColor = new ArrayList<Color>();
+
+ // make text,time & draw auxiliary line
+ int textWidthMax = 0;
+ double realXVal = tooltip.getStartVal();
+ int tooltipSize = 0;
+
+ int seriesIndex = (int) (seriesList.size() * tooltip.getYPosRatio());
+ DAChartSeries series = seriesList.get(seriesIndex);
+
+ int index = series.getPrevIndexByXvalue(realXVal);
+ String text = "";
+ String time = "";
+ Color color;
+ if (index >= 0) {
+ double xVal = series.getSeriesItemList().get(index).getX();
+
+ text += series.getName() + ": ";
+ time += toTimeFormat(xVal);
+
+ if (true == series.isSummarizeTooltip() && true == checkOverlapFromPrevItem(series, index)) {
+ text += series.getSummarizeString();
+ } else {
+ text += series.getSeriesItemList().get(index).getTooltipText();
+ }
+
+ gc.setForeground(tooltip.getLineColor());
+ gc.setLineStyle(SWT.LINE_DOT);
+ gc.setLineWidth(1);
+ gc.drawLine(plot.getXPixcelFromX(xVal), 0, plot.getXPixcelFromX(xVal), r.height);
+ gc.setLineStyle(SWT.LINE_CUSTOM);
+
+ // event color
+ color = series.getSeriesItemList().get(index).getColor();
+ } else {
+ return;
+ }
+
+ tooltipTexts.add(text);
+ tooltipTimes.add(time);
+ tooltipColor.add(color);
+
+ int textWidth = gc.textExtent(text).x + DAChartPlotTooltip.TOOLTIP_TIME_MARGIN + gc.textExtent(time).x;
+ if (textWidthMax < textWidth) {
+ textWidthMax = textWidth;
+ }
+
+ /*
+ * Drawing Tooltip Box
+ */
+ int preTextWidthMargin = DAChartPlotTooltip.TOOLTIP_MARGIN + DAChartPlotTooltip.TOOLTIP_SERIES_RECT_LENGTH
+ + DAChartPlotTooltip.TOOLTIP_MARGIN;
+ int startX = getTooltipStartX(realXVal, textWidthMax + preTextWidthMargin, DAChartPlotTooltip.TOOLTIP_MARGIN);
+
+ int totalHeight;
+ if (!tooltipTexts.isEmpty()) {
+ totalHeight = gc.textExtent(tooltipTexts.get(0)).y + DAChartPlotTooltip.TOOLTIP_MARGIN
+ + DAChartPlotTooltip.TOOLTIP_MARGIN;
+ } else {
+ totalHeight = DAChartPlotTooltip.TOOLTIP_TEXT_HEIGHT + DAChartPlotTooltip.TOOLTIP_MARGIN
+ + DAChartPlotTooltip.TOOLTIP_MARGIN;
+ }
+
+ int startY;
+ tooltipSize = seriesList.size();
+ int heightPerSeries = r.height / tooltipSize;
+ int currentSeries = ((int) (tooltip.getYPosRatio() * tooltipSize) + 1);
+ startY = r.y + (heightPerSeries * (currentSeries - 1)) + (heightPerSeries / 2) - (totalHeight / 2);
+ if (r.height - startY - totalHeight < 0) {
+ startY = r.height - totalHeight - 1;
+ if (startY < 0) {
+ startY = DAChartPlotTooltip.TOOLTIP_MARGIN;
+ }
+ }
+ gc.setAlpha(150);
+ gc.setBackground(tooltip.getBackgroundColor());
+ gc.setForeground(tooltip.getForegroundColor());
+ gc.fillGradientRectangle(startX, startY, preTextWidthMargin + textWidthMax + DAChartPlotTooltip.TOOLTIP_MARGIN,
+ totalHeight, true);
+ gc.setAlpha(255);
+ gc.setForeground(tooltip.getLineColor());
+ gc.drawRoundRectangle(startX, startY, preTextWidthMargin + textWidthMax + DAChartPlotTooltip.TOOLTIP_MARGIN,
+ totalHeight, 5, 5);
+ gc.setFont(tooltip.getFont());
+
+ /*
+ * Drawing Tooltip contents (color square, text, time)
+ */
+ int y = startY + DAChartPlotTooltip.TOOLTIP_MARGIN;
+ Color col = tooltipColor.get(0);
+ if (col == null) {
+ gc.setBackground(series.getColor());
+ } else {
+ gc.setBackground(col);
+ }
+
+ gc.fillRectangle(startX + DAChartPlotTooltip.TOOLTIP_MARGIN, y + DAChartPlotTooltip.TOOLTIP_TEXT_HEIGHT / 2
+ - DAChartPlotTooltip.TOOLTIP_SERIES_RECT_LENGTH / 2, DAChartPlotTooltip.TOOLTIP_SERIES_RECT_LENGTH,
+ DAChartPlotTooltip.TOOLTIP_SERIES_RECT_LENGTH);
+ gc.setBackground(tooltip.getBackgroundColor());
+
+ gc.setForeground(tooltip.getTextColor());
+ gc.drawText(tooltipTexts.get(0), startX + DAChartPlotTooltip.TOOLTIP_MARGIN
+ + DAChartPlotTooltip.TOOLTIP_SERIES_RECT_LENGTH + DAChartPlotTooltip.TOOLTIP_MARGIN, y,
+ SWT.DRAW_DELIMITER | SWT.DRAW_TRANSPARENT);
+
+ gc.setForeground(tooltip.getTimeColor());
+ String timeStr = tooltipTimes.get(0);
+ gc.drawText(tooltipTimes.get(0), startX + DAChartPlotTooltip.TOOLTIP_MARGIN
+ + DAChartPlotTooltip.TOOLTIP_SERIES_RECT_LENGTH + DAChartPlotTooltip.TOOLTIP_MARGIN + textWidthMax
+ - DAChartPlotTooltip.TOOLTIP_MARGIN - gc.textExtent(timeStr).x, y, SWT.DRAW_DELIMITER
+ | SWT.DRAW_TRANSPARENT);
+ }
+}
package org.tizen.dynamicanalyzer.ui.file;
+import java.sql.ResultSet;
+import java.sql.SQLException;
import org.eclipse.swt.custom.StackLayout;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.DASelectionData;
+import org.tizen.dynamicanalyzer.database.SqlConnectionManager;
import org.tizen.dynamicanalyzer.nl.FilePageLabels;
import org.tizen.dynamicanalyzer.resources.ColorResources;
import org.tizen.dynamicanalyzer.resources.FontResources;
import org.tizen.dynamicanalyzer.ui.common.SetRangeMarkerMouseMoveListener;
import org.tizen.dynamicanalyzer.ui.common.UICommonConstants;
import org.tizen.dynamicanalyzer.ui.file.manager.FileDataManager;
-import org.tizen.dynamicanalyzer.ui.file.model.FileEvent;
import org.tizen.dynamicanalyzer.ui.range.RangeDataManager;
import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants;
import org.tizen.dynamicanalyzer.ui.timeline.logparser.LifecycleLogParser;
@Override
public void handleSelectionEvent(DAChartBoardItem item) {
lastSelectedItemForSummary = item;
- AnalyzerManager
- .getCurrentPage().updateView(
- new DASelectionData(
- FilePage.chartViewID,
- (long) (((DAChartPlotIntervalMarker) fileChartBoard
- .getMarkers()
- .get(UICommonConstants.SELECTION_MARKER_INDEX))
- .getStartVal() * TimelineConstants.MEGA_DOUBLE),
- (long) (((DAChartPlotIntervalMarker) fileChartBoard
- .getMarkers()
- .get(UICommonConstants.SELECTION_MARKER_INDEX))
- .getEndVal() * TimelineConstants.MEGA_DOUBLE),
- item.getData(), null));
+ DAChartPlotIntervalMarker intervalMarker = (DAChartPlotIntervalMarker) fileChartBoard
+ .getMarkers().get(UICommonConstants.SELECTION_MARKER_INDEX);
+ long selectiedStartTime = (long) (intervalMarker.getStartVal() * TimelineConstants.MEGA_DOUBLE);
+ long selectiedEndTime = (long) (intervalMarker.getEndVal() * TimelineConstants.MEGA_DOUBLE);
+ AnalyzerManager.getCurrentPage().updateView(
+ new DASelectionData(FilePage.chartViewID,
+ selectiedStartTime, selectiedEndTime, item.getData(), null));
}
});
if (null != obData && (obData instanceof LogData)) { // summary
LogData ldata = (LogData) obData;
dataTime = ldata.getTime();
+
long seq = ldata.getSeq();
- FileEvent event = chartManager.getApiDB().selectFileEventBySeq(seq);
- if(event != null) {
- int selectedIndex[] = fileChartBoard.getChartIndex(event);
- fileChartBoard.selectItem(selectedIndex[0], selectedIndex[1]);
- if (null != lastSelectedItemForSummary) {
- AnalyzerManager.getCurrentPage().updateView(
- new DASelectionData(FilePage.chartViewID,
- dataTime, dataTime,
- lastSelectedItemForSummary.getData(),
- null));
+
+ ResultSet rs = chartManager.getApiDB().selectFileEventBySeq(seq);
+ if (rs != null) {
+ try {
+ if (rs.next()) {
+ int selectedIndex[] = fileChartBoard.getChartIndex(rs.getInt(1));
+ fileChartBoard.selectItem(selectedIndex[0], selectedIndex[1]);
+ if (null != lastSelectedItemForSummary) {
+ AnalyzerManager.getCurrentPage().updateView(
+ new DASelectionData(FilePage.chartViewID,
+ dataTime, dataTime,
+ lastSelectedItemForSummary.getData(),
+ null));
+ }
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ } finally {
+ SqlConnectionManager.releaseResultSet(rs);
}
- } // else, no need to update
+ }
}
} else {
dataTime = selData.getStartTime();
package org.tizen.dynamicanalyzer.ui.file;
-import java.util.List;
+import java.sql.ResultSet;
+import java.sql.SQLException;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.layout.FillLayout;
+import org.eclipse.swt.layout.FormAttachment;
+import org.eclipse.swt.layout.FormData;
+import org.eclipse.swt.layout.FormLayout;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Label;
+import org.eclipse.swt.widgets.Text;
import org.tizen.dynamicanalyzer.common.DASelectionData;
+import org.tizen.dynamicanalyzer.constant.CommonConstants;
+import org.tizen.dynamicanalyzer.database.SqlConnectionManager;
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
import org.tizen.dynamicanalyzer.nl.AnalyzerLabels;
import org.tizen.dynamicanalyzer.nl.FilePageLabels;
import org.tizen.dynamicanalyzer.resources.ColorResources;
import org.tizen.dynamicanalyzer.resources.FontResources;
import org.tizen.dynamicanalyzer.ui.file.manager.FileDataManager;
-import org.tizen.dynamicanalyzer.ui.file.model.FileEvent;
+import org.tizen.dynamicanalyzer.ui.file.model.FileAccessor;
import org.tizen.dynamicanalyzer.ui.file.model.FileSelectedData;
import org.tizen.dynamicanalyzer.widgets.da.view.DAViewComposite;
import org.tizen.dynamicanalyzer.widgets.da.view.DAViewData;
public class FileDetailInfoView extends DAViewComposite {
+
private Canvas canvas = null;
private String fileName = AnalyzerLabels.EMPTY_STRING;
private String filePath = AnalyzerLabels.EMPTY_STRING;
private int failedApiCount = 0;
private FileDataManager fileChartManager = FileDataManager.getInstance();
-
+
+ private Text detailText = null;
+ private Label labelMessage = null;
+
private void init() {
fileName = AnalyzerLabels.EMPTY_STRING;
filePath = AnalyzerLabels.EMPTY_STRING;
this.setLayout(new FillLayout());
setTitle(FilePageLabels.FILE_DETAILS_TITLE);
+
+ Composite detailCom = 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 = getContentArea();
+ Composite contents = detailCom;
contents.setBackground(ColorResources.VIEW_BG_COLOR);
- contents.setLayout(new FillLayout());
- canvas = new Canvas(contents, SWT.TRANSPARENT);
- canvas.addPaintListener(new PaintListener() {
-
- @Override
- public void paintControl(PaintEvent e) {
- int x = 0;
- int y = 0;
- Rectangle rect = canvas.getBounds();
- e.gc.setBackground(ColorResources.VIEW_BG_COLOR);
- e.gc.fillRectangle(rect.x, rect.y, rect.width, rect.height);
- e.gc.setForeground(ColorResources.TABLE_CONTENTS_FONT_COLOR);
- e.gc.setFont(FontResources.DETAIL_INFO_FONT);
-
- String pathLabel = FilePageLabels.FILE_DETAILS_FILE_PATH;
- Point pathSize = e.gc.textExtent(pathLabel, SWT.DRAW_MNEMONIC);
- int fontHeight = pathSize.y + 5;
- e.gc.drawString(FilePageLabels.FILE_DETAILS_FILE_PATH
- + filePath, x + 10, y += fontHeight);
-
- e.gc.drawString( FilePageLabels.FILE_DETAILS_FILE_NAME
- + fileName, x += 10, y += fontHeight);
-
- e.gc.drawString(
- FilePageLabels.FILE_DETAILS_TOTAL_SIZE
- + Long.toString(fileSize), x, y += fontHeight);
- e.gc.drawString(
- FilePageLabels.FILE_DETAILS_READ_SIZE
- + Long.toString(readSize), x, y += fontHeight);
- e.gc.drawString(
- FilePageLabels.FILE_DETAILS_WRITE_SIZE
- + Long.toString(writeSize), x, y += fontHeight);
- e.gc.drawString(
- FilePageLabels.FILE_DETAILS_API_COUNT
- + Integer.toString(apiCount), x,
- y += fontHeight);
- e.gc.drawString(FilePageLabels.FILE_DETAILS_FAILED_API_COUNT
- + Integer.toString(failedApiCount), x, y += fontHeight);
- }
- });
+ 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);
+ detailText.getVerticalBar().setVisible(true);
+ detailText.getHorizontalBar().setVisible(true);
+
+ showDetailInfoContents();
+
}
@Override
private void updateData(FileSelectedData selectData) {
failedApiCount = 0;
- List<FileEvent> events = null;
- events = fileChartManager.getApiDB().selectAPITable(
- selectData.getFilePath(), selectData.getPid(),
- selectData.getTid(), selectData.isParentChart());
- if (events != null) {
- filePath = events.get(0).getFilePath();
- fileName = events.get(0).getFileName();
- fileSize = events.get(events.size()-1).getFileSize();
-
- long readSize = 0;
- long writeSize = 0;
- int apiCount = events.size();
- for(FileEvent data : events) {
- switch(data.getFdApiType()) {
- case LogCenterConstants.FD_API_TYPE_OPEN:
- case LogCenterConstants.FD_API_TYPE_CLOSE:
- case LogCenterConstants.FD_API_TYPE_OTHERS:
- case LogCenterConstants.FD_API_TYPE_UNLOCK:
- if(data.getErrno() != 0) {
- failedApiCount++;
- }
- break;
- case LogCenterConstants.FD_API_TYPE_LOCK_END:
- if(data.getErrno() != 0) {
- failedApiCount++;
- }
- apiCount--;
- break;
- case LogCenterConstants.FD_API_TYPE_READ_END:
- if(data.getErrno() != 0) {
- failedApiCount++;
+ ResultSet rs = fileChartManager.getApiDB().selectAPI(
+ selectData.getFileId(),
+ selectData.getAccessorId(),
+ selectData.isParentChart());
+ boolean isParentChart = selectData.isParentChart();
+ FileAccessor accessor = selectData.getFileAccessor();
+ String path = null;
+ if (rs != null) {
+ try {
+ long readSize = 0;
+ long writeSize = 0;
+ int apiCount = 0;
+
+ while (rs.next()) {
+ apiCount++;
+ if(rs.isFirst()) {
+ if(isParentChart){
+ path = rs.getString(11);
+ }else{
+ path = accessor.getFilePath();
+ }
+ boolean isFindSpliter = false;
+ for(int i= path.length()-1; i > 0; i--) {
+ char character = path.charAt(i);
+ if(Character.toString(character).matches("\\/")) { //$NON-NLS-1$*/
+ filePath = path.substring(0, i+1);
+ fileName = path.substring(i+1, path.length());
+ isFindSpliter = true;
+ break;
+ }
+ }
+ if(!isFindSpliter) {
+ fileName = path;
+ filePath = AnalyzerLabels.EMPTY_STRING;
+ }
+ }else if(rs.isLast()) {
+ fileSize = rs.getLong(7);
}
- readSize += data.getSize();
- // except *_end event among the API count
- apiCount--;
- break;
- case LogCenterConstants.FD_API_TYPE_WRITE_END:
- if(data.getErrno() != 0) {
- failedApiCount++;
+ int apiType = rs.getInt(3);
+ long errno = rs.getInt(6);
+ long ioSize = rs.getLong(8);
+
+ switch(apiType) {
+ case LogCenterConstants.FD_API_TYPE_OPEN:
+ case LogCenterConstants.FD_API_TYPE_CLOSE:
+ case LogCenterConstants.FD_API_TYPE_OTHERS:
+ case LogCenterConstants.FD_API_TYPE_UNLOCK:
+ if(errno != 0) {
+ failedApiCount++;
+ }
+ break;
+ case LogCenterConstants.FD_API_TYPE_LOCK_END:
+ if(errno != 0) {
+ failedApiCount++;
+ }
+ apiCount--;
+ break;
+ case LogCenterConstants.FD_API_TYPE_READ_END:
+ if(errno != 0) {
+ failedApiCount++;
+ }
+ readSize += ioSize;
+ // except *_end event among the API count
+ apiCount--;
+ break;
+ case LogCenterConstants.FD_API_TYPE_WRITE_END:
+ if(errno != 0) {
+ failedApiCount++;
+ }
+ writeSize += ioSize;
+ // except *_end event among the API count
+ apiCount--;
+ break;
+ default:
+ break;
}
- writeSize += data.getSize();
- // except *_end event among the API count
- apiCount--;
- break;
- default:
- break;
}
+ this.apiCount = apiCount;
+ this.readSize = readSize;
+ this.writeSize = writeSize;
+ } catch (SQLException e) {
+ e.printStackTrace();
+ } finally {
+ SqlConnectionManager.releaseResultSet(rs);
}
- this.apiCount = apiCount;
- this.readSize = readSize;
- this.writeSize = writeSize;
+
+ showDetailInfoContents();
}
- canvas.redraw();
}
+ private void showDetailInfoContents() {
+ StringBuffer strDetailView = new StringBuffer(CommonConstants.DOUBLE_NEW_LINE);
+ strDetailView.append(CommonConstants.DOUBLE_SPACE + FilePageLabels.FILE_DETAILS_FILE_PATH );
+ strDetailView.append(filePath);
+ strDetailView.append(CommonConstants.DOUBLE_NEW_LINE);
+ strDetailView.append(CommonConstants.DOUBLE_SPACE + FilePageLabels.FILE_DETAILS_FILE_NAME);
+ strDetailView.append(fileName);
+ strDetailView.append(CommonConstants.DOUBLE_NEW_LINE);
+ strDetailView.append(CommonConstants.DOUBLE_SPACE + FilePageLabels.FILE_DETAILS_TOTAL_SIZE);
+ strDetailView.append(fileSize);
+ strDetailView.append(CommonConstants.DOUBLE_NEW_LINE);
+ strDetailView.append(CommonConstants.DOUBLE_SPACE + FilePageLabels.FILE_DETAILS_READ_SIZE);
+ strDetailView.append(readSize);
+ strDetailView.append(CommonConstants.DOUBLE_NEW_LINE);
+ strDetailView.append(CommonConstants.DOUBLE_SPACE + FilePageLabels.FILE_DETAILS_WRITE_SIZE);
+ strDetailView.append(writeSize);
+ strDetailView.append(CommonConstants.DOUBLE_NEW_LINE);
+ strDetailView.append(CommonConstants.DOUBLE_SPACE + FilePageLabels.FILE_DETAILS_API_COUNT);
+ strDetailView.append(apiCount);
+ strDetailView.append(CommonConstants.DOUBLE_NEW_LINE);
+ strDetailView.append(CommonConstants.DOUBLE_SPACE + FilePageLabels.FILE_DETAILS_FAILED_API_COUNT);
+ strDetailView.append(failedApiCount);
+ strDetailView.append(CommonConstants.DOUBLE_NEW_LINE);
+ detailText.setText(strDetailView.toString());
+ }
+
@Override
public Control getControl() {
return canvas;
@Override
public void clear() {
init();
- canvas.redraw();
+ showDetailInfoContents();
}
}
package org.tizen.dynamicanalyzer.ui.file.data;
import java.sql.PreparedStatement;
+import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import org.tizen.dynamicanalyzer.nl.FilePageLabels;
import org.tizen.dynamicanalyzer.ui.file.model.FileAccess;
-// read, write, lock
public class FileAccessDB extends DBTable {
- private static final String TABLE_NAME = FilePageLabels.FILE_ACCESS_DB;
-
+ private static final String ACCESS_TABLE = FilePageLabels.FILE_ACCESS_DB;
+ private static final String DBTYPE_TOOLTIP = "VARCHAR(256)";//$NON-NLS-1$
+
public static enum COLUMN {
- PID(0, "pid"),
- TID(1, "tid"),
- FILE_PATH(2, "filePath"),
- FD(3, "fd"),
- API_TYPE(4, "apiType"),
- START_TIME(5, "startTime"),
- END_TIME(6, "endTime"),
- ERRNO(7, "errNo"),
- FILE_SIZE(8, "fileSize");
+ ACCESSOR_ID(1, "ACCESSOR_ID"),
+ API_TYPE(2, "API_TYPE"),
+ START_TIME(3, "START_TIME"),
+ END_TIME(4, "END_TIME"),
+ TOOLTIP(5, "TOOLTIP");
- private final int value;
+ private final int index;
private final String name;
- private COLUMN(int value, String name) {
- this.value = value;
+ private COLUMN(int index, String name) {
+ this.index = index;
this.name = name;
}
- public int getValue() {
- return value;
+ public int getIndex() {
+ return index;
}
public String getName() {
return name;
}
}
-
+
public FileAccessDB() {
- addColumn(new DBColumn(COLUMN.PID.getName(), DBConstants.NOT_NULL, DBConstants.INTEGER));
- addColumn(new DBColumn(COLUMN.TID.getName(), DBConstants.NOT_NULL, DBConstants.INTEGER));
- addColumn(new DBColumn(COLUMN.FILE_PATH.getName(), DBConstants.EMPTY, DBConstants.BIG_TEXT));
- addColumn(new DBColumn(COLUMN.FD.getName(), DBConstants.EMPTY, DBConstants.LONG));
- addColumn(new DBColumn(COLUMN.API_TYPE.getName(), DBConstants.NOT_NULL, DBConstants.INTEGER));
- addColumn(new DBColumn(COLUMN.START_TIME.getName(), DBConstants.NOT_NULL, DBConstants.LONG));
- addColumn(new DBColumn(COLUMN.END_TIME.getName(), DBConstants.NOT_NULL, DBConstants.LONG));
- addColumn(new DBColumn(COLUMN.ERRNO.getName(), DBConstants.EMPTY, DBConstants.LONG));
- addColumn(new DBColumn(COLUMN.FILE_SIZE.getName(), DBConstants.EMPTY, DBConstants.LONG));
+ addColumn(new DBColumn(COLUMN.ACCESSOR_ID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.API_TYPE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.START_TIME.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.END_TIME.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.TOOLTIP.name, DBConstants.EMPTY, DBTYPE_TOOLTIP));
}
@Override
public String getTableName() {
- return TABLE_NAME;
+ return ACCESS_TABLE;
}
private static final String selectAll = selectAll();
private static final String SELECT_QUERY = "select "
+ selectAll
- + " from " + TABLE_NAME; //$NON-NLS-1$
+ + " from " + ACCESS_TABLE;
+
+ public List<FileAccess> executeQueryRS(String query) {
+ List<FileAccess> resultData = new ArrayList<FileAccess>();
+ ResultSet rs = SqlConnectionManager.executeQueryRS(query);
+ if (rs != null) {
+ try {
+ while (rs.next()) {
+ FileAccess access= getDataFromResultSet(rs);
+ if (access != null) {
+ resultData.add(access);
+ }
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ } finally {
+ SqlConnectionManager.releaseResultSet(rs);
+ }
+ }
+ return resultData;
+ }
+
+ public FileAccess getDataFromResultSet(ResultSet rs) {
+ FileAccess access = null;
+ try {
+ access = new FileAccess(
+ rs.getInt(COLUMN.ACCESSOR_ID.index),
+ rs.getInt(COLUMN.API_TYPE.index),
+ rs.getLong(COLUMN.START_TIME.index),
+ rs.getLong(COLUMN.END_TIME.index),
+ rs.getString(COLUMN.TOOLTIP.index)
+ );
+ } catch (SQLException e) {
+ e.printStackTrace();
+ return null;
+ }
+ return access;
+ }
public void insert(FileAccess insertData) {
List<List<Object>> insertDataList = new ArrayList<List<Object>>();
insertDataList.add(insertData.getDBData());
insertData(insertDataList);
}
-
+
public List<FileAccess> select() {
String query = String.format(SELECT_QUERY);
List<FileAccess> accessList = new ArrayList<FileAccess>();
-
- List<List<Object>> result = SqlConnectionManager.executeQuery(query);
- if (null == result || result.size() == 0 || result.get(0).size() == 0) {
- return accessList;
- }
-
- for (List<Object> data : result) {
- accessList.add(new FileAccess(data));
- }
+ accessList = executeQueryRS(query);
return accessList;
}
-
+
public static String selectAll() {
StringBuffer selectAllColumn = new StringBuffer();
- selectAllColumn.append(COLUMN.PID.getName());
- selectAllColumn.append(",");
- selectAllColumn.append(COLUMN.TID.getName());
- selectAllColumn.append(",");
- selectAllColumn.append(COLUMN.FILE_PATH.getName());
- selectAllColumn.append(",");
- selectAllColumn.append(COLUMN.FD.getName());
- selectAllColumn.append(",");
- selectAllColumn.append(COLUMN.API_TYPE.getName());
+ selectAllColumn.append(COLUMN.ACCESSOR_ID.name);
selectAllColumn.append(",");
- selectAllColumn.append(COLUMN.START_TIME.getName());
+ selectAllColumn.append(COLUMN.API_TYPE.name);
selectAllColumn.append(",");
- selectAllColumn.append(COLUMN.END_TIME.getName());
+ selectAllColumn.append(COLUMN.START_TIME.name);
selectAllColumn.append(",");
- selectAllColumn.append(COLUMN.ERRNO.getName());
+ selectAllColumn.append(COLUMN.END_TIME.name);
selectAllColumn.append(",");
- selectAllColumn.append(COLUMN.FILE_SIZE.getName());
+ selectAllColumn.append(COLUMN.TOOLTIP.name);
return selectAllColumn.toString();
}
isPrepared = false;
} else {
try {
- prep.setInt(1, (Integer)(rowData.get(COLUMN.PID.getValue())));
- prep.setInt(2, (Integer)(rowData.get(COLUMN.TID.getValue())));
- prep.setString(3, (String)(rowData.get(COLUMN.FILE_PATH.getValue())));
- prep.setLong(4, (Long)(rowData.get(COLUMN.FD.getValue())));
- prep.setInt(5, (Integer)(rowData.get(COLUMN.API_TYPE.getValue())));
- prep.setLong(6, (Long)(rowData.get(COLUMN.START_TIME.getValue())));
- prep.setLong(7, (Long)(rowData.get(COLUMN.END_TIME.getValue())));
- prep.setLong(8, (Long)(rowData.get(COLUMN.ERRNO.getValue())));
- prep.setLong(9, (Long)(rowData.get(COLUMN.FILE_SIZE.getValue())));
+ prep.setInt(1, (Integer)(rowData.get(0)));
+ prep.setInt(2, (Integer)(rowData.get(1)));
+ prep.setLong(3, (Long)(rowData.get(2)));
+ prep.setLong(4, (Long)(rowData.get(3)));
+ prep.setString(5, (String)(rowData.get(4)));
} catch (SQLException e) {
e.printStackTrace();
isPrepared = false;
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Hyeran Kim <Hyeran74.kim@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.file.data;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.tizen.dynamicanalyzer.database.DBColumn;
+import org.tizen.dynamicanalyzer.database.DBConstants;
+import org.tizen.dynamicanalyzer.database.DBTable;
+import org.tizen.dynamicanalyzer.database.SqlConnectionManager;
+import org.tizen.dynamicanalyzer.nl.FilePageLabels;
+import org.tizen.dynamicanalyzer.ui.file.model.FileAccessor;
+
+public class FileAccessorDB extends DBTable {
+ private static final String ACCESSOR_TABLE = FilePageLabels.FILE_ACCESSOR_DB;
+ private static final String DBTYPE_FILEPATH = "VARCHAR(4096)";//$NON-NLS-1$
+
+ public static enum COLUMN {
+ ACCESSOR_ID(1, "ACCESSOR_ID"),
+ FILE_ID(2, "FILE_ID"),
+ FILE_PATH(3, "FILE_PATH"),
+ PID(4, "PID"),
+ TID(5, "TID"),
+ IS_TARGET(6, "IS_TARGET");
+
+
+ private final int index;
+ private final String name;
+ private COLUMN(int index, String name) {
+ this.index = index;
+ this.name = name;
+ }
+
+ public int getIndex() {
+ return index;
+ }
+
+ public String getName() {
+ return name;
+ }
+ }
+
+ public FileAccessorDB() {
+ addColumn(new DBColumn(COLUMN.ACCESSOR_ID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.FILE_ID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.FILE_PATH.name, DBConstants.NOT_NULL, DBTYPE_FILEPATH));
+ addColumn(new DBColumn(COLUMN.PID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.TID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.IS_TARGET.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_BOOLEAN));
+ }
+
+
+ @Override
+ public String getTableName() {
+ return ACCESSOR_TABLE;
+ }
+
+ private static final String selectAll = selectAll();
+ private static final String SELECT_QUERY = "select "
+ + selectAll
+ + " from " + ACCESSOR_TABLE; //$NON-NLS-1$
+
+ public List<FileAccessor> executeQueryRS(String query) {
+ List<FileAccessor> resultData = new ArrayList<FileAccessor>();
+ ResultSet rs = SqlConnectionManager.executeQueryRS(query);
+ if (rs != null) {
+ try {
+ while (rs.next()) {
+ FileAccessor accessor = getDataFromResultSet(rs);
+ if (accessor != null) {
+ resultData.add(accessor);
+ }
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ } finally {
+ SqlConnectionManager.releaseResultSet(rs);
+ }
+ }
+ return resultData;
+ }
+
+ public FileAccessor getDataFromResultSet(ResultSet rs) {
+ FileAccessor accessor = null;
+ try {
+ accessor = new FileAccessor(
+ rs.getInt(COLUMN.ACCESSOR_ID.index),
+ rs.getInt(COLUMN.FILE_ID.index),
+ rs.getString(COLUMN.FILE_PATH.index),
+ rs.getInt(COLUMN.PID.index),
+ rs.getInt(COLUMN.TID.index),
+ rs.getBoolean(COLUMN.IS_TARGET.index)
+ );
+ } catch (SQLException e) {
+ e.printStackTrace();
+ return null;
+ }
+ return accessor;
+ }
+
+ public void insert(FileAccessor insertData) {
+ List<List<Object>> insertDataList = new ArrayList<List<Object>>();
+ insertDataList.add(insertData.getDBData());
+ insertData(insertDataList);
+ }
+
+ public List<FileAccessor> select() {
+ String query = String.format(SELECT_QUERY);
+
+ List<FileAccessor> accessorList = new ArrayList<FileAccessor>();
+ accessorList = executeQueryRS(query);
+ return accessorList;
+ }
+
+ public static String selectAll() {
+ StringBuffer selectAllColumn = new StringBuffer();
+ selectAllColumn.append(COLUMN.ACCESSOR_ID.name);
+ selectAllColumn.append(",");
+ selectAllColumn.append(COLUMN.FILE_ID.name);
+ selectAllColumn.append(",");
+ selectAllColumn.append(COLUMN.FILE_PATH.name);
+ selectAllColumn.append(",");
+ selectAllColumn.append(COLUMN.PID.name);
+ selectAllColumn.append(",");
+ selectAllColumn.append(COLUMN.TID.name);
+ selectAllColumn.append(",");
+ selectAllColumn.append(COLUMN.IS_TARGET.name);
+ return selectAllColumn.toString();
+ }
+
+ @Override
+ public boolean prepare(PreparedStatement prep, List<Object> rowData) {
+ boolean isPrepared = true;
+
+ int columnsize = getColumnSize();
+ if (columnsize != rowData.size()) {
+ isPrepared = false;
+ } else {
+ try {
+ prep.setInt(1, (Integer)(rowData.get(0)));
+ prep.setInt(2, (Integer)(rowData.get(1)));
+ prep.setString(3, (String)(rowData.get(2)));
+ prep.setLong(4, (Integer)(rowData.get(3)));
+ prep.setInt(5, (Integer)(rowData.get(4)));
+ prep.setBoolean(6, (Boolean)(rowData.get(5)));
+ } catch (SQLException e) {
+ e.printStackTrace();
+ isPrepared = false;
+ }
+ }
+ return isPrepared;
+ }
+}
package org.tizen.dynamicanalyzer.ui.file.data;
import java.sql.PreparedStatement;
+import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import org.tizen.dynamicanalyzer.database.SqlConnectionManager;
import org.tizen.dynamicanalyzer.nl.FilePageLabels;
import org.tizen.dynamicanalyzer.ui.file.model.FileEvent;
-import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants;
public class FileApiDB extends DBTable {
- private static final String TABLE_NAME = FilePageLabels.FILE_API_DB;
+ private static final String API_TABLE = FilePageLabels.FILE_API_DB;
+ private static final String ACCESSOR_TABLE = FilePageLabels.FILE_ACCESSOR_DB;
+ private static final String DBTYPE_RETUREN_VALUE = "VARCHAR(1024)";//$NON-NLS-1$
+ private static final String DBTYPE_ARGUMENTS_VALUE = "VARCHAR(1024)";//$NON-NLS-1$
public static enum COLUMN {
- SEQ(0, "seq"),
- FILE_PATH(1, "filePath"),
- PID(2, "pid"),
- TID(3, "tid"),
- FD(4, "fd"),
- API_TYPE(5, "apiType"),
- EVENT_TIME(6, "eventTime"),
- API_ID(7, "apiId"),
- ERRNO(8, "errNo"),
- IO_SIZE(9, "ioSize"),
- FILE_SIZE(10, "fileSize"),
- SIZE(11, "size"),
- RETURN_VALUE(12, "returnValue"),
- ARGS(13, "args"),
- TARGET(14, "target");
+ SEQUENCE_NUMBER(1, "SEQUENCE_NUMBER"),
+ FILE_ID(2, "FILE_ID"),
+ ACCESSOR_ID(3, "ACCESSOR_ID"),
+ FD(4, "FD"),
+ API_TYPE(5, "API_TYPE"),
+ EVENT_TIME(6, "EVENT_TIME"),
+ API_ID(7, "API_ID"),
+ ERRNO(8, "ERRNO"),
+ IO_SIZE(9, "IO_SIZE"),
+ FILE_SIZE(10, "FILE_SIZE"),
+ RETURN_VALUE(11, "RETURN_VALUE"),
+ ARGUMENTS_VALUE(12, "ARGUMENTS_VALUE");
- private final int value;
- private final String name;
+ public final int index;
+ public final String name;
- private COLUMN(int value, String name) {
- this.value = value;
+ private COLUMN(int index, String name) {
+ this.index = index;
this.name = name;
}
- public int getValue() {
- return value;
+ public int getIndex() {
+ return index;
}
public String getName() {
@Override
public String getTableName() {
- return TABLE_NAME;
+ return API_TABLE;
}
-
+
public FileApiDB() {
- addColumn(new DBColumn(COLUMN.SEQ.getName(), DBConstants.NOT_NULL, DBConstants.LONG));
- addColumn(new DBColumn(COLUMN.FILE_PATH.getName(), DBConstants.EMPTY, DBConstants.BIG_TEXT));
- addColumn(new DBColumn(COLUMN.PID.getName(), DBConstants.NOT_NULL, DBConstants.INTEGER));
- addColumn(new DBColumn(COLUMN.TID.getName(), DBConstants.NOT_NULL, DBConstants.INTEGER));
- addColumn(new DBColumn(COLUMN.FD.getName(), DBConstants.EMPTY, DBConstants.LONG));
- addColumn(new DBColumn(COLUMN.API_TYPE.getName(), DBConstants.NOT_NULL, DBConstants.INTEGER));
- addColumn(new DBColumn(COLUMN.EVENT_TIME.getName(), DBConstants.NOT_NULL, DBConstants.LONG));
- addColumn(new DBColumn(COLUMN.API_ID.getName(), DBConstants.EMPTY, DBConstants.INTEGER));
- addColumn(new DBColumn(COLUMN.ERRNO.getName(), DBConstants.EMPTY, DBConstants.LONG));
- addColumn(new DBColumn(COLUMN.IO_SIZE.getName(), DBConstants.EMPTY, DBConstants.LONG));
- addColumn(new DBColumn(COLUMN.FILE_SIZE.getName(), DBConstants.EMPTY, DBConstants.LONG));
- addColumn(new DBColumn(COLUMN.SIZE.getName(), DBConstants.EMPTY, DBConstants.LONG));
- addColumn(new DBColumn(COLUMN.RETURN_VALUE.getName(), DBConstants.EMPTY, DBConstants.BIG_TEXT));
- addColumn(new DBColumn(COLUMN.ARGS.getName(), DBConstants.EMPTY, DBConstants.BIG_TEXT));
- addColumn(new DBColumn(COLUMN.TARGET.getName(), DBConstants.NOT_NULL, DBConstants.BOOLEAN));
+ addColumn(new DBColumn(COLUMN.SEQUENCE_NUMBER.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.FILE_ID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.ACCESSOR_ID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.FD.name, DBConstants.EMPTY, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.API_TYPE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.EVENT_TIME.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.API_ID.name, DBConstants.EMPTY, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.ERRNO.name, DBConstants.EMPTY, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.IO_SIZE.name, DBConstants.EMPTY, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.FILE_SIZE.name, DBConstants.EMPTY, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.RETURN_VALUE.name, DBConstants.EMPTY, DBTYPE_RETUREN_VALUE));
+ addColumn(new DBColumn(COLUMN.ARGUMENTS_VALUE.name, DBConstants.EMPTY, DBTYPE_ARGUMENTS_VALUE));
}
private static final String selectAllColumn = selectAllColumn();
- private static final String SELECT_API_SERIES = "select "
- + selectAllColumn
- +" from "
- + TABLE_NAME + " where %s <= "
- + COLUMN.EVENT_TIME.getName() + " and "
- + COLUMN.EVENT_TIME.getName()
- + " <= %s";
-
- private static final String SELECT_FAILED_API_SERIES = "select "
- + selectAllColumn
- +" from "
- + TABLE_NAME + " where %s <= "
- + COLUMN.EVENT_TIME.getName() + " and "
- + COLUMN.EVENT_TIME.getName()
- + " <= %s" + " and "
- + COLUMN.ERRNO.getName() + " != '0'" + " and "
- + COLUMN.TARGET.getName() + " = 'true'";
-
- private static final String SELECT_APIS_FOR_CHILD = "select "
- + selectAllColumn
- +" from "
- + TABLE_NAME + " where "
- + COLUMN.FILE_PATH.getName() + " = '%s'" + " and "
- + COLUMN.PID.getName() + " = '%d'" + " and "
- + COLUMN.TID.getName() + " = '%d'" + " and "
- + COLUMN.TARGET.getName() + " = 'true'";
- private static final String SELECT_APIS_FOR_PARENT= "select "
- + selectAllColumn
- + " from "
- + TABLE_NAME + " where "
- + COLUMN.FILE_PATH.getName() + " = '%s'" + " and "
- + COLUMN.TARGET.getName() + " = 'true'";
+ private static final String SELECT_APIS_FOR_CHILD =
+ "select "
+ + "SEQUENCE_NUMBER, FD, API_TYPE, EVENT_TIME, API_ID, ERRNO, "
+ + "IO_SIZE, FILE_SIZE, RETURN_VALUE, ARGUMENTS_VALUE "
+ + "from " + API_TABLE
+ + " where "
+ + "ACCESSOR_ID" + " = '%d'";
+
+
+ private static final String SELECT_APIS_FOR_PARENT=
+ "select "
+ + "api.SEQUENCE_NUMBER, api.FD, api.API_TYPE, api.EVENT_TIME, api.API_ID, api.ERRNO, "
+ + "api.IO_SIZE, api.FILE_SIZE, api.RETURN_VALUE, api.ARGUMENTS_VALUE, "
+ + "accessor.FILE_PATH, accessor.PID, accessor.TID "
+ + "from " + API_TABLE + " api, " + ACCESSOR_TABLE + " accessor "
+ + "where "
+ + "api.FILE_ID" + " = '%d'"+ " and " + "api.ACCESSOR_ID = accessor.ACCESSOR_ID";
private static final String SELECT_FILE_EVENT_BY_SEQ = "select "
- //+ selectAllColumn
- + COLUMN.SEQ.getName() + " , "
- + COLUMN.FILE_PATH.getName() + " , "
- + COLUMN.PID.getName() + " , "
- + COLUMN.TID.getName()
- + " from "
- + TABLE_NAME + " where "
- + COLUMN.SEQ.getName() + " = '%d'"+ " and "
- + COLUMN.TARGET.getName() + " = 'true'";
+ + COLUMN.ACCESSOR_ID.name
+ + " from " + API_TABLE
+ + " where "
+ + COLUMN.SEQUENCE_NUMBER.name + " = '%d'";
+
+ private static final String SELECT_APIS_COUNT =
+ "select COUNT(*) from " + API_TABLE;
private static final String SELECT_ALL = "select "
+ selectAllColumn
+ " from "
- + TABLE_NAME + " where "
- + COLUMN.TARGET.getName() + " = 'true'";
+ + API_TABLE;
- public void insert(List<List<Object>> insertData) {
- insertData(insertData);
+ public ResultSet executeQuery(String query) {
+ ResultSet rs = SqlConnectionManager.executeQueryRS(query);
+ return rs;
}
- // for updating api series chart
- public List<FileEvent> selectAPISeries(double visibleStartTime,
- double visibleEndTime) {
- double selectStartTime = visibleStartTime * TimelineConstants.MEGA_DOUBLE;
- double selectEndTime = visibleEndTime * TimelineConstants.MEGA_DOUBLE;
-
- String query = String.format(SELECT_API_SERIES, selectStartTime, selectEndTime);
-
- List<List<Object>> result = SqlConnectionManager.executeQuery(query);
- if (null == result || result.size() == 0 || result.get(0).size() == 0) {
- return null;
- }
- List<FileEvent> apiList = new ArrayList<FileEvent>();
- for (List<Object> data : result) {
- apiList.add(new FileEvent(data));
+ public List<FileEvent> executeQueryRS(String query) {
+ List<FileEvent> resultData = new ArrayList<FileEvent>();
+ ResultSet rs = SqlConnectionManager.executeQueryRS(query);
+ if (rs != null) {
+ try {
+ while (rs.next()) {
+ FileEvent event= getDataFromResultSet(rs);
+ if (event != null) {
+ resultData.add(event);
+ }
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ } finally {
+ SqlConnectionManager.releaseResultSet(rs);
+ }
}
- return apiList;
+ return resultData;
}
- // for updating api series chart
- public List<FileEvent> selectFailedAPISeries(double visibleStartTime,
- double visibleEndTime) {
- double selectStartTime = visibleStartTime
- * TimelineConstants.MEGA_DOUBLE;
- double selectEndTime = visibleEndTime * TimelineConstants.MEGA_DOUBLE;
-
- String query = String.format(SELECT_FAILED_API_SERIES, selectStartTime,
- selectEndTime);
-
- List<List<Object>> result = SqlConnectionManager.executeQuery(query);
- if (null == result || result.size() == 0 || result.get(0).size() == 0) {
+ public FileEvent getDataFromResultSet(ResultSet rs) {
+ FileEvent event = null;
+ try {
+ event = new FileEvent(
+ rs.getLong(COLUMN.SEQUENCE_NUMBER.index),
+ rs.getInt(COLUMN.FILE_ID.index),
+ rs.getInt(COLUMN.ACCESSOR_ID.index),
+ rs.getLong(COLUMN.FD.index),
+ rs.getInt(COLUMN.API_TYPE.index),
+ rs.getInt(COLUMN.API_ID.index),
+ rs.getLong(COLUMN.EVENT_TIME.index),
+ rs.getLong(COLUMN.FILE_SIZE.index),
+ rs.getLong(COLUMN.IO_SIZE.index),
+ rs.getString(COLUMN.ARGUMENTS_VALUE.index),
+ rs.getString(COLUMN.RETURN_VALUE.index),
+ rs.getLong(COLUMN.ERRNO.index)
+ );
+ } catch (SQLException e) {
+ e.printStackTrace();
return null;
}
- List<FileEvent> apiList = new ArrayList<FileEvent>();
- for (List<Object> data : result) {
- apiList.add(new FileEvent(data));
- }
- return apiList;
+ return event;
}
-
- // for updating api table view
- public List<FileEvent> selectAPITable(String filePath, int pid, int tid,
+
+ public void insert(List<List<Object>> insertData) {
+ insertData(insertData);
+ }
+
+ // for updating api table view and detail view
+ public ResultSet selectAPI(int fileId, int accessorId,
boolean isParentChart) {
- String query = String.format(SELECT_APIS_FOR_CHILD, filePath, pid, tid);
+ String query = null;
if (isParentChart) {
- query = String
- .format(SELECT_APIS_FOR_PARENT, filePath);
- }
- List<List<Object>> result = SqlConnectionManager.executeQuery(query);
- if (null == result || result.size() == 0 || result.get(0).size() == 0) {
- return null;
+ query = String.format(SELECT_APIS_FOR_PARENT, fileId);
+ }else{
+ query = String.format(SELECT_APIS_FOR_CHILD, accessorId);
}
- List<FileEvent> apiList = new ArrayList<FileEvent>();
- for (List<Object> data : result) {
- apiList.add(new FileEvent(data));
- }
- return apiList;
+ return SqlConnectionManager.executeQueryRS(query);
}
-
- public FileEvent selectFileEventBySeq(long seq) {
+
+ // to get chart row index
+ public ResultSet selectFileEventBySeq(long seq) {
String query = String.format(SELECT_FILE_EVENT_BY_SEQ, seq);
- List<List<Object>> result = SqlConnectionManager.executeQuery(query);
- if (null == result || result.size() == 0 || result.get(0).size() == 0) {
- return null;
+
+ return SqlConnectionManager.executeQueryRS(query);
+ }
+
+ public int getTotal() {
+ String query = SELECT_APIS_COUNT;
+ ResultSet rs = SqlConnectionManager.executeQueryRS(query);
+ int totalCount = 0;
+ if (rs != null) {
+ try {
+ if (rs.next()) {
+ totalCount = rs.getInt(1);
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ } finally {
+ SqlConnectionManager.releaseResultSet(rs);
+ }
}
- List<Object> data = result.get(0);
- FileEvent fileEvent = new FileEvent(
- (Long) data.get(FileApiDB.COLUMN.SEQ.getValue()),
- (String) data.get(FileApiDB.COLUMN.FILE_PATH.getValue()),
- (Integer) data.get(FileApiDB.COLUMN.PID.getValue()),
- (Integer) data.get(FileApiDB.COLUMN.TID.getValue()));
- return fileEvent;
+ return totalCount;
}
public List<FileEvent> select() {
String query = String.format(SELECT_ALL);
-
- List<FileEvent> apiList = new ArrayList<FileEvent>();
-
- List<List<Object>> result = SqlConnectionManager.executeQuery(query);
- if (null == result || result.size() == 0 || result.get(0).size() == 0) {
- return apiList;
- }
-
- for (List<Object> data : result) {
- apiList.add(new FileEvent(data));
- }
+ List<FileEvent> apiList = executeQueryRS(query);
+
return apiList;
}
public static String selectAllColumn() {
StringBuffer selectAllColumn = new StringBuffer();
- selectAllColumn.append(COLUMN.SEQ.getName());
- selectAllColumn.append(",");
- selectAllColumn.append(COLUMN.FILE_PATH.getName());
- selectAllColumn.append(",");
- selectAllColumn.append(COLUMN.PID.getName());
- selectAllColumn.append(",");
- selectAllColumn.append(COLUMN.TID.getName());
+ selectAllColumn.append(COLUMN.SEQUENCE_NUMBER.name);
selectAllColumn.append(",");
- selectAllColumn.append(COLUMN.FD.getName());
+ selectAllColumn.append(COLUMN.FILE_ID.name);
selectAllColumn.append(",");
- selectAllColumn.append(COLUMN.API_TYPE.getName());
+ selectAllColumn.append(COLUMN.ACCESSOR_ID.name);
selectAllColumn.append(",");
- selectAllColumn.append(COLUMN.EVENT_TIME.getName());
+ selectAllColumn.append(COLUMN.FD.name);
selectAllColumn.append(",");
- selectAllColumn.append(COLUMN.API_ID.getName());
+ selectAllColumn.append(COLUMN.API_TYPE.name);
selectAllColumn.append(",");
- selectAllColumn.append(COLUMN.ERRNO.getName());
+ selectAllColumn.append(COLUMN.EVENT_TIME.name);
selectAllColumn.append(",");
- selectAllColumn.append(COLUMN.IO_SIZE.getName());
+ selectAllColumn.append(COLUMN.API_ID.name);
selectAllColumn.append(",");
- selectAllColumn.append(COLUMN.FILE_SIZE.getName());
+ selectAllColumn.append(COLUMN.ERRNO.name);
selectAllColumn.append(",");
- selectAllColumn.append(COLUMN.SIZE.getName());
+ selectAllColumn.append(COLUMN.IO_SIZE.name);
selectAllColumn.append(",");
- selectAllColumn.append(COLUMN.RETURN_VALUE.getName());
+ selectAllColumn.append(COLUMN.FILE_SIZE.name);
selectAllColumn.append(",");
- selectAllColumn.append(COLUMN.ARGS.getName());
+ selectAllColumn.append(COLUMN.RETURN_VALUE.name);
selectAllColumn.append(",");
- selectAllColumn.append(COLUMN.TARGET.getName());
+ selectAllColumn.append(COLUMN.ARGUMENTS_VALUE.name);
return selectAllColumn.toString();
}
isPrepared = false;
} else {
try {
- prep.setLong(1, (Long)(rowData.get(COLUMN.SEQ.getValue())));
- prep.setString(2, (String)(rowData.get(COLUMN.FILE_PATH.getValue())));
- prep.setInt(3, (Integer)(rowData.get(COLUMN.PID.getValue())));
- prep.setInt(4, (Integer)(rowData.get(COLUMN.TID.getValue())));
- prep.setLong(5, (Long)(rowData.get(COLUMN.FD.getValue())));
- prep.setInt(6, (Integer)(rowData.get(COLUMN.API_TYPE.getValue())));
- prep.setLong(7, (Long)(rowData.get(COLUMN.EVENT_TIME.getValue())));
- prep.setInt(8, (Integer)(rowData.get(COLUMN.API_ID.getValue())));
- prep.setLong(9, (Long)(rowData.get(COLUMN.ERRNO.getValue())));
- prep.setLong(10, (Long)(rowData.get(COLUMN.IO_SIZE.getValue())));
- prep.setLong(11, (Long)(rowData.get(COLUMN.FILE_SIZE.getValue())));
- prep.setLong(12, (Long)(rowData.get(COLUMN.SIZE.getValue())));
- prep.setString(13, (String)(rowData.get(COLUMN.RETURN_VALUE.getValue())));
- prep.setString(14, (String)(rowData.get(COLUMN.ARGS.getValue())));
- prep.setBoolean(15, (Boolean)(rowData.get(COLUMN.TARGET.getValue())));
+ prep.setLong(1, (Long)(rowData.get(0)));
+ prep.setInt(2, (Integer)(rowData.get(1)));
+ prep.setInt(3, (Integer)(rowData.get(2)));
+ prep.setLong(4, (Long)(rowData.get(3)));
+ prep.setInt(5, (Integer)(rowData.get(4)));
+ prep.setLong(6, (Long)(rowData.get(5)));
+ prep.setInt(7, (Integer)(rowData.get(6)));
+ prep.setLong(8, (Long)(rowData.get(7)));
+ prep.setLong(9, (Long)(rowData.get(8)));
+ prep.setLong(10, (Long)(rowData.get(9)));
+ prep.setString(11, (String)(rowData.get(10)));
+ prep.setString(12, (String)(rowData.get(11)));
} catch (SQLException e) {
e.printStackTrace();
isPrepared = false;
package org.tizen.dynamicanalyzer.ui.file.data;
import java.sql.PreparedStatement;
+import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
// open, close
public class FileStatusDB extends DBTable {
- private static final String TABLE_NAME = FilePageLabels.FILE_STATUS_DB;
+ private static final String STATUS_TABLE = FilePageLabels.FILE_STATUS_DB;
public static enum COLUMN {
- PID(0, "pid"),
- TID(1, "tid"),
- FILE_PATH(2, "filePath"),
- FD(3, "FD"),
- API_TYPE(4, "apiType"),
- EVENT_TIME(5, "eventTime"),
- ERRNO(6, "errNo");
+ FILE_ID(1, "FILE_ID"),
+ API_TYPE(2, "API_TYPE"),
+ EVENT_TIME(3, "EVENT_TIME");
- private final int value;
+ private final int index;
private final String name;
- private COLUMN(int value, String name) {
- this.value = value;
+ private COLUMN(int index, String name) {
+ this.index = index;
this.name = name;
}
- public int getValue() {
- return value;
+ public int getIndex() {
+ return index;
}
public String getName() {
}
public FileStatusDB() {
- addColumn(new DBColumn(COLUMN.PID.getName(), DBConstants.NOT_NULL, DBConstants.INTEGER));
- addColumn(new DBColumn(COLUMN.TID.getName(), DBConstants.NOT_NULL, DBConstants.INTEGER));
- addColumn(new DBColumn(COLUMN.FILE_PATH.getName(), DBConstants.NOT_NULL, DBConstants.BIG_TEXT));
- addColumn(new DBColumn(COLUMN.FD.getName(), DBConstants.EMPTY, DBConstants.LONG));
- addColumn(new DBColumn(COLUMN.API_TYPE.getName(), DBConstants.NOT_NULL, DBConstants.INTEGER));
- addColumn(new DBColumn(COLUMN.EVENT_TIME.getName(), DBConstants.NOT_NULL, DBConstants.LONG));
- addColumn(new DBColumn(COLUMN.ERRNO.getName(), DBConstants.NOT_NULL, DBConstants.LONG));
+ addColumn(new DBColumn(COLUMN.FILE_ID.name, DBConstants.NOT_NULL, DBConstants.INTEGER));
+ addColumn(new DBColumn(COLUMN.API_TYPE.name, DBConstants.NOT_NULL, DBConstants.INTEGER));
+ addColumn(new DBColumn(COLUMN.EVENT_TIME.name, DBConstants.NOT_NULL, DBConstants.LONG));
}
@Override
public String getTableName() {
- return TABLE_NAME;
+ return STATUS_TABLE;
}
private static final String selectAll = selectAll();
private static final String SELECT_QUERY = "select "
+ selectAll
- + " from " + TABLE_NAME; //$NON-NLS-1$
+ + " from " + STATUS_TABLE; //$NON-NLS-1$
+
+ public List<FileStatus> executeQueryRS(String query) {
+ List<FileStatus> resultData = new ArrayList<FileStatus>();
+ ResultSet rs = SqlConnectionManager.executeQueryRS(query);
+ if (rs != null) {
+ try {
+ while (rs.next()) {
+ FileStatus status= getDataFromResultSet(rs);
+ if (status != null) {
+ resultData.add(status);
+ }
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ } finally {
+ SqlConnectionManager.releaseResultSet(rs);
+ }
+ }
+ return resultData;
+ }
+
+ public FileStatus getDataFromResultSet(ResultSet rs) {
+ FileStatus status = null;
+ try {
+ status = new FileStatus(
+ rs.getInt(COLUMN.FILE_ID.index),
+ rs.getInt(COLUMN.API_TYPE.index),
+ rs.getLong(COLUMN.EVENT_TIME.index)
+ );
+ } catch (SQLException e) {
+ e.printStackTrace();
+ return null;
+ }
+ return status;
+ }
public void insert(FileStatus insertData) {
List<List<Object>> insertDataList = new ArrayList<List<Object>>();
String query = String.format(SELECT_QUERY);
List<FileStatus> statusList = new ArrayList<FileStatus>();
-
- List<List<Object>> result = SqlConnectionManager.executeQuery(query);
- if (null == result || result.size() == 0 || result.get(0).size() == 0) {
- return statusList;
- }
-
- for (List<Object> data : result) {
- statusList.add(new FileStatus(data));
- }
+ statusList = executeQueryRS(query);
return statusList;
}
public static String selectAll() {
StringBuffer selectAllColumn = new StringBuffer();
- selectAllColumn.append(COLUMN.PID.getName());
- selectAllColumn.append(",");
- selectAllColumn.append(COLUMN.TID.getName());
- selectAllColumn.append(",");
- selectAllColumn.append(COLUMN.FILE_PATH.getName());
- selectAllColumn.append(",");
- selectAllColumn.append(COLUMN.FD.getName());
- selectAllColumn.append(",");
- selectAllColumn.append(COLUMN.API_TYPE.getName());
+ selectAllColumn.append(COLUMN.FILE_ID.name);
selectAllColumn.append(",");
- selectAllColumn.append(COLUMN.EVENT_TIME.getName());
+ selectAllColumn.append(COLUMN.API_TYPE.name);
selectAllColumn.append(",");
- selectAllColumn.append(COLUMN.ERRNO.getName());
+ selectAllColumn.append(COLUMN.EVENT_TIME.name);
return selectAllColumn.toString();
}
isPrepared = false;
} else {
try {
- prep.setInt(1, (Integer)(rowData.get(COLUMN.PID.getValue())));
- prep.setInt(2, (Integer)(rowData.get(COLUMN.TID.getValue())));
- prep.setString(3, (String)(rowData.get(COLUMN.FILE_PATH.getValue())));
- prep.setLong(4, (Long)(rowData.get(COLUMN.FD.getValue())));
- prep.setInt(5, (Integer)(rowData.get(COLUMN.API_TYPE.getValue())));
- prep.setLong(6, (Long)(rowData.get(COLUMN.EVENT_TIME.getValue())));
- prep.setLong(7, (Long)(rowData.get(COLUMN.ERRNO.getValue())));
+ prep.setInt(1, (Integer)(rowData.get(0)));
+ prep.setInt(2, (Integer)(rowData.get(1)));
+ prep.setLong(3, (Long)(rowData.get(2)));
} catch (SQLException e) {
e.printStackTrace();
isPrepared = false;
package org.tizen.dynamicanalyzer.ui.file.manager;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.HashMap;
+import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Queue;
+import java.util.Set;
import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.atomic.AtomicInteger;
-import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.DALimit;
import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.swap.model.data.LogData;
import org.tizen.dynamicanalyzer.swap.model.data.ProfileData;
import org.tizen.dynamicanalyzer.ui.file.model.FileAccess;
+import org.tizen.dynamicanalyzer.ui.file.model.FileAccessor;
import org.tizen.dynamicanalyzer.ui.file.model.FileEvent;
import org.tizen.dynamicanalyzer.ui.file.model.FileStatus;
import org.tizen.dynamicanalyzer.ui.summary.SummaryDataManager;
private List<FileStatus> fileStatusList = new ArrayList<FileStatus>();
private List<FileAccess> fileAccessList = new ArrayList<FileAccess>();
private List<FileEvent> fileApiList = new ArrayList<FileEvent>();
-
-
- // to find file path, (key(PID, TID, FD), value (file_path))
- private Map<String, String> fileAccessorMap = new HashMap<String, String>();
-
- // temporary, file log list for 1second
- private Queue<List<FileEvent>> fileLogsQueue = new ConcurrentLinkedQueue<List<FileEvent>>();
-
- // (key(file path), value (read_count or write_count))
- private Map<String, Integer> concurrentAccessNumMap = new HashMap<String, Integer>();
- private Map<String, Integer> lockNumMap = new HashMap<String, Integer>();
+ private List<FileAccessor> fileAccessorList = new ArrayList<FileAccessor>();
- // for filtering out non-target file from syscall messages
- List<String> accessedFilePathList = new ArrayList<String>();
+ private Map<Long, FileEvent> entryMap = new HashMap<Long, FileEvent>(); // to match entry and exit message
+ private Map<String, List<Object>> fileAccessorMap= new HashMap<String, List<Object>>();
+ private Map<String, List<Object>> filePathMap= new HashMap<String, List<Object>>(); // to find file path
+ private Queue<List<FileAccessor>> fileAccessorQueue = new ConcurrentLinkedQueue<List<FileAccessor>>();
+ private Map<List<Integer>, List<Integer>> accessorHasLockMap = new HashMap<List<Integer>, List<Integer>>(); //to auto release
+ private Map<String, Integer> concurrentAccessNumMap = new HashMap<String, Integer>(); // to check concurrent access
- // temporary, to check if open event has been sent before the event has been sent
- private Map<String, FileEvent> sysCallMap = new HashMap<String, FileEvent>();
- // for searching entry message from exit message
- Map<Long, FileEvent> entryMap = new HashMap<Long, FileEvent>();
+ AtomicInteger idGenerator = new AtomicInteger();
public FileDataMaker() {}
public void clear(){
fileStatusList.clear();
fileAccessList.clear();
+ fileApiList.clear();
+ fileAccessorList.clear();
fileAccessorMap.clear();
- fileLogsQueue.clear();
+ fileAccessorQueue.clear();
+ filePathMap.clear();
+ accessorHasLockMap.clear();
concurrentAccessNumMap.clear();
- lockNumMap.clear();
- sysCallMap.clear();
- accessedFilePathList.clear();
entryMap.clear();
}
*/
List<FileEvent> fileEventList = new ArrayList<FileEvent>();
+ List<FileAccessor> fileAccessorList = new ArrayList<FileAccessor>();
// 1. In case of target process that the user is interested to analyze
ArrayList<List<Object>> fileApiList = new ArrayList<List<Object>>();
}
// filtering out print log and main func log
- // TODO: DISCUSSION: checkInvalidApiName: make the SWAP not send
- // TODO: DISCUSSION: isOpenMainLog: why osp main?
if (checkInvalidApiName(input) || isOpenMainLog(input)) {
continue;
}
input.getArgs(), input.getReturn(), input.getErrno(),
true);
- switch(input.getFdApiType()) {
- case LogCenterConstants.FD_API_TYPE_OPEN:
- accessedFilePathList.add(input.getFilePath());
- break;
- case LogCenterConstants.FD_API_TYPE_LOCK_START:
- case LogCenterConstants.FD_API_TYPE_LOCK_END:
- String args = input.getArgs();
- String[] splitPath = args.split(",\\s+");
- event.setLockType(Integer.parseInt(splitPath[1]));
- break;
- }
addFileEvent(fileEventList, event, input);
}
}
if (syscallLogs != null) {
ProfileData profileData = null;
FileEvent event = null;
+ FileEvent fakeOpenEvent = null;
String filePath = null;
long fd = 0;
String[] splitPath = args.split(",\\s+");
filePath = splitPath[0];
fd = Long.parseLong(splitPath[1]);
- FileEvent openEvent = null;
+
+ event = new FileEvent(seq, pid, tid, fd, filePath, eventType, time, 0, false);
+ fakeOpenEvent = new FileEvent(0, pid, tid, fd, filePath,
+ LogCenterConstants.FD_API_TYPE_OPEN, time, 0, false);
- // filtering out non-target files that user in not interested
- if(accessedFilePathList.contains(filePath)) {
- // target file
+ //fileAccessorMap: to filter out non-target files that user in not interested
+ //filePathMap: to check if the open event is exist
+ if(fileAccessorMap.containsKey(filePath)) {
Logger.debug(">> syscall:seq:" + seq + ", pid:" + pid
+ ", tid:" + tid + ", type:" + eventType + ", args:" + args);
if(fd == -1) {
event.setErrNo(-1);
}
+
+ String key = createKey(pid, tid, fd);
switch(eventType) {
case LogCenterConstants.FD_API_TYPE_OPEN:
- sysCallMap.put(filePath, event);
+ addFilePathInfo(key, filePath, -1, -1);
addFileEvent(fileEventList, event, null);
break;
case LogCenterConstants.FD_API_TYPE_CLOSE:
- openEvent = sysCallMap.get(filePath);
- if(openEvent != null) {
+ if(filePathMap.containsKey(key)) {
addFileEvent(fileEventList, event, null);
+ removeFilePathInfo(key);
}
break;
case LogCenterConstants.FD_API_TYPE_LOCK_START:
- openEvent = sysCallMap.get(filePath);
- if(openEvent == null) {
- // make fake open event
- FileEvent fakeOpenEvent = new FileEvent(0, pid,
- tid, fd, filePath,
- LogCenterConstants.FD_API_TYPE_OPEN,
- time, 0, false);
+ if(!filePathMap.containsKey(key)){
addFileEvent(fileEventList, fakeOpenEvent, null);
+ addFilePathInfo(key, filePath, -1, -1);
}
entryMap.put(seq, event);
- event.setLockType(Integer.parseInt(splitPath[2]));
addFileEvent(fileEventList, event, null);
break;
case LogCenterConstants.FD_API_TYPE_UNLOCK:
- openEvent = sysCallMap.get(filePath);
- if(openEvent == null) {
- // make fake open event
- FileEvent fakeOpenEvent = new FileEvent(0, pid,
- tid, fd, filePath,
- LogCenterConstants.FD_API_TYPE_OPEN,
- time, 0, false);
+ if(!filePathMap.containsKey(key)){
addFileEvent(fileEventList, fakeOpenEvent, null);
+ addFilePathInfo(key, filePath, -1, -1);
}
- entryMap.put(seq, event);
break;
case LogCenterConstants.FD_API_TYPE_READ_START:
case LogCenterConstants.FD_API_TYPE_WRITE_START:
- openEvent = sysCallMap.get(filePath);
- if(openEvent == null) {
- // make fake open event
- FileEvent fakeOpenEvent = new FileEvent(0, pid,
- tid, fd, filePath,
- LogCenterConstants.FD_API_TYPE_OPEN,
- time, 0, false);
+ if(!filePathMap.containsKey(key)){
addFileEvent(fileEventList, fakeOpenEvent, null);
+ addFilePathInfo(key, filePath, -1, -1);
}
entryMap.put(seq, event);
addFileEvent(fileEventList, event, null);
}// else, non-target file
break;
case DataChannelConstants.MSG_FUNCTION_EXIT:
- // for creating read/write end event with MSG_FUNCTION_EXIT
+ // for creating read/write/lock end event with MSG_FUNCTION_EXIT
long entrySeq = profileData.getEntrySeq();
+ String ret = profileData.getReturn();
if(entryMap.containsKey(entrySeq)) {
- Logger.debug(">> syscall entrySeq:" + + entrySeq + "endseq:" + seq + ", pid:" + pid
- + ", tid:" + tid + ", type:" + eventType);
event = entryMap.get(entrySeq);
if(Long.parseLong(profileData.getReturn()) == -1) {
event.setErrNo(-1);
switch(eventType) {
case LogCenterConstants.FD_API_TYPE_READ_START:
event.setFdApiType(LogCenterConstants.FD_API_TYPE_READ_END);
+ event.setTime(time);
addFileEvent(fileEventList, event, null);
break;
case LogCenterConstants.FD_API_TYPE_WRITE_START:
event.setFdApiType(LogCenterConstants.FD_API_TYPE_WRITE_END);
+ event.setTime(time);
addFileEvent(fileEventList, event, null);
break;
case LogCenterConstants.FD_API_TYPE_LOCK_START:
event.setFdApiType(LogCenterConstants.FD_API_TYPE_LOCK_END);
+ event.setTime(time);
addFileEvent(fileEventList, event, null);
break;
case LogCenterConstants.FD_API_TYPE_UNLOCK:
event.setFdApiType(LogCenterConstants.FD_API_TYPE_UNLOCK);
event.setTime(time);
addFileEvent(fileEventList, event, null);
+ break;
default:
break;
}
for(FileEvent data : fileEventList) {
fileApiList.add(data.getDBData());
}
- fileLogsQueue.add(fileEventList);
FileDataManager.getInstance().getApiDB().insert((List<List<Object>>)fileApiList);
}
+
+ Set<String> kyeSet = fileAccessorMap.keySet();
+ for (Iterator<String> iterator = kyeSet.iterator(); iterator.hasNext();) {
+ String key = (String) iterator.next();
+ List<Object> values= fileAccessorMap.get(key);
+ Object[] list = values.toArray();
+ List<FileAccessor> accessor = (ArrayList<FileAccessor>)list[1];
+ fileAccessorList.addAll(accessor);
+ }
+ fileAccessorQueue.add(fileAccessorList);
}
/**
String key = null;
Logger.debug("pid:" + pid + " tid:" +tid + " apiType:" + apiType);
+
if(isTarget) {
key = createKey(pid, tid, fd);
if(fd == -1) {
- // set the unknown file if the file open or close has been failed
- event.setFilePath(FilePageLabels.FILE_CHART_UNKNOWN_FILE);
- } else if(filePath == null || filePath.equals("")) {
- // set the file path to all normal file event that open and close was succeed
- filePath = getFilePath(key);
+ filePath = FilePageLabels.FILE_CHART_UNKNOWN_FILE;
+ int[] fileInfo = addFileAccessor(filePath, pid, tid, isTarget);
+ event.setFileId(fileInfo[0]);
+ event.setAccessorId(fileInfo[1]);
+ event.setFilePath(filePath);
+ }else if(filePath == null || filePath.equals("")) {
+ // get file path except open event
+ Object[] fileInfo = getFilePathInfo(key);
+ filePath = (String)fileInfo[0];
event.setFilePath(filePath);
+ event.setFileId((Integer)fileInfo[1]);
+ event.setAccessorId((Integer)fileInfo[2]);
}
+ }else{
+ int[] fileInfo = addFileAccessor(filePath, pid, tid, isTarget);
+ event.setFileId(fileInfo[0]);
+ event.setAccessorId(fileInfo[1]);
}
switch (apiType) {
case LogCenterConstants.FD_API_TYPE_OPEN:
- if(isTarget && errNo == 0) {
- addFileAccessor(key, filePath);
+ if (isTarget) {
+ int[] fileInfo = addFileAccessor(filePath, pid, tid, isTarget);
+ event.setFileId(fileInfo[0]);
+ event.setAccessorId(fileInfo[1]);
+ addFilePathInfo(key, filePath, fileInfo[0], fileInfo[1]);
+ }
+ if (errNo == 0) {
+ addStatusData(new FileStatus(event.getFileId(), apiType, eventTime));
}
- addStatusData(new FileStatus(pid, tid, fd, filePath,
- apiType, eventTime, errNo));
break;
case LogCenterConstants.FD_API_TYPE_CLOSE:
- if(isTarget && errNo == 0) {
- removeFileAccessor(key);
- }
- addStatusData(new FileStatus(pid, tid, fd, filePath,
- apiType, eventTime, errNo));
- // if it remains lock without lock release
- if(getCurrentLockNum(filePath) > 0) {
- removeLockNum(filePath);
- addEndAccessData(pid, tid, fd, filePath, eventTime, size,
- LogCenterConstants.FD_API_TYPE_LOCK_START, errNo);
+ if(errNo == 0) {
+ if(isTarget) {
+ removeFilePathInfo(key);
+ }
+ addStatusData(new FileStatus(event.getFileId(), apiType, eventTime));
+ List<Integer> accessorIds = getTidsHasLock(event.getFileId(), pid);
+ if(accessorIds != null) {
+ // lock auto release
+ for(Integer accessor : accessorIds){
+ FileAccess access = new FileAccess(accessor,
+ LogCenterConstants.FD_API_TYPE_LOCK_AUTORELEASE,
+ eventTime, eventTime, FilePageLabels.FILE_CHART_TOOLTIP_LOCK_AUTORELEASE);
+ addAccessData(access);
+ }
+ removeTidsHasLock(event.getFileId(), pid);
+ }
}
break;
case LogCenterConstants.FD_API_TYPE_READ_START:
- FileAccess readAccess = new FileAccess(filePath, pid,
- tid, fd, apiType, eventTime);
+ FileAccess readAccess = new FileAccess(event.getAccessorId(), fd, apiType,
+ eventTime, FilePageLabels.FILE_CHART_TOOLTIP_READ);
if(checkConcurrentAccess(filePath)) {
readAccess.setWarning();
+ readAccess.setTooltip(FilePageLabels.FILE_CHART_TOOLTIP_CONCURRENT_READ);
if(logData != null) {
SummaryDataManager.getInstance().getWarningDataMaker().add(
logData,
addStartAccessData(readAccess);
break;
case LogCenterConstants.FD_API_TYPE_READ_END:
- addEndAccessData(pid, tid, fd, filePath, eventTime,
- size, LogCenterConstants.FD_API_TYPE_READ_START, errNo);
+ addEndAccessData(event.getAccessorId(), fd, eventTime,
+ size, LogCenterConstants.FD_API_TYPE_READ_START, errNo);
removeConcurrentAccess(filePath);
break;
case LogCenterConstants.FD_API_TYPE_WRITE_START:
- FileAccess writeAccess = new FileAccess(filePath, pid,
- tid, fd, apiType, eventTime);
+ FileAccess writeAccess = new FileAccess(event.getAccessorId(), fd, apiType,
+ eventTime, FilePageLabels.FILE_CHART_TOOLTIP_WRITE);
if(checkConcurrentAccess(filePath)) {
writeAccess.setWarning();
+ writeAccess.setTooltip(FilePageLabels.FILE_CHART_TOOLTIP_CONCURRENT_WRITE);
if(logData != null) {
SummaryDataManager.getInstance().getWarningDataMaker().add(
logData,
addStartAccessData(writeAccess);
break;
case LogCenterConstants.FD_API_TYPE_WRITE_END:
- addEndAccessData(pid, tid, fd, filePath, eventTime,
+ addEndAccessData(event.getAccessorId(), fd, eventTime,
size, LogCenterConstants.FD_API_TYPE_WRITE_START, errNo);
removeConcurrentAccess(filePath);
break;
case LogCenterConstants.FD_API_TYPE_LOCK_START:
- if(event.getLockType() == AnalyzerConstants.F_SETLKW) {// F_SETLKW
- addStartAccessData(new FileAccess(filePath, pid, tid, fd,
- LogCenterConstants.FD_API_TYPE_LOCK_WAIT_START, eventTime));
- }else{
- addStartAccessData(new FileAccess(filePath, pid, tid, fd,
- LogCenterConstants.FD_API_TYPE_LOCK_START, eventTime));
- }
- addCurrentLock(filePath);
+ addStartAccessData(new FileAccess(event.getAccessorId(), fd, apiType,
+ eventTime, FilePageLabels.FILE_CHART_TOOLTIP_LOCK));
break;
case LogCenterConstants.FD_API_TYPE_LOCK_END:
- if(event.getLockType() == AnalyzerConstants.F_SETLKW) {// F_SETLKW
- addEndAccessData(pid, tid, fd, filePath, eventTime,
- size, LogCenterConstants.FD_API_TYPE_LOCK_WAIT_START, errNo);
- addStartAccessData(new FileAccess(filePath, pid, tid, fd,
- LogCenterConstants.FD_API_TYPE_LOCK_START, eventTime));
- }
+ addEndAccessData(event.getAccessorId(), fd, eventTime, size,
+ LogCenterConstants.FD_API_TYPE_LOCK_START, errNo);
+ addFileLock(event.getFileId(), pid, event.getAccessorId());
break;
case LogCenterConstants.FD_API_TYPE_UNLOCK:
- removeLockNum(filePath);
- addEndAccessData(pid, tid, fd, filePath, eventTime,
- size, LogCenterConstants.FD_API_TYPE_LOCK_START, errNo);
+ addAccessData(new FileAccess(event.getAccessorId(), apiType,
+ eventTime, eventTime, FilePageLabels.FILE_CHART_TOOLTIP_UNLOCK));
break;
default:
break;
}
- fileEventList.add(event);
+
+ // file access fail
+ if (errNo != 0) {
+ String tooltip = FilePageLabels.FILE_CHART_TOOLTIP_FAIL + " "
+ + Global.getFunctionName(event.getApiId());
+ FileAccess accessFail = new FileAccess(event.getAccessorId(),
+ LogCenterConstants.FD_API_TYPE_FAIL, eventTime, eventTime,
+ tooltip);
+ addAccessData(accessFail);
+ }
+
+ if(event.isTarget()) {
+ fileEventList.add(event);
+ }
}
public void addStatusData(FileStatus data) {
public void addStartAccessData(FileAccess data) {
fileAccessList.add(data);
}
-
+
+ public void addAccessData(FileAccess data) {
+ fileAccessList.add(data);
+ FileDataManager.getInstance().getAccessDB().insert(data);
+ }
+
// in case of file read/write/lock probe/system call
- public void addEndAccessData(int pid, int tid, long fd, String filePath,
- long endTime, long fileSize, int apiType, long errNo) {
+ public void addEndAccessData(int accessorId, long fd, long endTime,
+ long ioSize, int apiType, long errNo) {
for (int i = 0; i < fileAccessList.size(); i++) {
FileAccess data = fileAccessList.get(i);
- if (data.getPid() == pid
- && data.getTid() == tid
+ if (data.getAccessorId() == accessorId
&& data.getFd() == fd
&& data.getApiType() == apiType
&& data.getEndTime() <= 0){
- data.setEndTime(endTime);
- data.setFileSize(fileSize);
- data.setErroNo(errNo);
- FileDataManager.getInstance().getAccessDB().insert(data);
+ if(errNo!=0) {
+ fileAccessList.remove(i);
+ }else{
+ data.setEndTime(endTime);
+ if(apiType == LogCenterConstants.FD_API_TYPE_WRITE_START
+ || apiType == LogCenterConstants.FD_API_TYPE_READ_START){
+ String tooltip = data.getTooltip() + " , " + String.valueOf(ioSize);
+ data.setTooltip(tooltip);
+ }
+ FileDataManager.getInstance().getAccessDB().insert(data);
+ }
break;
}
}
// when failed search start time, dump endEvent.
}
- public List<FileEvent> getFileEventList() {
- return fileLogsQueue.poll();
- }
-
- public List<FileAccess> getFileAccessList() {
- return fileAccessList;
- }
-
- public List<FileStatus> getFileStatusList() {
- return fileStatusList;
- }
-
- public List<FileEvent> getFileApiList() {
- return fileApiList;
- }
-
private String createKey(int pid, int tid, long fd) {
StringBuffer key = new StringBuffer();
key.append(pid);
return key.toString();
}
- // for the open log: probe only
- private void addFileAccessor(String key, String filePath) {
- if(!fileAccessorMap.containsKey(key)) {
- fileAccessorMap.put(key, filePath);
- } else {
- Logger.error(" addFileAccessor:" + key + "is aleady exist" );
- }
- }
-
- // for the close log: probe only
- private void removeFileAccessor(String key) {
- if(fileAccessorMap.containsKey(key)) {
- fileAccessorMap.remove(key);
- }else {
- Logger.error(" removeFileAccessor:" + key + "is not exist" );
- }
- }
-
- private String getFilePath(String key) {
- String filePath = null;
- if(fileAccessorMap.containsKey(key)) {
- filePath = fileAccessorMap.get(key);
- }else{
- Logger.error("The key is not exist : " + key);
- }
- return filePath;
- }
-
/**
* Check if it is concurrent access
* @param concurrentKey
int num = 0;
if(concurrentAccessNumMap.containsKey(concurrentKey)) {
num = concurrentAccessNumMap.get(concurrentKey);
+ }else{
+ concurrentAccessNumMap.put(concurrentKey, 1);
}
- concurrentAccessNumMap.put(concurrentKey, num+1);
if(num > 0) {
return true;
}else {
}
}
- private int addCurrentLock(String lockKey) {
- int num = 0;
- if(lockNumMap.containsKey(lockKey)) {
- num = lockNumMap.get(lockKey);
- lockNumMap.put(lockKey, num+1);
+ /**
+ * Add a new file accessor
+ * @param filePath
+ * @param pid
+ * @param tid
+ * @return fileId
+ */
+ private int[] addFileAccessor(String filePath, int pid, int tid, boolean isTarget) {
+ int fileId = -1;
+ int accessorId = -1;
+ if(fileAccessorMap.containsKey(filePath)) {
+ List<Object> set = fileAccessorMap.get(filePath);
+ Object[] list = set.toArray();
+ fileId = (Integer) list[0];
+ List<FileAccessor> accessorList = (ArrayList<FileAccessor>) list[1];
+ boolean isExistAccessor = false;
+ for(FileAccessor accessor : accessorList) {
+ if(pid == accessor.getPid() && tid == accessor.getTid()) {
+ accessorId = accessor.getAccessorId();
+ isExistAccessor = true;
+ break;
+ }
+ }
+ if(!isExistAccessor){
+ // add a new file accessor
+ accessorId = idGenerator.incrementAndGet();
+ FileAccessor newAccessor = new FileAccessor(
+ accessorId, fileId, filePath, pid, tid, isTarget);
+ accessorList.add(newAccessor);
+ set.add(fileId);
+ set.add(accessorList);
+ fileAccessorMap.put(filePath, set);
+ FileDataManager.getInstance().getAccessorDB().insert(newAccessor);
+ }
+ }else{
+ fileId = fileAccessorMap.size()+1;
+ accessorId = idGenerator.incrementAndGet();
+ List<FileAccessor> accessorList = new ArrayList<FileAccessor>();
+ FileAccessor newAccessor = new FileAccessor(accessorId,
+ fileId, filePath, pid, tid, isTarget);
+ accessorList.add(newAccessor);
+ List<Object> set = new ArrayList<Object>();
+ set.add(fileId);
+ set.add(accessorList);
+ fileAccessorMap.put(filePath, set);
+ FileDataManager.getInstance().getAccessorDB().insert(newAccessor);
}
- lockNumMap.put(lockKey, num+1);
- return num;
+ return new int[]{fileId, accessorId};
}
- private int getCurrentLockNum(String lockKey) {
- int num = 0;
- if(lockNumMap.containsKey(lockKey)) {
- num = lockNumMap.get(lockKey);
+
+ /**
+ * Get file path
+ * @param key
+ * @return Object[0]:filePath,Object[1]:fileId, Object[2]:accessorId
+ */
+ private Object[] getFilePathInfo(String key) {
+ Object[] list = null;
+ if(filePathMap.containsKey(key)) {
+ List<Object> set = filePathMap.get(key);
+ list = set.toArray();
+ }else{
+ Logger.error("The key is not exist : " + key);
}
- return num;
+ return list;
}
-
- private void removeLockNum(String lockKey) {
- int num = 0;
- if(lockNumMap.containsKey(lockKey)) {
- num = lockNumMap.get(lockKey);
- lockNumMap.put(lockKey, num-1);
- } else {
- Logger.error("Couldn't get current lock num!, key :" + lockKey);
+
+ /**
+ * Add file path information
+ * @param key
+ * @param filePath
+ * @param fileId
+ * @param accessorId
+ */
+ private void addFilePathInfo(String key, String filePath, int fileId, int accessorId){
+ if(!filePathMap.containsKey(key)) {
+ List<Object> set = new ArrayList<Object>();
+ set.add((String)filePath);
+ set.add((Integer)fileId);
+ set.add((Integer)accessorId);
+ filePathMap.put(key, set);
+ }
+ }
+
+ private void removeFilePathInfo(String key) {
+ if(filePathMap.containsKey(key)) {
+ filePathMap.remove(key);
+ }
+ }
+
+ /**
+ * Add file lock information
+ * @param fileId
+ * @param pid
+ * @param accessorId
+ */
+ private void addFileLock(int fileId, int pid, int accessorId) {
+ List<Integer> key = Arrays.asList(fileId, pid);
+ List<Integer> tids = new ArrayList<Integer>();
+ if(accessorHasLockMap.containsKey(key)){
+ tids = accessorHasLockMap.get(key);
+ if(!tids.contains(accessorId)) {
+ tids.add(accessorId);
+ accessorHasLockMap.put(key, tids);
+ }
+ }else{
+ tids.add(accessorId);
+ accessorHasLockMap.put(key, tids);
+ }
+ }
+
+ /**
+ * Get TIDs which has file locks
+ * @param fileId
+ * @param pid
+ * @return
+ */
+ private List<Integer> getTidsHasLock(int fileId, int pid) {
+ List<Integer> tids = null;
+ List<Integer> key = Arrays.asList(fileId, pid);
+ if(accessorHasLockMap.containsKey(key)) {
+ tids = accessorHasLockMap.get(key);
+ }
+ return tids;
+ }
+
+ private void removeTidsHasLock(int fileId, int pid) {
+ List<Integer> key = Arrays.asList(fileId, pid);
+ if(accessorHasLockMap.containsKey(key)) {
+ accessorHasLockMap.remove(key);
}
}
}
}
-
/**
* filtering out STDIN/STDOUT ops
* @param input
return false;
}
+ public List<FileAccessor> getFileAccessor() {
+ return fileAccessorQueue.poll();
+ }
+
+ public List<FileAccess> getFileAccessList() {
+ return fileAccessList;
+ }
+
+ public List<FileStatus> getFileStatusList() {
+ return fileStatusList;
+ }
+
+ public List<FileEvent> getFileApiList() {
+ return fileApiList;
+ }
+
+ public List<FileAccessor> getFileAccessorList() {
+ return fileAccessorList;
+ }
+
public void setFileAccessList(List<FileAccess> fileAccessList) {
this.fileAccessList = fileAccessList;
}
public void setFileApiList(List<FileEvent> fileApiList) {
this.fileApiList = fileApiList;
}
+
+ public void setFileAccessorList(List<FileAccessor> fileAccessorList) {
+ this.fileAccessorList = fileAccessorList;
+ }
}
package org.tizen.dynamicanalyzer.ui.file.manager;
-import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.tizen.dynamicanalyzer.swap.logparser.LogPackage;
import org.tizen.dynamicanalyzer.swap.logparser.PageDataManager;
import org.tizen.dynamicanalyzer.ui.file.data.FileAccessDB;
+import org.tizen.dynamicanalyzer.ui.file.data.FileAccessorDB;
import org.tizen.dynamicanalyzer.ui.file.data.FileApiDB;
import org.tizen.dynamicanalyzer.ui.file.data.FileStatusDB;
import org.tizen.dynamicanalyzer.ui.file.model.FileAccess;
-import org.tizen.dynamicanalyzer.ui.file.model.FileEvent;
+import org.tizen.dynamicanalyzer.ui.file.model.FileSelectedData;
public class FileDataManager extends PageDataManager {
private FileAccessDB accessDB = null;
private FileApiDB apiDB = null;
private FileStatusDB statusDB = null;
+ private FileAccessorDB accessorDB = null;
- private List<FileEvent> selectedTableAPIList = new ArrayList<FileEvent>();
+ private FileSelectedData selectedData = null;
private FileDataManager() {
dataMaker = new FileDataMaker();
accessDB = new FileAccessDB();
apiDB = new FileApiDB();
statusDB = new FileStatusDB();
+ accessorDB = new FileAccessorDB();
}
public void clear() {
accessDB = null;
apiDB = null;
statusDB = null;
- selectedTableAPIList = new ArrayList<FileEvent>();
+ accessorDB = null;
+ selectedData = null;
}
public FileAccessDB getAccessDB(){
return statusDB;
}
+ public FileAccessorDB getAccessorDB() {
+ return accessorDB;
+ }
+
public void saveData(Map<String, String> dataMap) {
List<FileAccess> accessList = dataMaker.getFileAccessList();
if (accessList != null ) {
if (dataMaker.getFileApiList().size() == 0) {
dataMaker.setFileApiList(apiDB.select());
}
+
+ if (dataMaker.getFileAccessorList().size() == 0) {
+ dataMaker.setFileAccessorList(accessorDB.select());
+ }
}
public FileDataMaker getFileChartDataMaker() {
return dataMaker;
}
- public List<FileEvent> getSelectedTableAPIList() {
- return selectedTableAPIList;
+ public void setSelectedData(FileSelectedData selectedData) {
+ this.selectedData = selectedData;
}
-
- public void setSelectedTableAPIList(
- List<FileEvent> selectedTableAPIList) {
- this.selectedTableAPIList = selectedTableAPIList;
+
+ public FileSelectedData getSelectedData() {
+ return selectedData;
}
/**
import java.util.ArrayList;
import java.util.List;
-import org.tizen.dynamicanalyzer.ui.file.data.FileAccessDB;
public class FileAccess {
- private String filePath = null;
- private int pid = -1;
- private int tid = -1;
+ private int accessorId = -1;
private long fd = -1;
- private int apiType = -1; // only read, write, lock event
+ private int apiType = -1; // r/w, concurrent r/w, lock, lock wait, unlock, auto release, fail
private long startTime = -1;
private long endTime = -1;
- private long erroNo = 0;
- private long fileSize = -1;
+ private String tooltip = null;
private boolean isAlreadyReading = false;
private boolean isAlreadyWriting = false;
private boolean isAlreadyLocking = false;
private boolean isWarning = false;
- public FileAccess(String filePath, int pid, int tid, int apiType, long startTime) {
- this.filePath = filePath;
- this.pid = pid;
- this.tid = tid;
+ public FileAccess(int accessorId, long fd, int apiType, long startTime, String tooltip) {
+ this.fd = fd;
+ this.accessorId = accessorId;
this.apiType = apiType;
this.startTime = startTime;
+ this.tooltip = tooltip;
}
-
- public FileAccess(String filePath, int pid, int tid, long fd, int apiType, long startTime) {
- this.filePath = filePath;
- this.pid = pid;
- this.tid = tid;
- this.fd = fd;
+
+ public FileAccess(int accessorId, int apiType, long startTime, long endTime, String tooltip) {
+ this.accessorId = accessorId;
this.apiType = apiType;
this.startTime = startTime;
+ this.endTime = endTime;
+ this.tooltip = tooltip;
}
public List<Object> getDBData() {
List<Object> data = new ArrayList<Object>();
- data.add(new Integer(this.pid));
- data.add(new Integer(this.tid));
- data.add(this.filePath);
- data.add(new Long(this.fd));
- data.add(new Integer(this.apiType));
- data.add(new Long(this.startTime));
- data.add(new Long(this.endTime));
- data.add(new Long(this.erroNo));
- data.add(new Long(this.fileSize));
+ data.add(this.accessorId);
+ data.add(this.apiType);
+ data.add(this.startTime);
+ data.add(this.endTime);
+ data.add(this.tooltip);
return data;
}
-
- public FileAccess(List<Object> data) {
- this.pid = (Integer)data.get(FileAccessDB.COLUMN.PID.getValue());
- this.tid = (Integer)data.get(FileAccessDB.COLUMN.TID.getValue());
- this.filePath = (String)data.get(FileAccessDB.COLUMN.FILE_PATH.getValue());
- this.fd = (Long)data.get(FileAccessDB.COLUMN.FD.getValue());
- this.apiType = (Integer)data.get(FileAccessDB.COLUMN.API_TYPE.getValue());
- this.startTime = (Long)data.get(FileAccessDB.COLUMN.START_TIME.getValue());
- this.endTime = (Long)data.get(FileAccessDB.COLUMN.END_TIME.getValue());
- this.erroNo = (Long)data.get(FileAccessDB.COLUMN.ERRNO.getValue());
- this.fileSize = (Long)data.get(FileAccessDB.COLUMN.FILE_SIZE.getValue());
- }
-
- public String getFilePath() {
- return filePath;
- }
-
- public void setFilePath(String filePath) {
- this.filePath = filePath;
- }
-
- public int getPid() {
- return pid;
- }
-
- public void setPid(int pid) {
- this.pid = pid;
- }
-
- public int getTid() {
- return tid;
- }
-
- public void setTid(int tid) {
- this.tid = tid;
- }
-
- public long getFd() {
- return fd;
- }
-
- public void setFd(long fd) {
- this.fd = fd;
- }
public int getApiType() {
return apiType;
this.isAlreadyLocking = isAlreadyLocking;
}
- public long getErroNo() {
- return erroNo;
- }
-
- public void setErroNo(long erroNo) {
- this.erroNo = erroNo;
- }
- public long getFileSize() {
- return fileSize;
+ public String getTooltip() {
+ return tooltip;
}
- public void setFileSize(long fileSize) {
- this.fileSize = fileSize;
+ public void setTooltip(String tooltip) {
+ this.tooltip = tooltip;
}
public void setWarning() {
public boolean isWarning() {
return isWarning;
}
+
+ public void setFd(long fd) {
+ this.fd = fd;
+ }
+
+ public long getFd() {
+ return fd;
+ }
+
+ public int getAccessorId() {
+ return accessorId;
+ }
+
+ public void setAccessorId(int accessorId) {
+ this.accessorId = accessorId;
+ }
}
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Hyeran Kim <Hyeran74.kim@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.file.model;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+public class FileAccessor {
+ private int accessorId = -1;
+ private int fileId = -1;
+ private String filePath = null;
+ private int pid = -1;
+ private int tid = -1;
+ private boolean isTarget = true;
+
+ public FileAccessor(int accessorId, int fileId, String filePath, int pid, int tid, boolean isTarget) {
+ this.accessorId = accessorId;
+ this.fileId = fileId;
+ this.filePath = filePath;
+ this.pid = pid;
+ this.tid = tid;
+ this.isTarget = isTarget;
+ }
+
+ public List<Object> getDBData() {
+ List<Object> data = new ArrayList<Object>();
+ data.add(this.accessorId);
+ data.add(this.fileId);
+ data.add(this.filePath);
+ data.add(this.pid);
+ data.add(this.tid);
+ data.add(this.isTarget);
+ return data;
+ }
+
+ public int getAccessorId() {
+ return accessorId;
+ }
+ public void setAccessorId(int accessorId) {
+ this.accessorId = accessorId;
+ }
+ public int getFileId() {
+ return fileId;
+ }
+ public void setFileId(int fileId) {
+ this.fileId = fileId;
+ }
+ public String getFilePath() {
+ return filePath;
+ }
+ public void setFilePath(String filePath) {
+ this.filePath = filePath;
+ }
+ public int getPid() {
+ return pid;
+ }
+ public void setPid(int pid) {
+ this.pid = pid;
+ }
+ public int getTid() {
+ return tid;
+ }
+ public void setTid(int tid) {
+ this.tid = tid;
+ }
+ public boolean isTarget() {
+ return isTarget;
+ }
+ public void setIsTarget(boolean isTarget) {
+ this.isTarget = isTarget;
+ }
+
+ @Override
+ public boolean equals(Object o){
+ FileAccessor s = (FileAccessor) o;
+ if(this.fileId == s.getFileId()
+ && this.pid == s.getPid()
+ && this.tid == s.getTid()){
+ return true;
+ } else {
+ return false;
+ }
+ }
+}
import java.util.List;
import org.tizen.dynamicanalyzer.swap.model.data.FileData;
-import org.tizen.dynamicanalyzer.ui.file.data.FileApiDB;
public class FileEvent extends FileData{
- // TODO considering apiId
private int apiId = -1;
- private long ioSize =-1;
private boolean target = false;
private int lockType = -1;
-
+
+ protected int fileId = -1;
+ protected int accessorId = -1;
+
public FileEvent() { }
// for non-target process
this.target = target;
}
- public FileEvent(long seq, String filePath, int pid, int tid) {
+ public FileEvent(long seq, String filePath, int pid, int tid,
+ long fd, int apiType, int apiId, long eventTime, long fileSize, long size,
+ String args, String returnVal, long errNo){
this.seq = seq;
- this.filePath = filePath;
this.pid = pid;
this.tid = tid;
+ this.filePath = filePath;
+ this.fdValue = fd;
+ this.fdApiType = apiType;
+ this.apiId = apiId;
+ this.time = eventTime;
+ this.fileSize = fileSize;
+ this.size = size;
+ this.args = args;
+ this.ret = returnVal;
+ this.errno = errNo;
}
-
- public FileEvent(List<Object> data) {
- this.seq = (Long) data.get(FileApiDB.COLUMN.SEQ.getValue());
- this.filePath = (String) data.get(FileApiDB.COLUMN.FILE_PATH.getValue());
- this.pid = (Integer) data.get(FileApiDB.COLUMN.PID.getValue());
- this.tid = (Integer) data.get(FileApiDB.COLUMN.TID.getValue());
- this.fdValue = (Long) data.get(FileApiDB.COLUMN.FD.getValue());
- this.fdApiType = (Integer) data.get(FileApiDB.COLUMN.API_TYPE.getValue());
- this.apiId = (Integer) data.get(FileApiDB.COLUMN.API_ID.getValue());
- this.time = (Long) data.get(FileApiDB.COLUMN.EVENT_TIME.getValue());
- this.fileSize = (Long) data.get(FileApiDB.COLUMN.FILE_SIZE.getValue());
- this.size = (Long) data.get(FileApiDB.COLUMN.SIZE.getValue());
- this.ret = (String) data.get(FileApiDB.COLUMN.RETURN_VALUE.getValue());
- this.args = (String) data.get(FileApiDB.COLUMN.ARGS.getValue());
- this.errno = (Long) data.get(FileApiDB.COLUMN.ERRNO.getValue());
- this.target = (Boolean) data.get(FileApiDB.COLUMN.TARGET.getValue());
+
+ public FileEvent(long seq, int accessorId, int fileId,
+ long fd, int apiType, int apiId, long eventTime, long fileSize, long size,
+ String args, String returnVal, long errNo){
+ this.seq = seq;
+ this.fileId = fileId;
+ this.accessorId = accessorId;
+ this.fdValue = fd;
+ this.fdApiType = apiType;
+ this.apiId = apiId;
+ this.time = eventTime;
+ this.fileSize = fileSize;
+ this.size = size;
+ this.args = args;
+ this.ret = returnVal;
+ this.errno = errNo;
}
public List<Object> getDBData() {
List<Object> data = new ArrayList<Object>();
data.add(this.seq);
- data.add(this.filePath);
- data.add(this.pid);
- data.add(this.tid);
+ data.add(this.fileId);
+ data.add(this.accessorId);
data.add(this.fdValue);
data.add(this.fdApiType);
data.add(this.time);
data.add(this.apiId);
data.add(this.errno);
- data.add(this.ioSize);
data.add(this.fileSize);
data.add(this.size);
data.add(this.ret);
data.add(this.args);
- data.add(this.target);
+
return data;
}
this.seq = seqNo;
}
- public long getIoSize() {
- return ioSize;
- }
-
- public void setIoSize(long ioSize) {
- this.ioSize = ioSize;
- }
-
public long getFileSize() {
return fileSize;
}
public int getLockType() {
return lockType;
}
+
+ public void setFileId(int fileId) {
+ this.fileId = fileId;
+ }
+
+ public int getFileId() {
+ return fileId;
+ }
+
+ public int getAccessorId() {
+ return accessorId;
+ }
+
+ public void setAccessorId(int accessorId) {
+ this.accessorId = accessorId;
+ }
}
public class FileSelectedData extends FileEvent{
private boolean isParentChart = false;
+ private FileAccessor accessor = null;
- public FileSelectedData(String filePath, int pid, int tid,long fd, boolean isParentChart) {
- this.filePath = filePath;
- this.pid = pid;
- this.tid = tid;
- this.fdValue = fd;
- this.isParentChart = isParentChart;
+ public FileSelectedData(FileAccessor accessor, boolean isParentChart) {
+ this.accessor = accessor;
+ this.accessorId = accessor.getAccessorId();
+ this.fileId = accessor.getFileId();
}
- public FileSelectedData(String filePath, int pid, int tid, long fd,
- long fileSize, boolean isParentChart) {
- this.pid = pid;
- this.tid = tid;
- this.fdValue = fd;
+ /*public FileSelectedData(int accessorId, int fileId, boolean isParentChart) {
+ this.fileId = fileId;
+ this.accessorId = accessorId;
+ this.isParentChart = isParentChart;
+ }*/
+
+ public FileSelectedData(int fileId, boolean isParentChart) {
+ this.fileId = fileId;
this.isParentChart = isParentChart;
- this.filePath = filePath;
- this.fileSize = fileSize;
- }
-
- public int getPid() {
- return pid;
- }
-
- public void setPid(int pid) {
- this.pid = pid;
- }
-
- public int getTid() {
- return tid;
- }
-
- public void setTid(int tid) {
- this.tid = tid;
}
-
+
+
public boolean isParentChart() {
return isParentChart;
}
this.isParentChart = isParentChart;
}
- public String getFilePath(){
- return filePath;
+ public FileAccessor getFileAccessor() {
+ return accessor;
}
public String getFileName() {
return fileName;
}
- public long getFileSize() {
- return fileSize;
- }
-
- public void getFileSize(long fileSize) {
- this.fileSize = fileSize;
- }
-
}
import java.util.ArrayList;
import java.util.List;
-import org.tizen.dynamicanalyzer.ui.file.data.FileStatusDB;
-
public class FileStatus {
- private String filePath = null;
- private int pid = -1;
- private int tid = -1;
- private long fd = -1;
+ private int fileId = -1;
private int apiType = -1; // only open, close event
private long eventTime = -1;
- private long errNo = 0;
-
- public FileStatus(int pid, int tid, long fd, String filePath,
- int apiType, long eventTime, long errNo) {
- this.filePath = filePath;
- this.pid = pid;
- this.tid = tid;
- this.fd = fd;
+
+ public FileStatus(int fileId, int apiType, long eventTime) {
+ this.fileId = fileId;
this.apiType = apiType;
this.eventTime = eventTime;
- this.errNo = errNo;
}
public List<Object> getDBData() {
List<Object> data = new ArrayList<Object>();
- data.add(this.pid);
- data.add(this.tid);
- data.add(this.filePath);
- data.add(this.fd);
+ data.add(this.fileId);
data.add(this.apiType);
data.add(this.eventTime);
- data.add(this.errNo);
return data;
}
- public FileStatus(List<Object> data) {
- this.pid = (Integer)data.get(FileStatusDB.COLUMN.PID.getValue());
- this.tid = (Integer)data.get(FileStatusDB.COLUMN.TID.getValue());
- this.filePath = (String)data.get(FileStatusDB.COLUMN.FILE_PATH.getValue());
- this.fd = (Long)data.get(FileStatusDB.COLUMN.FD.getValue());
- this.apiType = (Integer)data.get(FileStatusDB.COLUMN.API_TYPE.getValue());
- this.eventTime = (Long)data.get(FileStatusDB.COLUMN.EVENT_TIME.getValue());
- this.errNo = (Long)data.get(FileStatusDB.COLUMN.ERRNO.getValue());
- }
-
- public String getFilePath() {
- return filePath;
- }
-
- public void setFilePath(String filePath) {
- this.filePath = filePath;
- }
-
- public int getPid() {
- return pid;
- }
-
- public void setPid(int pid) {
- this.pid = pid;
- }
-
- public int getTid() {
- return tid;
- }
-
- public void setTid(int tid) {
- this.tid = tid;
- }
-
- public long getFd() {
- return fd;
- }
-
- public void setFd(long fd) {
- this.fd = fd;
- }
-
public int getApiType() {
return apiType;
}
public void setApiType(int apiType) {
this.apiType = apiType;
}
-
- public void setErrNo(long errNo) {
- this.errNo = errNo;
- }
-
- public long getErrNo() {
- return errNo;
+ public void setFileId(int fileId) {
+ this.fileId = fileId;
}
+ public int getFileId() {
+ return fileId;
+ }
}
public class CallStackDataDBTable extends DBTable {
private static final String TABLENAME="CallStackData";
private static final String queryto_withSeq = "where %s = %s";
- //TODO: use Array type of DB
+
public enum COLUMN {
SEQ(0, "SEQNUMBER"),
- ORDER(1, "CallStackOrder"),
- PCADDR(2, "PcAddr");
+ ADDRESS_ARRAY(1, "ADDRESS_ARRAY");
public final int index;
public final String name;
public CallStackDataDBTable() {
addColumn(new DBColumn(COLUMN.SEQ.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
- addColumn(new DBColumn(COLUMN.ORDER.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
- addColumn(new DBColumn(COLUMN.PCADDR.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.ADDRESS_ARRAY.name, DBConstants.NOT_NULL, DBConstants.BIGINT_ARRAY));
}
public List<List<Object>> getCallStackAddrsFromDB(long seq) {
COLUMN.SEQ.name, seq);
List<String> selectColumn = new ArrayList<String>();
- selectColumn.add(COLUMN.PCADDR.name);
+ selectColumn.add(COLUMN.ADDRESS_ARRAY.name);
return selectData(selectColumn, where, new IResultSet() {
@Override
public List<Object> extractDataFromResultSet(ResultSet rs) {
List<Object> row = new ArrayList<Object>();
- try {
- row.add(Long.valueOf(rs.getLong(1)));
- } catch (SQLException e) {
- e.printStackTrace();
- return null;
- }
-
+ row.add(getArrayFromResultSet(rs, 1, Long.valueOf(0)));
return row;
}
});
} else {
try {
prep.setLong(COLUMN.SEQ.index + 1, (Long) (rowData.get(COLUMN.SEQ.index)));
- prep.setInt(COLUMN.ORDER.index + 1, (Integer) (rowData.get(COLUMN.ORDER.index)));
- prep.setLong(COLUMN.PCADDR.index + 1, (Long) (rowData.get(COLUMN.PCADDR.index)));
+ setArrayToPreparedStatement(COLUMN.ADDRESS_ARRAY.index, DBConstants.LONG,
+ prep, rowData);
} catch (SQLException e) {
e.printStackTrace();
isPrepared = false;
package org.tizen.dynamicanalyzer.ui.info.callstack;
import java.util.ArrayList;
+import java.util.Iterator;
import java.util.List;
+import java.util.Map;
+import java.util.NavigableMap;
+import java.util.SortedMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
+import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.DALimit;
import org.tizen.dynamicanalyzer.common.Global;
+import org.tizen.dynamicanalyzer.nl.ConfigureLabels;
import org.tizen.dynamicanalyzer.project.BinaryInfo;
+import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler;
+import org.tizen.dynamicanalyzer.ui.toolbar.setting.SettingDataManager;
+import org.tizen.dynamicanalyzer.ui.toolbar.setting.TargetData;
// inserter thread for callstackdata, callstackunit
public class CallStackInserter implements Runnable {
private static volatile Thread inserterThread = null;
private static final int FULL_COUNT = 100;
private static boolean stopTrace = false;
+ private static long lastInsertSeq = -1;
private CallStackDataDBTable callStackDataTable = null;
private CallStackUnitDBTable callStackUnitTable = null;
while ((csd = callstackDataQueue.poll()) != null) {
List<Long> addrs = csd.getAddrs();
- int size = addrs.size();
-
- for(int i = 0; i < size; i++) {
- List<Object> insertRowData = new ArrayList<Object>();
- try {
- insertRowData.add(new Long(csd.getSeq()));
- insertRowData.add(new Integer(i));
- insertRowData.add(new Long(addrs.get(i)));
- } catch (ArrayIndexOutOfBoundsException e) {
- e.printStackTrace();
- }
- insertData.add(insertRowData);
+
+ List<Object> insertRowData = new ArrayList<Object>();
+ try {
+ insertRowData.add(new Long(csd.getSeq()));
+ insertRowData.add(addrs);
+ } catch (ArrayIndexOutOfBoundsException e) {
+ e.printStackTrace();
}
+ insertData.add(insertRowData);
+
+ lastInsertSeq = csd.getSeq();
if ((insertCount-- <= 0) && (stopTrace == false)) {
break;
}
if (insertData.size() > 0) {
callStackDataTable.insertData(insertData);
}
+ // remove unnecessary callstackdata from memory
+ TargetData target = SettingDataManager.getInstance().getConnectedTarget();
+ if (target.isSelectedFeature(ConfigureLabels.FEATURE_FUNCTION_SAMPLING)) {
+ // sample feature is on
+ long lastSampleSeq = FunctionUsageProfiler.getInstance().getLastSampleSeq();
+ if (lastSampleSeq != -1) {
+ if (lastSampleSeq <= lastInsertSeq) {
+ removeCallstackData(lastSampleSeq);
+ } else { // lastSampleSeq > lastInsertSeq
+ removeCallstackData(lastInsertSeq);
+ }
+ }
+ } else { // sample feature is off
+ // callstackdata is not needed in memory after insertion to DB
+ removeCallstackData(lastInsertSeq);
+ }
+ // clear SeqTimeMap if number of entries over > 1M
+ List<Integer> tids = AnalyzerManager.getCallstackManager().getTidsOfSeqTimeMap();
+ int size = tids.size();
+ for (int i = 0; i < size; i++) {
+ NavigableMap<Long, Long> seqByTimeMap =
+ AnalyzerManager.getCallstackManager()
+ .getSeqTimeByTidMap(tids.get(i));
+ if (seqByTimeMap.size() > DALimit.MAX_CALLSTACK_SEQTIMEMAP_SIZE) {
+ seqByTimeMap.clear();
+ }
+ }
}
public void offerCallstackUnit(CallStackUnit csu) {
callstackDataQueue.offer(csd);
}
}
+
+ private void removeCallstackData(long seq) {
+ NavigableMap<Long, CallStackData> callstackDataMap = AnalyzerManager
+ .getCallstackManager().getCallStackDataBySeqMap();
+ SortedMap<Long, CallStackData> headMap = callstackDataMap.headMap(seq);
+ Iterator<Map.Entry<Long, CallStackData>> itr = headMap.entrySet().iterator();
+ while (itr.hasNext()) {
+ itr.next();
+ itr.remove();
+ }
+ }
@Override
public void run() {
package org.tizen.dynamicanalyzer.ui.info.callstack;
-import java.util.ArrayList;
import java.util.List;
import java.util.Map;
time = logData.getTime();
}
- Map<Long, CallStackData> cdMap = AnalyzerManager
- .getCallstackManager().getCallStackDataBySeqMap();
Map<Long, CallStackUnit> addrMap = AnalyzerManager
.getCallstackManager().getCallStackApiAddrByPidMap(pid);
- if (null == cdMap || null == addrMap) {
+ if (null == addrMap) {
return;
}
- CallStackData csd = cdMap.get(seqNum);
- List<Long> addrs = null;
- if (null == csd) { // callstackdata is not in memory, find from DB
- List<List<Object>> callStackAddrs =
- CallStackInserter.getInstance().getCallStackDataTable()
- .getCallStackAddrsFromDB(seqNum);
-
- if (null == callStackAddrs || 0 == callStackAddrs.size()
- || null == callStackAddrs.get(0)) { // not found
- return;
- }
- int size = callStackAddrs.size();
- addrs = new ArrayList<Long>();
- for (int i = 0; i < size; i++) {
- addrs.add((Long) callStackAddrs.get(i).get(0));
- }
- } else { // callstackdata is in memory
- addrs = csd.getAddrs();
+ List<Long> addrs = null;
+ addrs = AnalyzerManager.getCallstackManager().getCallstackAddrListFromSeq(seqNum);
+ if (null == addrs) {
+ return;
}
-
+
int size = addrs.size();
for (int i = 0; i < size; i++) {
String hexAddr = Formatter.toHexString(addrs.get(i).toString());
CallStackUnit api = addrMap.get(addrs.get(i));
if (null == api) {
- Logger.debug("callstackunit for addr : " + hexAddr + " not found");
+ Logger.debug("callstackunit for addr : " + hexAddr + " not found");
return;
}
public void clear() {
leakDataMaker.clear();
+ warningDataMaker.clear();
}
@Override
import java.util.ArrayList;
import java.util.HashMap;
-import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.NavigableMap;
-import java.util.SortedMap;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.swap.logparser.PageDataManager;
import org.tizen.dynamicanalyzer.swap.model.data.LogData;
import org.tizen.dynamicanalyzer.swap.model.data.ProfileData;
-import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackData;
import org.tizen.dynamicanalyzer.ui.toolbar.setting.SettingDataManager;
import org.tizen.dynamicanalyzer.ui.toolbar.setting.TargetData;
public static final String APPLICATION_KEY = "profiling_app_bin_key";//$NON-NLS-1$
public static final String DEPENDENT_LIB_KEY = "profiling_dependent_lib_key";//$NON-NLS-1$
public static final String UNKNOWN = CommonConstants.EMPTY;
- public static final int CALLSTACKDATA_MAX = 5000;
private static FunctionUsageProfiler instance = null;
private boolean isSetSamplePeriod = false;
private FunctionSampleDBTable functionSampleTable = null;
private HashMap<Integer, ProfileDataMaker> profileDataMakerMap = null;
+
+ private static long lastSampleSeq = -1;
+ private Object sampleSeqLock = new Object();
+
+ public void setLastSampleSeq(long seq) {
+ synchronized(sampleSeqLock) {
+ lastSampleSeq = seq;
+ }
+ }
+
+ public long getLastSampleSeq() {
+ synchronized(sampleSeqLock) {
+ return lastSampleSeq;
+ }
+ }
private FunctionUsageProfiler() {
profilingDataTable = new ProfilingDataDBTable();
for (int j = 0; j < count; j++) {
ProfilingChildData data = pDataList.get(j);
List<Integer> childList = data.getChildren();
- int childCount = childList.size();
try {
- for (int k = 0; k < childCount; k++)
- {
- List<Object> insertRowData = new ArrayList<Object>();
- insertRowData.add(Integer.valueOf(data.getProfilingDataID()));
- insertRowData.add(new Integer(data.getPid()));
- insertRowData.add(new Integer(childList.get(k)));
- insertData.add(insertRowData);
- }
+ List<Object> insertRowData = new ArrayList<Object>();
+ insertRowData.add(Integer.valueOf(data.getProfilingDataID()));
+ insertRowData.add(new Integer(data.getPid()));
+ insertRowData.add(childList);
+ insertData.add(insertRowData);
} catch (ArrayIndexOutOfBoundsException e) {
e.printStackTrace();
}
getInstance().getProfileDataMakerByPid(
sample.get(i).getPid())
.makeFunctionUsageProfileData(sampleLog);
- Map<Long, CallStackData> callstackDataMap = AnalyzerManager.getCallstackManager()
- .getCallStackDataBySeqMap();
- if (callstackDataMap.size() > CALLSTACKDATA_MAX) {
- // remove unnecessary callstackdata from memory
- NavigableMap<Long, Long> seqByTimeMap =
- AnalyzerManager.getCallstackManager()
- .getSeqTimeByTidMap(sampleLog.getTid());
- // find the time of callstackdata which was made
- // right before the current sample time
- // callstackdatas made before that time is needless
- Long lastTime = seqByTimeMap
- .floorKey(sampleLog.getTime());
- if (null != lastTime) {
- SortedMap<Long, Long> headMap =
- seqByTimeMap.headMap(lastTime);
- Iterator<Map.Entry<Long, Long>> itr = headMap
- .entrySet().iterator();
- while (itr.hasNext()) {
- Map.Entry<Long, Long> entry = itr.next();
- callstackDataMap.remove(entry.getValue());
- itr.remove();
- }
- }
+ // set LastSampleSeq
+ NavigableMap<Long, Long> seqByTimeMap =
+ AnalyzerManager.getCallstackManager()
+ .getSeqTimeByTidMap(sampleLog.getTid());
+ // find the time of callstackdata which was made
+ // right before the current sample time
+ // callstackdatas made before that time is needless
+ Long lastTime = seqByTimeMap
+ .floorKey(sampleLog.getTime());
+ if (lastTime != null) {
+ Long lastSeq = seqByTimeMap.get(lastTime);
+ setLastSampleSeq(lastSeq);
}
// save to DB
try {
functionSampleTable.insertData(insertData);
}
}
- } else { // sampling is off, callstackdata is not needed in memory
- // need to maintain callstackdata until insertion to DB is finished
- Map<Long, CallStackData> callstackDataMap = AnalyzerManager.getCallstackManager()
- .getCallStackDataBySeqMap();
- if (callstackDataMap.size() > CALLSTACKDATA_MAX) {
- callstackDataMap.clear();
- }
}
}
}
import java.util.HashMap;
import java.util.List;
import java.util.Map;
-import java.util.NavigableMap;
import java.util.concurrent.ConcurrentHashMap;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
int pid = sampleLog.getPid();
if(DACommunicator.isSWAPVersion()) {
- long seq;
+ long userCallstackSeq;
int tid = sampleLog.getTid();
long sampleTime = sampleLog.getTime();
- long callstackTime;
- Long longTime = null;
+
CallStackData callstackData;
- NavigableMap<Long, Long> seqByTimeMap = callstackManager.getSeqTimeByTidMap(tid);
Map<Long, CallStackUnit> addrMap = callstackManager
.getCallStackApiAddrByPidMap(pid);
addrMap.put(selfAddr, newCallstackUnit);
}
- longTime = seqByTimeMap.floorKey(sampleTime);
- if(null != longTime) {
- callstackTime = longTime.longValue();
- seq = seqByTimeMap.get(callstackTime);
- callstackData = callstackManager.getCallStackDataBySeqMap().get(seq);
- addrs = new ArrayList<Long>(callstackData.getAddrs());
- for(int i = 0; i < addrs.size(); i++) {
- if(addrs.get(i) == 0) {
- addrs.remove(i);
+ userCallstackSeq = callstackManager.getSeqOfUserCallstackForTime(tid, sampleTime);
+ if (-1 != userCallstackSeq) {
+ callstackData = callstackManager.getCallStackDataBySeqMap().get(userCallstackSeq);
+ if (null == callstackData) {
+ Logger.debug("CallStackData is not found for seq : " + userCallstackSeq);
+ addrs = new ArrayList<Long>();
+ addrs.add(selfAddr);
+ } else {
+ addrs = new ArrayList<Long>(callstackData.getAddrs());
+ for(int i = 0; i < addrs.size(); i++) {
+ if(addrs.get(i) == 0) {
+ addrs.remove(i);
+ }
}
+ addrs.add(0, selfAddr);
}
- addrs.add(0, selfAddr);
} else {
// Logger.debug("makeFunctionUsageProfileData : cannot find seq by time");
addrs = new ArrayList<Long>();
public class ProfilingChildDataDBTable extends DBTable {
private static final String TABLENAME="ProfilingChildData";
- // TODO: use Array type of DB
+
public enum COLUMN {
PROFILINGDATAID(0, "ProfilingDataID"),
PID(1, "PID"),
- CHILDDATAID(2, "ChildDataID");
+ CHILDSEQARRAY(2, "CHILD_SEQUENCE_ARRAY");
public final int index;
public final String name;
public ProfilingChildDataDBTable() {
addColumn(new DBColumn(COLUMN.PROFILINGDATAID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
addColumn(new DBColumn(COLUMN.PID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
- addColumn(new DBColumn(COLUMN.CHILDDATAID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
- }
+ addColumn(new DBColumn(COLUMN.CHILDSEQARRAY.name, DBConstants.NOT_NULL, DBConstants.INTEGER_ARRAY));
+ }
public List<List<Object>> getProfilingChildDataFromDB() {
return selectAllColumnData(null);
try {
prep.setInt(COLUMN.PROFILINGDATAID.index + 1, (Integer) (rowData.get(COLUMN.PROFILINGDATAID.index)));
prep.setInt(COLUMN.PID.index + 1, (Integer) (rowData.get(COLUMN.PID.index)));
- prep.setInt(COLUMN.CHILDDATAID.index + 1, (Integer) (rowData.get(COLUMN.CHILDDATAID.index)));
+ setArrayToPreparedStatement(COLUMN.CHILDSEQARRAY.index, DBConstants.DBTYPE_INT4, prep, rowData);
} catch (SQLException e) {
e.printStackTrace();
isPrepared = false;
try {
row.add(Integer.valueOf(rs.getInt(1)));
row.add(Integer.valueOf(rs.getInt(2)));
- row.add(Integer.valueOf(rs.getInt(3)));
+ row.add(getArrayFromResultSet(rs, 3, Integer.valueOf(0)));
} catch (SQLException e) {
e.printStackTrace();
return null;
* Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
*
* Contact:
+ * Hyunjong Park <phjwithyou.park@samsung.com>
* WooJin Jung <woojin2.jung@samsung.com>
* yeongtaik byeon <yeongtaik.byeon@samsung.com>
* Juyoung Kim <j0.kim@samsung.com>
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
import java.util.List;
import org.eclipse.nebula.widgets.grid.GridItem;
import org.tizen.dynamicanalyzer.database.SqlConnectionManager;
import org.tizen.dynamicanalyzer.error.ErrorCodeManager;
import org.tizen.dynamicanalyzer.model.TableInput;
-import org.tizen.dynamicanalyzer.swap.model.data.LogData;
import org.tizen.dynamicanalyzer.swap.model.data.ProbeCommonData;
-import org.tizen.dynamicanalyzer.ui.thread.data.SyncAPIDBTable;
-import org.tizen.dynamicanalyzer.ui.thread.data.ThreadAPIDBTable;
-import org.tizen.dynamicanalyzer.ui.thread.sync.ThreadPageSyncData;
-import org.tizen.dynamicanalyzer.ui.thread.thread.ThreadPageThreadData;
-import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants;
-import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
+import org.tizen.dynamicanalyzer.swap.model.data.SyncData;
+import org.tizen.dynamicanalyzer.ui.thread.data.ThreadDataManager;
+import org.tizen.dynamicanalyzer.ui.thread.db.SyncAPIDBTable;
+import org.tizen.dynamicanalyzer.ui.thread.db.ThreadAPIDBTable;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageData;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageSyncData;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageSyncDataEvent;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageThreadData;
import org.tizen.dynamicanalyzer.ui.widgets.table.DAApiListTableComposite;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableDataFormat;
import org.tizen.dynamicanalyzer.util.Logger;
import org.tizen.dynamicanalyzer.utils.Formatter;
public class ThreadAPIListTable extends DAApiListTableComposite {
-
+
private enum API {
- SEQ(1),
- APICALLTIME(2),
- APIID(3),
- PID(4),
- TID(5),
- ARGUMENT(6),
- RETURN(7),
- ERRORNO(8);
-
+ SEQ(1), APICALLTIME(2), APIID(3), PID(4), TID(5), ARGUMENT(6), RETURN(7), ERRORNO(8);
public final int index;
-
+
API(int index) {
this.index = index;
}
}
-
+
public ThreadAPIListTable(Composite parent, int compStyle, int tableStyle) {
super(parent, compStyle, tableStyle);
table.addSelectionListener(new SelectionListener() {
-
@Override
public void widgetSelected(SelectionEvent e) {
GridItem[] items = table.getSelection();
}
long startTime = 0;
long endTime = 0;
-
DATableDataFormat dataFormat;
for (int i = 0; i < items.length; i++) {
dataFormat = (DATableDataFormat) items[i].getData();
endTime = itemTime;
}
}
-
- DASelectionData selData = new DASelectionData(
- ThreadPage.listViewID, startTime, endTime, items, table);
+ DASelectionData selData = new DASelectionData(ThreadPage.listViewID, startTime,
+ endTime, items, table);
AnalyzerManager.getCurrentPage().updateView(selData);
}
@Override
protected List<TableInput> makeTableInput() {
- ThreadAPIListView view = (ThreadAPIListView) AnalyzerManager
- .getCurrentPage().getView(ThreadPage.listViewID);
-
+ List<TableInput> input = new ArrayList<TableInput>();
+ ThreadAPIListView view = (ThreadAPIListView) AnalyzerManager.getCurrentPage().getView(
+ ThreadPage.listViewID);
+ if(null == view){
+ return input;
+ }
ThreadPageData data = view.getPageData();
- long rangeStartTime = view.getAnalysisStartTime();
- long rangeEndTime = view.getAnaysisEndTime();
-
if (null == data) {
+ return input;
+ }
+
+ int selectID = -1;
+ List<ProbeCommonData> syncAPIList = new ArrayList<ProbeCommonData>();
+ if (data instanceof ThreadPageThreadData) {
+ ThreadPageThreadData tData = (ThreadPageThreadData) data;
+ selectID = tData.getThreadDataID();
+ } else if (data instanceof ThreadPageSyncData) {
+ ThreadPageSyncData sData = (ThreadPageSyncData) data;
+ selectID = sData.getSyncDataID();
+ syncAPIList.addAll(getSyncAPIOfNotInsert(selectID));
+ } else {
+ Logger.debug("failed to selectionD data in Thread Page API table");
return null;
}
- List<TableInput> input = new ArrayList<TableInput>();
- ResultSet rs = null;
+ syncAPIList.addAll(selectAPIListFromDB(data, selectID));
+ sortListByTime(syncAPIList);
+ for (ProbeCommonData apiData : syncAPIList) {
+ List<String> contentText = new ArrayList<String>();
+ List<String> contentData = new ArrayList<String>();
+
+ contentText.add(0, String.valueOf(apiData.getSeq()));
+ contentData.add(String.valueOf(apiData.getSeq()));
+
+ contentText.add(Formatter.toTimeFormat(apiData.getTime()));
+ contentData.add(Long.toString(apiData.getTime()));
+
+ contentText.add(Integer.toString(apiData.getPid()));
+ contentData.add(Integer.toString(apiData.getPid()));
+
+ contentText.add(Long.toString(apiData.getTid()));
+ contentData.add(Long.toString(apiData.getTid()));
+ contentText.add(apiData.getApiName());
+ contentData.add(apiData.getApiName());
+
+ contentText.add(apiData.getArgs());
+ contentData.add(apiData.getArgs());
+
+ contentText.add(apiData.getReturn());
+ contentData.add(apiData.getReturn());
+
+ String errMsg = ErrorCodeManager.getInatance().getErrorCode(apiData.getErrno()).name();
+ if (null == errMsg) {
+ errMsg = "undefined error code";
+ }
+ contentText.add(errMsg);
+ contentData.add(errMsg);
+
+ DATableDataFormat tableData = new DATableDataFormat(apiData.getSeq());
+ tableData.setLogData(apiData);
+ tableData.getData().addAll(contentData);
+ TableInput tableInput = new TableInput();
+ tableInput.setText(contentText);
+ tableInput.setData(tableData);
+ if (!errMsg.contains("SUCCESS")) {//$NON-NLS-1$
+ tableInput.setFailed(true);
+ }
+ input.add(tableInput);
+ if (apiData.getTime() >= view.getAnalysisStartTime()
+ && apiData.getTime() <= view.getAnaysisEndTime()) {
+ tableInput.setInRange(true);
+ }
+ }
+ return input;
+ }
+
+ private List<ProbeCommonData> selectAPIListFromDB(ThreadPageData data, int selectID) {
+ List<ProbeCommonData> returnList = new ArrayList<ProbeCommonData>();
+ if(null == data){
+ return returnList;
+ }
+ ResultSet rs = null;
if (data instanceof ThreadPageThreadData) {
- ThreadPageThreadData tData = (ThreadPageThreadData) data;
- String query = String.format(ThreadAPIDBTable.SELECT_QUERY, tData.getThreadDataID());
+ String query = String.format(ThreadAPIDBTable.SELECT_QUERY, selectID);
rs = SqlConnectionManager.executeQueryRS(query);
if (null == rs) {
Logger.debug("failed to query api data in thread API table");
- return null;
+ return returnList;
}
} else if (data instanceof ThreadPageSyncData) {
- ThreadPageSyncData sData = (ThreadPageSyncData) data;
- String query = String.format(SyncAPIDBTable.SELECT_QUERY, sData.getSyncDataID());
+ String query = String.format(SyncAPIDBTable.SELECT_QUERY, selectID);
rs = SqlConnectionManager.executeQueryRS(query);
if (null == rs) {
Logger.debug("failed to query api data in sync API table");
- return null;
- }
+ return returnList;
+ }
} else {
Logger.error("unknown thread page data type!!");
- return null;
+ return returnList;
}
-
try {
- while(rs.next()) {
- ProbeCommonData apiData = makeProbeCommonData(rs);
-
- int selectedPid = ToolbarArea.getInstance().getSelectedPid();
- if (selectedPid != 0) {
- if (selectedPid != apiData.getPid()) {
- continue;
- }
- }
- List<String> contentText = new ArrayList<String>();
- List<String> contentData = new ArrayList<String>();
-
- contentText.add(0, String.valueOf(apiData.getSeq()));
- contentData.add(String.valueOf(apiData.getSeq()));
-
- contentText.add(Formatter.toTimeFormat(apiData.getTime()));
- contentData.add(Long.toString(apiData.getTime()));
-
- contentText.add(Integer.toString(apiData.getPid()));
- contentData.add(Integer.toString(apiData.getPid()));
-
- contentText.add(Long.toString(apiData.getTid()));
- contentData.add(Long.toString(apiData.getTid()));
-
- contentText.add(apiData.getApiName());
- contentData.add(apiData.getApiName());
-
- contentText.add(apiData.getArgs());
- contentData.add(apiData.getArgs());
-
- contentText.add(apiData.getReturn());
- contentData.add(apiData.getReturn());
-
- String errMsg = ErrorCodeManager.getInatance()
- .getErrorCode(apiData.getErrno()).name();
- if (null == errMsg) {
- errMsg = "undefined error code";
- }
- contentText.add(errMsg);
- contentData.add(errMsg);
-
- DATableDataFormat tableData = new DATableDataFormat(apiData.getSeq());
- tableData.setLogData(apiData);
- tableData.getData().addAll(contentData);
- TableInput tableInput = new TableInput();
- tableInput.setText(contentText);
- tableInput.setData(tableData);
- if (!errMsg.contains("SUCCESS")) {//$NON-NLS-1$
- tableInput.setFailed(true);
- }
- input.add(tableInput);
-
- if (apiData.getTime() >= rangeStartTime && apiData.getTime() <= rangeEndTime) {
- tableInput.setInRange(true);
- }
+ while (rs.next()) {
+ returnList.add(makeProbeCommonData(rs));
}
} catch (SQLException e) {
e.printStackTrace();
SqlConnectionManager.releaseResultSet(rs);
}
}
-
- return input;
+ return returnList;
}
- protected void actionSetStartEnd(int type) {
- GridItem item = table.getItem(mousePoint);
- if (null != item) {
- LogData data = ((DATableDataFormat) item.getData()).getLogData();
- long inputTime = data.getTime();
- double startTime = -1;
- double endTime = -1;
-
- if (type == START_TIME) {
- rangeDataManager.setMarkerStartTime(inputTime);
- startTime = inputTime / TimelineConstants.MEGA_DOUBLE;
- endTime = rangeDataManager.getMarkerEndTime()
- / TimelineConstants.MEGA_DOUBLE;
-
- } else if (type == END_TIME) {
- rangeDataManager.setMarkerEndTime(inputTime);
- endTime = inputTime / TimelineConstants.MEGA_DOUBLE;
- startTime = rangeDataManager.getMarkerStartTime()
- / TimelineConstants.MEGA_DOUBLE;
+ private List<ProbeCommonData> getSyncAPIOfNotInsert(int selectID) {
+ List<ProbeCommonData> returnList = new ArrayList<ProbeCommonData>();
+ List<ThreadPageSyncDataEvent> notInsertList = ThreadDataManager.getInstance()
+ .getSyncDataMaker().getNotInsertSyncEventList();
+ for (ThreadPageSyncDataEvent event : notInsertList) {
+ if (event.getSyncDataID() != selectID) {
+ continue;
}
-
- ThreadChartView chartview = (ThreadChartView) (AnalyzerManager
- .getCurrentPage().getView(ThreadPage.chartViewID));
-
- chartview.setRangeMarker(startTime, endTime);
+ returnList.add((SyncData) event.getContents());
}
+ return returnList;
}
-
+
+ private void sortListByTime(List<ProbeCommonData> list) {
+ Comparator<ProbeCommonData> comparator = new Comparator<ProbeCommonData>() {
+ @Override
+ public int compare(ProbeCommonData arg0, ProbeCommonData arg1) {
+ if (arg0.getTime() > arg1.getTime()) {
+ return 1;
+ } else if (arg0.getTime() < arg1.getTime()) {
+ return -1;
+ } else {
+ return 0;
+ }
+ }
+ };
+ Collections.sort(list, comparator);
+ }
+
private ProbeCommonData makeProbeCommonData(ResultSet rs) {
ProbeCommonData pData = null;
try {
String args = rs.getString(API.ARGUMENT.index);
String returnValue = rs.getString(API.RETURN.index);
int errorno = rs.getInt(API.ERRORNO.index);
-
+
pData = new ProbeCommonData(seq, time, apiID, pid, tid, args, returnValue, errorno);
} catch (SQLException e) {
e.printStackTrace();
* Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
*
* Contact:
+ * Hyunjong Park <phjwithyou.park@samsung.com>
* WooJin Jung <woojin2.jung@samsung.com>
* yeongtaik byeon <yeongtaik.byeon@samsung.com>
* Jooyoul Lee <jy.exe.lee@samsung.com>
import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;
import org.tizen.dynamicanalyzer.resources.ColorResources;
import org.tizen.dynamicanalyzer.ui.range.RangeDataManager;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageData;
+import org.tizen.dynamicanalyzer.ui.timeline.TimelinePage;
import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
import org.tizen.dynamicanalyzer.ui.widgets.table.TableColumnSizePackListener;
import org.tizen.dynamicanalyzer.widgets.da.view.DAViewComposite;
private long selectionEndTime = 0;
private int preSelectionPid = -1;
- private String[] columnNames = {
- ThreadPageLabels.THREAD_API_LIST_VIEW_INDEX,
- ThreadPageLabels.THREAD_API_LIST_VIEW_TIME,
- ThreadPageLabels.THREAD_API_LIST_VIEW_PID,
+ private String[] columnNames = { ThreadPageLabels.THREAD_API_LIST_VIEW_INDEX,
+ ThreadPageLabels.THREAD_API_LIST_VIEW_TIME, ThreadPageLabels.THREAD_API_LIST_VIEW_PID,
ThreadPageLabels.THREAD_API_LIST_VIEW_THREAD_ID,
ThreadPageLabels.THREAD_API_LIST_VIEW_NAME,
ThreadPageLabels.THREAD_API_LIST_VIEW_PARAMETER,
private int[] columnSizes = { 35, 70, 45, 45, 180, 240, 75, 100 };
- private int[] columnAlignment = { SWT.RIGHT, SWT.LEFT, SWT.LEFT, SWT.LEFT,
- SWT.LEFT, SWT.LEFT, SWT.LEFT, SWT.LEFT };
+ private int[] columnAlignment = { SWT.RIGHT, SWT.LEFT, SWT.LEFT, SWT.LEFT, SWT.LEFT, SWT.LEFT,
+ SWT.LEFT, SWT.LEFT };
- int[] sortTypes = { AnalyzerConstants.SORT_TYPE_NUM,
+ int[] sortTypes = { AnalyzerConstants.SORT_TYPE_NUM, 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_STRING };
-
- // int[] sourceColumns = { LogCenterConstants.SEQUENCE_NUMBER_INDEX,
- // LogCenterConstants.TIME_INDEX, LogCenterConstants.APINAME_INDEX,
- // LogCenterConstants.INPUTPARM_INDEX,
- // LogCenterConstants.THREAD_ID_INDEX,
- // LogCenterConstants.RETURN_INDEX, LogCenterConstants.ERROR_INDEX };
+ AnalyzerConstants.SORT_TYPE_STRING, AnalyzerConstants.SORT_TYPE_STRING,
+ AnalyzerConstants.SORT_TYPE_STRING, AnalyzerConstants.SORT_TYPE_STRING };
ThreadAPIListTable tableComp = null;
Composite contents = getContentArea();
contents.setBackground(ColorResources.WINDOW_BG_COLOR);
contents.setLayout(new FillLayout());
- tableComp = new ThreadAPIListTable(contents, SWT.NONE, SWT.MULTI
- | SWT.BORDER | SWT.FULL_SELECTION | SWT.H_SCROLL | SWT.V_SCROLL);
+ tableComp = new ThreadAPIListTable(contents, SWT.NONE, SWT.MULTI | SWT.BORDER
+ | SWT.FULL_SELECTION | SWT.H_SCROLL | SWT.V_SCROLL);
tableComp.setTableName("Thread API List");
tableComp.setSortTypes(sortTypes);
- // tableComp.setSourceColumns(sourceColumns);
tableComp.setColumnAlignment(columnAlignment);
tableComp.setColumns(columnNames);
tableComp.setColumnSize(columnSizes);
- contents.addControlListener(new TableColumnSizePackListener(tableComp,
- columnSizes));
+ contents.addControlListener(new TableColumnSizePackListener(tableComp, columnSizes));
}
@Override
long newAnalysisEndTime = 0;
if (RangeDataManager.getInstance().isBeingAnalyzed()) {
- newAnalysisStartTime = RangeDataManager.getInstance()
- .getAnalysisStartTime();
- newAnalysisEndTime = RangeDataManager.getInstance()
- .getAnalysisEndTime();
+ newAnalysisStartTime = RangeDataManager.getInstance().getAnalysisStartTime();
+ newAnalysisEndTime = RangeDataManager.getInstance().getAnalysisEndTime();
} else {
newAnalysisStartTime = 0;
newAnalysisEndTime = 0;
}
- if (newAnalysisStartTime != analysisStartTime
- || newAnalysisEndTime != analysisEndTime) {
+ if (newAnalysisStartTime != analysisStartTime || newAnalysisEndTime != analysisEndTime) {
analysisStartTime = newAnalysisStartTime;
analysisEndTime = newAnalysisEndTime;
tableComp.updateTable();
}
preSelectionPid = selectedPid;
- if (tableComp.getTable().getItemCount() > 0
- && data.getContents().size() != tableComp.getTable()
- .getItemCount()) {
- tableComp.updateTable();
- }
+ tableComp.updateTable();
}
@Override
public void updateView(DAViewData vdata) {
- if (vdata instanceof DASelectionData) {
- DASelectionData data = (DASelectionData) vdata;
- ThreadPageData pageData;
-
- if (data.getData() instanceof ThreadPageData) {
- pageData = (ThreadPageData) data.getData();
- this.data = pageData;
- } else if (data.getData() instanceof Integer) {
- this.data = null;
- }
+ if(vdata.getViewID().equals(TimelinePage.timelineViewID)){
+ return;
+ }
+ if (vdata instanceof DASelectionData == false) {
+ return;
+ }
+ tableComp.clear();
+ DASelectionData data = (DASelectionData) vdata;
+ ThreadPageData pageData;
+
+ if (data.getData() instanceof ThreadPageData) {
+ pageData = (ThreadPageData) data.getData();
+ this.data = pageData;
+ } else if (data.getData() instanceof Integer) {
+ this.data = null;
+ }
- selectionStartTime = data.getStartTime();
- selectionEndTime = data.getEndTime();
+ selectionStartTime = data.getStartTime();
+ selectionEndTime = data.getEndTime();
- tableComp.getTable().removeAll();
- tableComp.updateTable();
- tableComp.setSelectionByTime(selectionStartTime, selectionEndTime);
- }
+ tableComp.getTable().removeAll();
+ tableComp.updateTable();
+ tableComp.setSelectionByTime(selectionStartTime, selectionEndTime);
}
@Override
+++ /dev/null
-/*
- * Dynamic Analyzer
- *
- * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * WooJin Jung <woojin2.jung@samsung.com>
- * yeongtaik byeon <yeongtaik.byeon@samsung.com>
- * Juyoung Kim <j0.kim@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-
-package org.tizen.dynamicanalyzer.ui.thread;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-
-import org.tizen.dynamicanalyzer.database.SqlConnectionManager;
-import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;
-import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants;
-import org.tizen.dynamicanalyzer.swap.logparser.LogPackage;
-import org.tizen.dynamicanalyzer.swap.logparser.Logs;
-import org.tizen.dynamicanalyzer.swap.logparser.PageDataManager;
-import org.tizen.dynamicanalyzer.swap.model.data.LogData;
-import org.tizen.dynamicanalyzer.ui.thread.data.SyncAPIDBTable;
-import org.tizen.dynamicanalyzer.ui.thread.data.SyncDataDBTable;
-import org.tizen.dynamicanalyzer.ui.thread.data.SyncEventDBTable;
-import org.tizen.dynamicanalyzer.ui.thread.data.ThreadAPIDBTable;
-import org.tizen.dynamicanalyzer.ui.thread.data.ThreadDataDBTable;
-import org.tizen.dynamicanalyzer.ui.thread.data.ThreadEventDBTable;
-import org.tizen.dynamicanalyzer.ui.thread.sync.ThreadPageSyncData;
-import org.tizen.dynamicanalyzer.ui.thread.sync.ThreadPageSyncDataEvent;
-import org.tizen.dynamicanalyzer.ui.thread.sync.ThreadPageSyncDataManager;
-import org.tizen.dynamicanalyzer.ui.thread.thread.ThreadPageThreadData;
-import org.tizen.dynamicanalyzer.ui.thread.thread.ThreadPageThreadDataEvent;
-import org.tizen.dynamicanalyzer.ui.thread.thread.ThreadPageThreadDataManager;
-import org.tizen.dynamicanalyzer.util.Logger;
-import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoard;
-
-public class ThreadChartManager extends PageDataManager {
- private static ThreadChartManager instance = null;
-
- private ThreadDataDBTable threadDataTable = null;
- private ThreadEventDBTable threadEventTable = null;
- private ThreadAPIDBTable threadAPITable = null;
-
- private SyncDataDBTable syncDataTable = null;
- private SyncEventDBTable syncEventTable = null;
- private SyncAPIDBTable syncAPITable = null;
-
- private ThreadPageThreadDataManager tManager;
- private ThreadPageSyncDataManager sManager;
-
- private enum THREADEVENT {
- EVENTTIME(0),
- TID(1),
- APITYPE(2),
- TOOLTIP(3),
- ERRORNO(4),
- EVENTTYPE(5),
- THREADTYPE(6),
- CALLERID(7);
-
- public final int index;
-
- THREADEVENT(int index) {
- this.index = index;
- }
- }
-
- private enum SYNCEVENT {
- EVENTTIME(0),
- APITYPE(1),
- TOOLTIP(2),
- ERRORNO(3),
- SYNCVALUE(4);
-
- public final int index;
-
- SYNCEVENT(int index) {
- this.index = index;
- }
- }
-
- private ThreadChartManager() {
- threadDataTable = new ThreadDataDBTable();
- threadEventTable = new ThreadEventDBTable();
- threadAPITable = new ThreadAPIDBTable();
-
- syncDataTable = new SyncDataDBTable();
- syncEventTable = new SyncEventDBTable();
- syncAPITable = new SyncAPIDBTable();
-
- tManager = new ThreadPageThreadDataManager(null);
- sManager = new ThreadPageSyncDataManager(null);
- }
-
- public static ThreadChartManager getInstance() {
- if (null == instance) {
- instance = new ThreadChartManager();
- }
- return instance;
- }
-
- public ThreadPageThreadDataManager getThreadDataManager() {
- return tManager;
- }
-
- public ThreadEventDBTable getThreadEventDBTable() {
- return threadEventTable;
- }
-
- public ThreadAPIDBTable getThreadAPIDBTable() {
- return threadAPITable;
- }
-
- public SyncDataDBTable getSyncDataDBTable() {
- return syncDataTable;
- }
-
- public SyncEventDBTable getSyncEventDBTable() {
- return syncEventTable;
- }
-
- public SyncAPIDBTable getSyncAPIDBTable() {
- return syncAPITable;
- }
-
- private List<LogData> getLogsFromLogPackage(LogPackage logPack,
- int logCenterConstants) {
- Logs logs = logPack.getLogs(logCenterConstants);
- if (null == logs || logs.getRawLogs().size() == 0) {
- return null;
- }
- List<LogData> ret = logs.getLogs();
-
- return ret;
- }
-
- public void update() {
- tManager.checkUpdate();
- sManager.checkUpdate();
- }
-
- public void clear() {
- tManager.clear();
- sManager.clear();
- }
-
- @Override
- protected void onThreadStop() {
- saveRemainingThreadData();
- }
-
- private void saveRemainingThreadData() {
- // ThreadPageThreadData
- List<ThreadPageThreadData> remainedThreadData = tManager.getRows();
- int size = remainedThreadData.size();
- for (int i = 0; i < size; i++) {
- ThreadPageThreadData threadData = remainedThreadData.get(i);
- if (threadData.getEndTime() < 0) {
- saveThreadPageThreadData(threadData);
- }
- }
- }
-
- public void openData(Map<String, String> dataMap) {
- openThreadData();
- }
-
- private void openThreadData() {
- //TODO: use ResultSet
- // load ThreadPageThreadData
- List<List<Object>> threadDatas = threadDataTable.getThreadDataFromDB();
- int size = threadDatas.size();
- for (int i = 0; i < size; i++) {
- List<Object>rowData = threadDatas.get(i);
- int id = (Integer) rowData.get(ThreadDataDBTable.COLUMN.THREADDATAID.index);
- int pid = (Integer) rowData.get(ThreadDataDBTable.COLUMN.PID.index);
- int tid = (Integer) rowData.get(ThreadDataDBTable.COLUMN.TID.index);
- byte threadType = (Byte) rowData.get(ThreadDataDBTable.COLUMN.THREADTYPE.index);
- byte attrType = (Byte) rowData.get(ThreadDataDBTable.COLUMN.ATTRIBUTETYPE.index);
- String attributeType = ThreadPageThreadDataManager.getAttrTypeByTypeInt(attrType);
- long startTime = (Long) rowData.get(ThreadDataDBTable.COLUMN.STARTTIME.index);
- long endTime = (Long) rowData.get(ThreadDataDBTable.COLUMN.ENDTIME.index);
- int functionID = (Integer) rowData.get(ThreadDataDBTable.COLUMN.FUNCTIONID.index);
- String className = (String) rowData.get(ThreadDataDBTable.COLUMN.CLASSNAME.index);
-
- ThreadPageThreadData threadData = new ThreadPageThreadData(id, pid, tid, threadType,
- attributeType, startTime, endTime, functionID, className);
- tManager.pushRow(threadData);
-
- // load ThreadPageThreadDataEvent for the ThreadPageThreadData
- String query = String.format(ThreadEventDBTable.SELECT_QUERY, id);
- List<List<Object>> threadEvents = SqlConnectionManager.executeQuery(query);
- int eventSize = threadEvents.size();
- for (int j = 0; j < eventSize; j++) {
- ThreadPageThreadDataEvent threadEvent = makeThreadEvent(threadEvents.get(j));
- threadData.pushEvent(threadEvent);
- }
- }
-
- // load ThreadPageSyncData
-// List<List<Object>> syncDatas = SqlConnectionManager.executeQuery(SyncDataDBTable.SELECT_QUERY);
- List<List<Object>> syncDatas = syncDataTable.getSyncDataFromDB();
- int syncSize = syncDatas.size();
- for (int i = 0; i < syncSize; i++) {
- ThreadPageSyncData syncData = makeSyncData(syncDatas.get(i));
- // load ThreadPageSyncDataEvent for the ThreadPageSyncData
- String query = String.format(SyncEventDBTable.SELECT_QUERY, syncData.getSyncDataID());
- List<List<Object>> syncEvents = SqlConnectionManager.executeQuery(query);
- int eventSize = syncEvents.size();
- for (int j = 0; j < eventSize; j++) {
- ThreadPageSyncDataEvent syncEvent = makeSyncEvent(syncEvents.get(j));
- syncData.pushEvent(syncEvent);
- }
-
- switch (syncData.getSyncDataType()) {
- case ThreadPageSyncData.SYNC_PARENT:
- case ThreadPageSyncData.SYNC_CHILD:
- sManager.pushRow(syncData);
- break;
- case ThreadPageSyncData.THREAD_CHILD:
- tManager.pushSyncData(syncData);
- break;
- default:
- Logger.error("unknown sync data type");
- }
- }
- }
-
- private ThreadPageThreadDataEvent makeThreadEvent(List<Object> rowData) {
- ThreadPageThreadDataEvent threadEvent = null;
- long time = (Long) rowData.get(THREADEVENT.EVENTTIME.index);
- int tid = (Integer) rowData.get(THREADEVENT.TID.index);
- String tidStr = String.valueOf(tid);
- byte apiType = (Byte) rowData.get(THREADEVENT.APITYPE.index);
- String tooltip = (String) rowData.get(THREADEVENT.TOOLTIP.index);
- long errorNum = (Long) rowData.get(THREADEVENT.ERRORNO.index);
- byte eventType = (Byte) rowData.get(THREADEVENT.EVENTTYPE.index);
- int threadType = (Integer) rowData.get(THREADEVENT.THREADTYPE.index);
- int callerId = (Integer) rowData.get(THREADEVENT.CALLERID.index);
- String callerIdStr = null;
- if (callerId != -1) {
- callerIdStr = String.valueOf(callerId);
- }
-
- threadEvent = new ThreadPageThreadDataEvent(eventType, threadType, apiType, time,
- tidStr, tooltip, errorNum, null);
- threadEvent.setCallerTid(callerIdStr);
-
- return threadEvent;
- }
-
- private ThreadPageSyncData makeSyncData(List<Object> rowData) {
- ThreadPageSyncData syncData = null;
- int id = (Integer) rowData.get(SyncDataDBTable.COLUMN.SYNCDATAID.index);
- int pid = (Integer) rowData.get(SyncDataDBTable.COLUMN.PID.index);
- int tid = (Integer) rowData.get(SyncDataDBTable.COLUMN.TID.index);
- byte syncType = (Byte) rowData.get(SyncDataDBTable.COLUMN.SYNCTYPE.index);
- long syncValue = (Long) rowData.get(SyncDataDBTable.COLUMN.SYNCVALUE.index);
- byte attrType = (Byte) rowData.get(SyncDataDBTable.COLUMN.ATTRIBUTETYPE.index);
- String attributeType = ThreadPageSyncDataManager.getAttrTypeByTypeInt(attrType);
- byte syncDataType = (Byte) rowData.get(SyncDataDBTable.COLUMN.SYNCDATATYPE.index);
- int parentID = (Integer) rowData.get(SyncDataDBTable.COLUMN.PARENTID.index);
-
- syncData = new ThreadPageSyncData(id, pid, tid, syncType, syncValue, attributeType,
- syncDataType, parentID);
-
- return syncData;
- }
-
- private ThreadPageSyncDataEvent makeSyncEvent(List<Object> rowData) {
- ThreadPageSyncDataEvent syncEvent = null;
- long time = (Long) rowData.get(SYNCEVENT.EVENTTIME.index);
- byte apiType = (Byte) rowData.get(SYNCEVENT.APITYPE.index);
- String tooltip = (String) rowData.get(SYNCEVENT.TOOLTIP.index);
- long errorNum = (Long) rowData.get(SYNCEVENT.ERRORNO.index);
- long syncValue = (Long) rowData.get(SYNCEVENT.SYNCVALUE.index);
- String syncValueStr = String.valueOf(syncValue);
-
- syncEvent = new ThreadPageSyncDataEvent(time, apiType, tooltip, errorNum, syncValueStr);
-
- return syncEvent;
- }
-
- public int getItemIndexByTid(String tid) {
- return tManager.getItemIndexByTid(tid);
- }
-
- // FIXME
- public void setBoard(DAChartBoard threadBoard, DAChartBoard syncBoard) {
- tManager.setBoard(threadBoard);
- sManager.setBoard(syncBoard);
- }
-
- @Override
- protected void makeData(LogPackage pack) {
- List<LogData> loadInputs = getLogsFromLogPackage(pack,
- DataChannelConstants.MSG_DATA_SYSTEM);
- if (null != loadInputs) {
- int logSize = loadInputs.size();
- for (int i = 0; i < logSize; i++) {
- tManager.parseLoad(loadInputs.get(i));
- }
- }
-
- List<LogData> threadInputs = getLogsFromLogPackage(pack,
- DataChannelConstants.MSG_PROBE_THREAD);
- if (null != threadInputs) {
- int logSize = threadInputs.size();
- for (int i = 0; i < logSize; i++) {
- tManager.parseAPI(threadInputs.get(i));
- }
- }
-
- List<LogData> syncInputs = getLogsFromLogPackage(pack,
- DataChannelConstants.MSG_PROBE_SYNC);
- if (null != syncInputs) {
- int logSize = syncInputs.size();
- for (int i = 0; i < logSize; i++) {
- tManager.parseSync(syncInputs.get(i));
- sManager.parseSync(syncInputs.get(i));
- }
- }
- }
-
- public void saveThreadPageThreadData(ThreadPageData threadPageData) {
- List<List<Object>> insertData = new ArrayList<List<Object>>();
- List<Object> insertRowData = new ArrayList<Object>();
-
- if (threadPageData instanceof ThreadPageThreadData) {
- ThreadPageThreadData threadData = (ThreadPageThreadData) threadPageData;
- try {
- insertRowData.add(new Integer(threadData.getThreadDataID()));
- insertRowData.add(new Integer(threadData.getPid()));
- insertRowData.add(new Integer(threadData.getTid()));
- Integer type = new Integer(threadData.getType());
- byte threadType = type.byteValue();
- insertRowData.add(new Byte(threadType));
- String attrTypeStr = threadData.getAttrType();
- byte attrType = -1;
- if (attrTypeStr.equals(ThreadPageLabels.THREAD_ATTR_TYPE_JOINABLE)) {
- attrType = ThreadPageThreadDataManager.PTHREAD_CREATE_JOINABLE;
- } else if (attrTypeStr.equals(ThreadPageLabels.THREAD_ATTR_TYPE_DETACHED)) {
- attrType = ThreadPageThreadDataManager.PTHREAD_CREATE_DETACHED;
- } else { // main thread has no attribute
- attrType = -1;
- }
- insertRowData.add(new Byte(attrType));
- insertRowData.add(new Long(threadData.getStartTime()));
- insertRowData.add(new Long(threadData.getEndTime()));
- insertRowData.add(new Integer(threadData.getThreadFuncID()));
- insertRowData.add(new String(threadData.getThreadClassName()));
- } catch (ArrayIndexOutOfBoundsException e) {
- e.printStackTrace();
- }
- insertData.add(insertRowData);
- } else if (threadPageData instanceof ThreadPageSyncData) {
-
- } else {
- Logger.error("Unknown ThreadPageData type!");
- }
-
- if (insertData.size() > 0) {
- threadDataTable.insertData(insertData);
- }
- }
-}
\ No newline at end of file
* Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
*
* Contact:
+ * Hyunjong Park <phjwithyou.park@samsung.com>
* WooJin Jung <woojin2.jung@samsung.com>
* yeongtaik byeon <yeongtaik.byeon@samsung.com>
* Jooyoul Lee <jy.exe.lee@samsung.com>
import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;
import org.tizen.dynamicanalyzer.resources.ColorResources;
import org.tizen.dynamicanalyzer.resources.FontResources;
-import org.tizen.dynamicanalyzer.ui.thread.sync.ThreadPageSyncData;
-import org.tizen.dynamicanalyzer.ui.thread.thread.ThreadPageThreadData;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageData;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageSyncData;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageThreadData;
+import org.tizen.dynamicanalyzer.ui.timeline.TimelinePage;
import org.tizen.dynamicanalyzer.widgets.da.view.DAViewComposite;
import org.tizen.dynamicanalyzer.widgets.da.view.DAViewData;
private Composite contents = null;
private Text detailText = null;
- private final static String leftFormAttachment = CommonConstants.SPACE
- + CommonConstants.SPACE;
+ private final static String leftFormAttachment = CommonConstants.SPACE + CommonConstants.SPACE;
private final static String heightFormAttachment = CommonConstants.NEW_LINE
+ CommonConstants.NEW_LINE;
contents.setBackground(ColorResources.VIEW_BG_COLOR);
contents.setLayout(new FormLayout());
- detailText = new Text(contents, SWT.BORDER | SWT.V_SCROLL
- | SWT.H_SCROLL);
+ 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);
String str;
if (item instanceof ThreadPageThreadData) {
- tid = item.getTid();
+ tid = Integer.toString(item.getTid());
type = ((ThreadPageThreadData) item).getTypeString();
str = ((ThreadPageThreadData) item).getThreadFuncName();
if (null != str && !(str.equals(CommonConstants.EMPTY))) {
List<ThreadPageSyncData> children = syncItem.getChildren();
int childrenSize = children.size();
if (0 == childrenSize) {
- tid = item.getTid();
+ tid = Integer.toString(item.getTid());
}
str = item.getAttrType();
if (null != str && !(str.equals(CommonConstants.EMPTY))) {
}
}
- StringBuffer strDetailView = new StringBuffer(heightFormAttachment);
- addDetailInfo(strDetailView, ThreadPageLabels.THREAD_DETAILS_TYPE
- + type);
+ StringBuffer strDetailView = new StringBuffer(CommonConstants.NEW_LINE);
+ addDetailInfo(strDetailView, ThreadPageLabels.THREAD_DETAILS_TYPE + type);
if (null != tid && !(tid.equals(CommonConstants.EMPTY))) {
- addDetailInfo(strDetailView, ThreadPageLabels.THREAD_DETAILS_TID
- + tid);
+ addDetailInfo(strDetailView, ThreadPageLabels.THREAD_DETAILS_TID + tid);
}
if (type.equals(ThreadPageLabels.THREAD_ITEM_TYPE_TIZEN)) {
if (null != className && !(className.equals(CommonConstants.EMPTY))) {
- addDetailInfo(strDetailView,
- ThreadPageLabels.THREAD_DETAILS_CLASSNAME + className);
+ addDetailInfo(strDetailView, ThreadPageLabels.THREAD_DETAILS_CLASSNAME + className);
}
} else {
if (null != funcName && !(funcName.equals(CommonConstants.EMPTY))) {
- addDetailInfo(strDetailView,
- ThreadPageLabels.THREAD_DETAILS_FUNCNAME + funcName);
+ addDetailInfo(strDetailView, ThreadPageLabels.THREAD_DETAILS_FUNCNAME + funcName);
}
}
if (null != startTime && !(startTime.equals(CommonConstants.EMPTY))) {
- addDetailInfo(strDetailView,
- ThreadPageLabels.THREAD_DETAILS_STARTTIME + startTime);
+ addDetailInfo(strDetailView, ThreadPageLabels.THREAD_DETAILS_STARTTIME + startTime);
}
if (null != endTime && !(endTime.equals(CommonConstants.EMPTY))) {
- addDetailInfo(strDetailView,
- ThreadPageLabels.THREAD_DETAILS_ENDTIME + endTime);
+ addDetailInfo(strDetailView, ThreadPageLabels.THREAD_DETAILS_ENDTIME + endTime);
}
if (null != attrType && !(attrType.equals(CommonConstants.EMPTY))) {
- addDetailInfo(strDetailView,
- ThreadPageLabels.THREAD_DETAILS_ATTRTYPE + attrType);
+ addDetailInfo(strDetailView, ThreadPageLabels.THREAD_DETAILS_ATTRTYPE + attrType);
}
detailText.setText(strDetailView.toString());
detailText.redraw();
private boolean isChange() {
if (item instanceof ThreadPageThreadData) {
- if (!tid.equals(item.getTid())) {
+ if (!tid.equals(Integer.toString(item.getTid()))) {
return true;
}
if (!type.equals(((ThreadPageThreadData) item).getTypeString())) {
return true;
}
- if (!funcName.equals(((ThreadPageThreadData) item)
- .getThreadFuncName())) {
+ if (!funcName.equals(((ThreadPageThreadData) item).getThreadFuncName())) {
return true;
}
- if (!className.equals(((ThreadPageThreadData) item)
- .getThreadClassName())) {
+ if (!className.equals(((ThreadPageThreadData) item).getThreadClassName())) {
return true;
}
- if (!startTime.equals(((ThreadPageThreadData) item)
- .getStartTimeString())) {
+ if (!startTime.equals(((ThreadPageThreadData) item).getStartTimeString())) {
return true;
}
- if (!endTime.equals(((ThreadPageThreadData) item)
- .getEndTimeString())) {
+ if (!endTime.equals(((ThreadPageThreadData) item).getEndTimeString())) {
return true;
}
if (!attrType.equals(item.getAttrType())) {
return true;
}
} else if (item instanceof ThreadPageSyncData) {
- if (!tid.equals(item.getTid())) {
+ if (!tid.equals(Integer.toString(item.getTid()))) {
return true;
}
if (!attrType.equals(item.getAttrType())) {
@Override
public void updateView(DAViewData vdata) {
- if (vdata instanceof DASelectionData) {
- DASelectionData data = (DASelectionData) vdata;
- String id = data.getViewID();
- if (!(id.equals(ThreadPage.chartViewID))) {
- return;
- }
- if (data.getData() instanceof ThreadPageData) {
- item = (ThreadPageData) data.getData();
- } else {
- item = null;
- }
-
- updateDetails();
+ if(vdata.getViewID().equals(TimelinePage.timelineViewID)){
+ return;
+ }
+ if (vdata instanceof DASelectionData == false) {
+ return;
+ }
+ DASelectionData data = (DASelectionData) vdata;
+ String id = data.getViewID();
+ if (!(id.equals(ThreadPage.chartViewID))) {
+ return;
+ }
+ if (data.getData() instanceof ThreadPageData) {
+ item = (ThreadPageData) data.getData();
+ } else {
+ item = null;
}
+ updateDetails();
}
@Override
* Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
*
* Contact:
+ * Hyunjong Park <phjwithyou.park@samsung.com>
* WooJin Jung <woojin2.jung@samsung.com>
* yeongtaik byeon <yeongtaik.byeon@samsung.com>
* Jooyoul Lee <jy.exe.lee@samsung.com>
import org.tizen.dynamicanalyzer.shortcut.ShortCutManager;
import org.tizen.dynamicanalyzer.swap.logparser.DataManagerRegistry;
import org.tizen.dynamicanalyzer.ui.page.ScreenshotTabComposite;
+import org.tizen.dynamicanalyzer.ui.thread.chart.ThreadChartView;
+import org.tizen.dynamicanalyzer.ui.thread.data.ThreadDataManager;
import org.tizen.dynamicanalyzer.widgets.da.view.DAPageComposite;
public class ThreadPage extends DAPageComposite {
public ThreadPage(Composite parent, int style) {
super(parent, style);
setTitle(AnalyzerLabels.COOLBAR_AREA_THREAD);
- this.setData(DAPageComposite.KEY_TOOLTIP,
- ShortCutManager.COOLBAR_AREA_THREAD_TOOLTIP);
+ this.setData(DAPageComposite.KEY_TOOLTIP, ShortCutManager.COOLBAR_AREA_THREAD_TOOLTIP);
this.setLayout(new FillLayout());
baseForm = new SashForm(this, SWT.HORIZONTAL);
baseForm.setLayout(new FillLayout());
leftForm = new SashForm(baseForm, SWT.VERTICAL);
- ThreadChartView threadChartView = new ThreadChartView(leftForm,
- SWT.NONE);
+ ThreadChartView threadChartView = new ThreadChartView(leftForm, SWT.NONE);
addView(threadChartView);
- ThreadAPIListView threadAPIListView = new ThreadAPIListView(leftForm,
- SWT.NONE);
+ ThreadAPIListView threadAPIListView = new ThreadAPIListView(leftForm, SWT.NONE);
addView(threadAPIListView);
leftForm.setWeights(new int[] { 60, 40 });
rightForm = new SashForm(baseForm, SWT.VERTICAL);
- // INFO_VIEW_INDEX = 2;
-
- ScreenshotTabComposite tabView = new ScreenshotTabComposite(rightForm,
- SWT.NONE, ThreadPage.pageID);
+
+ ScreenshotTabComposite tabView = new ScreenshotTabComposite(rightForm, SWT.NONE,
+ ThreadPage.pageID);
tabView.setObservingViews(ScreenshotTabComposite.screenshotViewID,
new String[] { ThreadPage.listViewID });
tabView.setObservingViews(ScreenshotTabComposite.callstackViewID,
new String[] { ThreadPage.listViewID });
addView(tabView);
- // FILE_DETAIL = 3;
- ThreadDetailInfoView detailInfo = new ThreadDetailInfoView(rightForm,
- SWT.NONE);
+ ThreadDetailInfoView detailInfo = new ThreadDetailInfoView(rightForm, SWT.NONE);
addView(detailInfo);
rightForm.setWeights(new int[] { 50, 50 });
baseForm.setSashWidth(AnalyzerConstants.SASH_WIDTH);
leftForm.setSashWidth(AnalyzerConstants.SASH_WIDTH);
rightForm.setSashWidth(AnalyzerConstants.SASH_WIDTH);
-
- DataManagerRegistry.registerPageDataManager(ThreadChartManager.getInstance());
+
+ DataManagerRegistry.registerPageDataManager(ThreadDataManager.getInstance());
}
@Override
+++ /dev/null
-/*
- * Dynamic Analyzer
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * WooJin Jung <woojin2.jung@samsung.com>
- * yeongtaik byeon <yeongtaik.byeon@samsung.com>
- * Juyoung Kim <j0.kim@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-package org.tizen.dynamicanalyzer.ui.thread;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;
-import org.tizen.dynamicanalyzer.resources.ColorResources;
-import org.tizen.dynamicanalyzer.widgets.chart.DAChart;
-import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeriesItem;
-import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoardItem;
-
-public abstract class ThreadPageData {
- private String pid;
- private String tid;
- private int type;
- private String key;
- private String attrType;
- protected DAChartBoardItem item;
- protected List<ThreadPageDataEvent> contents = new ArrayList<ThreadPageDataEvent>();
- protected List<ThreadPageDataEvent> contentsQueue = new ArrayList<ThreadPageDataEvent>();
- protected DAChart chart;
- protected boolean hasUpdate = false;
-
- public ThreadPageData(int type, String name, String pid, String tid, String attrType) {
- setType(type);
- setKey(name);
- setPid(pid);
- setTid(tid);
- setAttrType(attrType);
- }
-
- public String getTid() {
- return tid;
- }
-
- public void setTid(String tid) {
- this.tid = tid;
- }
-
- public String getPid() {
- return pid;
- }
-
- public void setPid(String pid) {
- this.pid = pid;
- }
-
- public int getType() {
- return type;
- }
-
- public void setType(int type) {
- this.type = type;
- }
-
- public String getKey() {
- return key;
- }
-
- public void setKey(String name) {
- this.key = name;
- }
-
- public DAChartBoardItem getItem() {
- return item;
- }
-
- public DAChart getChart() {
- return chart;
- }
-
- public void setChart(DAChart chart) {
- this.chart = chart;
- }
-
- public 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(DAChartBoardItem item);
-
- protected abstract int createChartItem(ThreadPageDataEvent event);
-
- public String getAttrType() {
- return attrType;
- }
-
- public void setAttrType(String attrType) {
- this.attrType = attrType;
- }
-
- protected DAChartSeriesItem createApiItem(
- ThreadPageDataEvent event, long errno) {
- DAChartSeriesItem apiItem = null;
- if (0 != errno) {
- apiItem = new DAChartSeriesItem(event.getDoubleTime(),
- DAChartSeriesItem.SERIES_STATE_BAR,
- ColorResources.RED, event.getTooltipContent()
- + ThreadPageLabels.SYNC_CHART_ITEM_FAILED);
- } else {
- apiItem = new DAChartSeriesItem(event.getDoubleTime(),
- DAChartSeriesItem.SERIES_STATE_BAR,
- ColorResources.YELLOW, event.getTooltipContent());
- }
- return apiItem;
- }
-}
\ No newline at end of file
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Hyunjong Park <phjwithyou.park@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.chart;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.tizen.dynamicanalyzer.constant.CommonConstants;
+import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
+import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;
+import org.tizen.dynamicanalyzer.resources.ColorResources;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageDataEvent;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageSyncDataEvent;
+import org.tizen.dynamicanalyzer.utils.Formatter;
+import org.tizen.dynamicanalyzer.widgets.chart.DAChart;
+import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeries;
+import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeriesItem;
+import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoardItem;
+
+public class SyncChart {
+ public final static int SYNC_PARENT_CHART = 0;
+ public final static int SYNC_CHILD_CHART = 1;
+ public final static int THREAD_CHART = 2;
+ protected int chartType = -1;;
+ protected DAChartBoardItem item;
+ protected DAChart chart;
+ protected List<SyncChart> children = new ArrayList<SyncChart>();
+ protected DAChartSeries syncAPISeries;
+ protected DAChartSeries syncStateSeries;
+
+ protected String chartName = CommonConstants.EMPTY;
+ protected int chartID = -1;
+ protected int pId = -1;
+ protected int tId = -1;
+
+ public SyncChart(int chartId, DAChartBoardItem item, DAChart chart, int chartType) {
+ setChartType(chartType);
+ setChartID(chartId);
+ setItem(item);
+ setChart(chart);
+ }
+
+ public int getChartID() {
+ return chartID;
+ }
+
+ public void setChartID(int chartID) {
+ this.chartID = chartID;
+ }
+
+ public String getChartName() {
+ return chartName.trim();
+ }
+
+ public void setChartName(String chartName) {
+ this.chartName = chartName;
+ }
+
+ public int getpId() {
+ return pId;
+ }
+
+ public void setpId(int pId) {
+ this.pId = pId;
+ }
+
+ public int gettId() {
+ return tId;
+ }
+
+ public void settId(int tId) {
+ this.tId = tId;
+ }
+
+ public boolean isParentChartRow() {
+ if (children.size() > 0) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ public void pushChild(SyncChart data) {
+ children.add(data);
+ }
+
+ public void setItem(DAChartBoardItem item) {
+ this.item = item;
+ setChart(item.getChart());
+ if (chartType == THREAD_CHART) {
+ return;
+ }
+ syncStateSeries = new DAChartSeries(ThreadPageLabels.THREAD_SYNC_CHART_SERIES_STATE,
+ DAChartSeries.SERIES_STYLE_STATE, ColorResources.WHITE, false);
+
+ syncAPISeries = new DAChartSeries(ThreadPageLabels.THREAD_CHART_SERIES_API,
+ DAChartSeries.SERIES_STYLE_EVENT, ColorResources.YELLOW);
+ syncAPISeries.setSummarizeTooltipText(ThreadPageLabels.THREAD_TOOLTIP_APIS);
+
+ chart.addSeries(syncStateSeries);
+ chart.addSeries(syncAPISeries);
+ }
+
+ public DAChartBoardItem getItem() {
+ return item;
+ }
+
+ public DAChart getChart() {
+ return chart;
+ }
+
+ public void setChart(DAChart chart) {
+ this.chart = chart;
+ }
+
+ public void clearSeries() {
+ if (null != syncAPISeries) {
+ syncAPISeries.clear();
+ }
+ if (null != syncStateSeries) {
+ syncStateSeries.clear();
+ }
+ }
+
+ public void updateSyncSeries(List<ThreadPageSyncDataEvent> eventList) {
+ if (chartType == THREAD_CHART) {
+ return;
+ }
+ for (ThreadPageSyncDataEvent syncEvent : eventList) {
+ if (chartID != syncEvent.getSyncDataID()) {
+ continue;
+ }
+ addSyncSeriesItem(syncEvent);
+ }
+ chart.redraw();
+ }
+
+ private void addSyncSeriesItem(ThreadPageSyncDataEvent syncEvent) {
+ double startTime = syncEvent.getDoubleTime();
+ double endTime = Formatter.longTimeToDoubleTime(syncEvent.getBlockEndTime());
+ long errorNum = syncEvent.getErrorNum();
+ switch (syncEvent.getApiType()) {
+ case LogCenterConstants.SYNC_API_TYPE_NEW:
+ case LogCenterConstants.SYNC_API_TYPE_NOTIFY:
+ case LogCenterConstants.SYNC_API_TYPE_NOTIFY_ALL:
+ case LogCenterConstants.SYNC_API_TYPE_OTHER:
+ syncStateSeries.addSeriesItem(new DAChartSeriesItem(startTime,
+ DAChartSeriesItem.SERIES_STATE_BAR,
+ ColorResources.THREAD_GRAPH_LOCK_RELEASE_COLOR,
+ ThreadPageLabels.SYNC_CHART_ITEM_UNUSED));
+ syncAPISeries.addSeriesItem(createAPIItem(syncEvent, errorNum));
+ break;
+ case LogCenterConstants.SYNC_API_TYPE_ACQUIRE_WAIT_START:
+ case LogCenterConstants.SYNC_API_TYPE_COND_WAIT_START:
+ syncStateSeries.addSeriesItem(new DAChartSeriesItem(startTime,
+ DAChartSeriesItem.SERIES_STATE_CONNECTION,
+ ColorResources.THREAD_GRAPH_LOCK_WAIT_COLOR,
+ ThreadPageLabels.SYNC_CHART_ITEM_WAITED));
+ if (syncEvent.getBlockEndTime() != -1) {
+ syncStateSeries.addSeriesItem(new DAChartSeriesItem(endTime,
+ DAChartSeriesItem.SERIES_STATE_CONNECTION,
+ ColorResources.THREAD_GRAPH_LOCK_ACQUIRE_COLOR,
+ ThreadPageLabels.SYNC_CHART_ITEM_USED));
+ }
+ syncAPISeries.addSeriesItem(createAPIItem(syncEvent, errorNum));
+ break;
+ case LogCenterConstants.SYNC_API_TYPE_RELEASE:
+ if (syncEvent.getBlockEndTime() == -1) {
+ syncStateSeries.addSeriesItem(new DAChartSeriesItem(startTime,
+ DAChartSeriesItem.SERIES_STATE_BAR,
+ ColorResources.THREAD_GRAPH_LOCK_RELEASE_COLOR,
+ ThreadPageLabels.SYNC_CHART_ITEM_UNUSED));
+ } else {
+ syncStateSeries.addSeriesItem(new DAChartSeriesItem(startTime,
+ DAChartSeriesItem.SERIES_STATE_CONNECTION,
+ ColorResources.THREAD_GRAPH_LOCK_RELEASE_COLOR,
+ ThreadPageLabels.SYNC_CHART_ITEM_UNUSED));
+ syncStateSeries.addSeriesItem(new DAChartSeriesItem(endTime,
+ DAChartSeriesItem.SERIES_STATE_CONNECTION,
+ ColorResources.THREAD_GRAPH_LOCK_WAIT_COLOR,
+ ThreadPageLabels.SYNC_CHART_ITEM_WAITED));
+ }
+ syncAPISeries.addSeriesItem(createAPIItem(syncEvent, errorNum));
+ break;
+ case LogCenterConstants.SYNC_API_TYPE_ACQUIRE_WAIT_END:
+ case LogCenterConstants.SYNC_API_TYPE_COND_WAIT_END:
+ syncStateSeries.addSeriesItem(new DAChartSeriesItem(startTime,
+ DAChartSeriesItem.SERIES_STATE_CONNECTION,
+ ColorResources.THREAD_GRAPH_LOCK_ACQUIRE_COLOR,
+ ThreadPageLabels.SYNC_CHART_ITEM_USED));
+ if (syncEvent.getBlockEndTime() != -1) {
+ syncStateSeries.addSeriesItem(new DAChartSeriesItem(endTime,
+ DAChartSeriesItem.SERIES_STATE_CONNECTION,
+ ColorResources.THREAD_GRAPH_LOCK_RELEASE_COLOR,
+ ThreadPageLabels.SYNC_CHART_ITEM_UNUSED));
+ }
+ break;
+ case LogCenterConstants.SYNC_API_TYPE_TRY_ACQUIRE:
+ syncStateSeries.addSeriesItem(new DAChartSeriesItem(startTime,
+ DAChartSeriesItem.SERIES_STATE_CONNECTION,
+ ColorResources.THREAD_GRAPH_LOCK_ACQUIRE_COLOR,
+ ThreadPageLabels.SYNC_CHART_ITEM_USED));
+ if (syncEvent.getBlockEndTime() != -1) {
+ syncStateSeries.addSeriesItem(new DAChartSeriesItem(endTime,
+ DAChartSeriesItem.SERIES_STATE_CONNECTION,
+ ColorResources.THREAD_GRAPH_LOCK_RELEASE_COLOR,
+ ThreadPageLabels.SYNC_CHART_ITEM_UNUSED));
+ }
+ syncAPISeries.addSeriesItem(createAPIItem(syncEvent, errorNum));
+ break;
+ default:
+ return;
+ }
+ }
+
+ protected DAChartSeriesItem createAPIItem(ThreadPageDataEvent event, long errno) {
+ DAChartSeriesItem apiItem = null;
+ if (0 != errno) {
+ apiItem = new DAChartSeriesItem(event.getDoubleTime(),
+ DAChartSeriesItem.SERIES_STATE_BAR, ColorResources.RED,
+ event.getTooltipContent() + ThreadPageLabels.SYNC_CHART_ITEM_FAILED);
+ } else {
+ apiItem = new DAChartSeriesItem(event.getDoubleTime(),
+ DAChartSeriesItem.SERIES_STATE_BAR, ColorResources.YELLOW,
+ event.getTooltipContent());
+ }
+ return apiItem;
+ }
+
+ public int getChartType() {
+ return chartType;
+ }
+
+ public void setChartType(int chartType) {
+ this.chartType = chartType;
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Hyunjong Park <phjwithyou.park@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.chart;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.swt.widgets.Composite;
+import org.tizen.dynamicanalyzer.database.SqlConnectionManager;
+import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;
+import org.tizen.dynamicanalyzer.nl.TimelineChartLabels;
+import org.tizen.dynamicanalyzer.resources.ColorResources;
+import org.tizen.dynamicanalyzer.resources.FontResources;
+import org.tizen.dynamicanalyzer.resources.ImageResources;
+import org.tizen.dynamicanalyzer.ui.common.PopupAnalysisMenuItemClickListener;
+import org.tizen.dynamicanalyzer.ui.common.PopupClearMenuItemClickListener;
+import org.tizen.dynamicanalyzer.ui.common.PopupEndMenuItemClickListener;
+import org.tizen.dynamicanalyzer.ui.common.PopupFromSelectionMenuItemClickListener;
+import org.tizen.dynamicanalyzer.ui.common.PopupStartMenuItemClickListener;
+import org.tizen.dynamicanalyzer.ui.common.TimelineChartMouseEventListener;
+import org.tizen.dynamicanalyzer.ui.common.TimelineChartMouseTrackAdapter;
+import org.tizen.dynamicanalyzer.ui.thread.data.ThreadDataManager;
+import org.tizen.dynamicanalyzer.ui.thread.db.SyncEventDBTable;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageSyncData;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageSyncDataEvent;
+import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants;
+import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
+import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
+import org.tizen.dynamicanalyzer.widgets.chart.DAChart;
+import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlot;
+import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlot.AutoRangeType;
+import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlotIntervalMarker;
+import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlotTooltip;
+import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoard;
+import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoardItem;
+import org.tizen.dynamicanalyzer.widgets.popupMenu.DAPopupMenu;
+import org.tizen.dynamicanalyzer.widgets.popupMenu.DAPopupMenuItem;
+
+public class SyncChartBoard extends DAChartBoard {
+ private List<SyncChart> syncChartItemList = new ArrayList<SyncChart>();
+ protected int syncListCount = -1;
+ private int preSelectionPId = -1;
+
+ public SyncChartBoard(Composite parent, String title) {
+ super(parent, title);
+ initIntervalMarkers();
+
+ }
+
+ public SyncChartBoard(Composite parent, String title, int[] scaleValues) {
+ super(parent, title, scaleValues);
+ }
+
+ public SyncChartBoard(Composite parent, String title, int boardStyle) {
+ super(parent, title, boardStyle);
+ }
+
+ @Override
+ protected void callBackScaleChanged() {
+ super.callBackScaleChanged();
+ updateChart();
+ }
+
+ @Override
+ protected void callBackScrollChanged() {
+ super.callBackScrollChanged();
+ updateChart();
+ }
+
+ @Override
+ protected void callBackSizeChanged() {
+ layout(true, true);
+ super.callBackSizeChanged();
+ }
+
+ public void updateChart() {
+ createChartItem();
+ clearSeries();
+ updateSeries();
+ chartFilteringByPId();
+ }
+
+ protected void chartFilteringByPId() {
+ if (null == getItemList()) {
+ return;
+ }
+ int selectedPid = ToolbarArea.getInstance().getSelectedPid();
+ if (preSelectionPId != -1 && preSelectionPId != selectedPid) {
+ return;
+ }
+
+ int parentIndex = 0;
+ for (SyncChart chart : syncChartItemList) {
+ if (!chart.isParentChartRow()) {
+ continue;
+ }
+ if (selectedPid == 0) {
+ showItem(parentIndex);
+ } else if (selectedPid == chart.getpId()) {
+ showItem(parentIndex);
+ } else {
+ hideItem(parentIndex);
+ }
+ parentIndex++;
+ }
+ preSelectionPId = selectedPid;
+ }
+
+ public void clear() {
+ super.clear();
+ syncChartItemList.clear();
+ syncListCount = -1;
+ preSelectionPId = -1;
+ initIntervalMarkers();
+ }
+
+ public void initIntervalMarkers() {
+ // selection marker
+ DAChartPlotIntervalMarker selectionMarker = new DAChartPlotIntervalMarker(-1, -1,
+ DAChartPlotIntervalMarker.INTERVAL_MARKER_STYLE_AREA);
+ selectionMarker.setBackgroundColor(ColorResources.SELECTION_RANGE);
+ selectionMarker.setAlpha((int) (255 * 0.25));
+ addIntervalMarker(selectionMarker);
+
+ // range analysis marker
+ DAChartPlotIntervalMarker rangeAnalyzeMarker = new DAChartPlotIntervalMarker(-1, -1,
+ DAChartPlotIntervalMarker.INTERVAL_MARKER_STYLE_AREA);
+ rangeAnalyzeMarker.setBackgroundColor(ColorResources.YELLOW);
+ rangeAnalyzeMarker.setAlpha((int) (255 * 0.25));
+ addIntervalMarker(rangeAnalyzeMarker);
+
+ // range marker
+ DAChartPlotIntervalMarker rangeMarker = new DAChartPlotIntervalMarker(-1, -1,
+ DAChartPlotIntervalMarker.INTERVAL_MARKER_STYLE_LINE);
+ rangeMarker.setForegroundColor(ColorResources.RED);
+ rangeMarker.setAlpha((int) (255 * 0.25));
+ addIntervalMarker(rangeMarker);
+
+ }
+
+ protected void initChart(DAChart chart, boolean isParent) {
+ if (null == chart) {
+ return;
+ }
+
+ DAChartPlot plot = chart.getPlot();
+ if (null == plot) {
+ return;
+ }
+ if (true == isParent) {
+ plot.setBackgroundImage(ImageResources.BG_GRADIENT);
+ } else {
+ plot.setBackgroundImage(ImageResources.BG_CHILD_GRADIENT);
+ }
+ plot.setAutoHeightRange(AutoRangeType.MANUAL);
+ plot.setAxisFont(FontResources.CHART_AXIS_FONT);
+ plot.setAxisRangeY(0, 101);
+ plot.setAxisRangeX(getVisibleStartTime(), getVisibleEndTime());
+ DAChartPlotTooltip tooltip = new DAChartPlotTooltip(-1);
+ tooltip.setFont(FontResources.CHART_TOOLTIP_FONT);
+ plot.setTooltip(tooltip);
+
+ DAPopupMenu popupMenu = new DAPopupMenu(chart);
+ popupMenu.setFont(FontResources.CONTEXT_MENU_ITEM_FONT);
+ DAPopupMenuItem startItem = new DAPopupMenuItem(popupMenu, DAPopupMenuItem.NONE);
+ startItem.setText(TimelineChartLabels.RANGE_CONTEXT_SET_START);
+ startItem.addListener(new PopupStartMenuItemClickListener(startItem, this));
+
+ DAPopupMenuItem endItem = new DAPopupMenuItem(popupMenu, DAPopupMenuItem.NONE);
+ endItem.setText(TimelineChartLabels.RANGE_CONTEXT_SET_END);
+ endItem.addListener(new PopupEndMenuItemClickListener(endItem, this));
+
+ DAPopupMenuItem fromSelectionItem = new DAPopupMenuItem(popupMenu, DAPopupMenuItem.NONE);
+ fromSelectionItem.setText(TimelineChartLabels.RANGE_CONTEXT_SET_FROM_SELECTION);
+ fromSelectionItem.addListener(new PopupFromSelectionMenuItemClickListener(
+ fromSelectionItem, this));
+
+ DAPopupMenuItem analysisItem = new DAPopupMenuItem(popupMenu, DAPopupMenuItem.NONE);
+ analysisItem.setText(TimelineChartLabels.RANGE_CONTEXT_ANALYSIS);
+ analysisItem.addListener(new PopupAnalysisMenuItemClickListener());
+
+ DAPopupMenuItem clearItem = new DAPopupMenuItem(popupMenu, DAPopupMenuItem.NONE);
+ clearItem.setText(TimelineChartLabels.RANGE_CONTEXT_CLEAR);
+ clearItem.addListener(new PopupClearMenuItemClickListener());
+
+ TimelineChartMouseEventListener timelineChartMouseEventListener = new TimelineChartMouseEventListener(
+ popupMenu, getTimeline());
+ chart.addMouseListener(timelineChartMouseEventListener);
+ chart.addMouseMoveListener(timelineChartMouseEventListener);
+ chart.addMouseTrackListener(new TimelineChartMouseTrackAdapter(getTimeline()));
+ plot.setMarkers(getMarkers());
+ }
+
+ public boolean createChartItem() {
+ if (syncListCount != ThreadDataManager.getInstance().getSyncDataMaker().getChartRowData()
+ .size()) {
+ for (ThreadPageSyncData data : ThreadDataManager.getInstance().getSyncDataMaker()
+ .getChartRowData()) {
+ if (isExistSyncChartRow(data)) {
+ continue;
+ }
+ if (data.getSyncDataType() == ThreadPageSyncData.SYNC_PARENT) {
+ addSyncParentChartItemList(data);
+ } else if (data.getSyncDataType() == ThreadPageSyncData.SYNC_CHILD) {
+ addChartChildItemList(data);
+ }
+ }
+ }
+ syncListCount = ThreadDataManager.getInstance().getSyncDataMaker().getChartRowData().size();
+ return true;
+ }
+
+ protected boolean isExistSyncChartRow(ThreadPageSyncData data) {
+ for (SyncChart chart : syncChartItemList) {
+ if (chart.getChartID() == data.getSyncDataID()) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private void addChartChildItemList(ThreadPageSyncData data) {
+ SyncChart parent = getParentChartData(data);
+ if (null != parent) {
+ addSyncChildChartItemList(parent, data);
+ }
+ }
+
+ private void addSyncParentChartItemList(ThreadPageSyncData sync) {
+ DAChartBoardItem parentItem = new DAChartBoardItem(this, sync.getTypeString()
+ + ThreadPageLabels.THREAD_CHART_NAME_PREFIX
+ + ThreadPageLabels.THREAD_CHART_NAME_OBJ + AnalyzerUtil.toHexdecimal(sync.getKey())
+ + ThreadPageLabels.THREAD_CHART_NAME_POSTFIX);
+ parentItem.setData(sync);
+ DAChart parentDAChart = parentItem.getChart();
+ initChart(parentDAChart, true);
+ SyncChart parentChartData = new SyncChart(sync.getSyncDataID(), parentItem, parentDAChart,
+ ThreadChart.SYNC_PARENT_CHART);
+ parentChartData.setpId(Integer.parseInt(sync.getPid()));
+ syncChartItemList.add(parentChartData);
+ }
+
+ protected void addSyncChildChartItemList(SyncChart parent, ThreadPageSyncData sync) {
+ DAChartBoardItem parentItem = parent.getItem();
+ DAChartBoardItem childItem = new DAChartBoardItem(parentItem, sync.getTypeString()
+ + ThreadPageLabels.THREAD_CHART_NAME_PREFIX
+ + ThreadPageLabels.THREAD_CHART_NAME_OBJ + AnalyzerUtil.toHexdecimal(sync.getKey())
+ + ThreadPageLabels.THREAD_CHART_NAME_POSTFIX);
+ childItem.setData(sync);
+ DAChart childChart = childItem.getChart();
+ initChart(childChart, false);
+ SyncChart childChartData = new SyncChart(sync.getSyncDataID(), childItem, childChart,
+ ThreadChart.SYNC_CHILD_CHART);
+ parent.pushChild(childChartData);
+ syncChartItemList.add(childChartData);
+ }
+
+ private SyncChart getParentChartData(ThreadPageSyncData syncData) {
+ if (syncData.getSyncDataType() != ThreadPageSyncData.SYNC_CHILD) {
+ return null;
+ }
+ for (SyncChart chart : syncChartItemList) {
+ if (chart.getChartID() == syncData.getParentID()) {
+ return chart;
+ }
+ }
+ return null;
+ }
+
+ public void clearSeries() {
+ clearSyncSeries();
+ }
+
+ private void clearSyncSeries() {
+ if (null == syncChartItemList) {
+ return;
+ }
+ for (SyncChart chart : syncChartItemList) {
+ chart.clearSeries();
+ }
+ }
+
+ private void updateSeries() {
+ updateSyncEventSeries();
+ }
+
+ protected void updateSyncEventSeries() {
+ if (null == syncChartItemList) {
+ return;
+ }
+ List<ThreadPageSyncDataEvent> seriesList = getSyncEventList();
+ if (null == seriesList) {
+ return;
+ }
+ for (SyncChart chart : syncChartItemList) {
+ chart.updateSyncSeries(seriesList);
+ }
+ }
+
+ private List<ThreadPageSyncDataEvent> getSyncEventList() {
+ List<ThreadPageSyncDataEvent> returnList = new ArrayList<ThreadPageSyncDataEvent>();
+ returnList.addAll(selectSyncEventFromDB());
+ returnList.addAll(ThreadDataManager.getInstance().getSyncDataMaker()
+ .getNotInsertSyncEventList());
+ return returnList;
+ }
+
+ private List<ThreadPageSyncDataEvent> selectSyncEventFromDB() {
+ List<ThreadPageSyncDataEvent> returnList = new ArrayList<ThreadPageSyncDataEvent>();
+ double chartStartTime = (getVisibleStartTime() - 2) * TimelineConstants.MEGA_LONG;
+ double chartEndTime = getVisibleEndTime() * TimelineConstants.MEGA_LONG;
+ String query = String.format(SyncEventDBTable.SELECT_QUERY, chartStartTime, chartEndTime,
+ chartStartTime, chartEndTime);
+ ResultSet rs = SqlConnectionManager.executeQueryRS(query);
+ if (rs == null) {
+ SqlConnectionManager.releaseResultSet(rs);
+ return returnList;
+ }
+ try {
+ while (rs.next()) {
+ int syncDataID = rs.getInt(SyncEventDBTable.COLUMN.SYNCDATAID.index + 1);
+ long time = rs.getLong(SyncEventDBTable.COLUMN.EVENTTIME.index + 1);
+ int apiType = rs.getByte(SyncEventDBTable.COLUMN.APITYPE.index + 1);
+ String tooltip = rs.getString(SyncEventDBTable.COLUMN.TOOLTIP.index + 1);
+ long errorNum = rs.getLong(SyncEventDBTable.COLUMN.ERRORNO.index + 1);
+ long syncValue = rs.getLong(SyncEventDBTable.COLUMN.SYNCVALUE.index + 1);
+ long releaseTime = rs.getLong(SyncEventDBTable.COLUMN.RELEASETIME.index + 1);
+ ThreadPageSyncDataEvent syncData = new ThreadPageSyncDataEvent(time, apiType,
+ tooltip, errorNum, Long.toString(syncValue));
+ syncData.setSyncDataID(syncDataID);
+ syncData.setBlockEndTime(releaseTime);
+ returnList.add(syncData);
+ }
+ SqlConnectionManager.releaseResultSet(rs);
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+ return returnList;
+ }
+}
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Hyunjong Park <phjwithyou.park@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.chart;
+
+import java.util.List;
+
+import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
+import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;
+import org.tizen.dynamicanalyzer.resources.ColorResources;
+import org.tizen.dynamicanalyzer.resources.FontResources;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageThreadDataEvent;
+import org.tizen.dynamicanalyzer.widgets.chart.DAChart;
+import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeries;
+import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeriesItem;
+import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoardItem;
+
+public class ThreadChart extends SyncChart {
+ private DAChartSeries threadLoadSeries;
+ private DAChartSeries threadEventSeries;
+ private DAChartSeries threadAPISeries;
+
+ public ThreadChart(int chartId, DAChartBoardItem item, DAChart chart, int chartType) {
+ super(chartId, item, chart, chartType);
+ }
+
+ public void setItem(DAChartBoardItem item) {
+ super.setItem(item);
+ this.item = item;
+ setChart(item.getChart());
+ threadLoadSeries = new DAChartSeries(ThreadPageLabels.THREAD_CHART_SERIES_LOAD,
+ DAChartSeries.SERIES_STYLE_LOAD, ColorResources.THREAD_GRAPH_MIN_CPU_LOAD_COLOR,
+ ColorResources.THREAD_GRAPH_MAX_CPU_LOAD_COLOR);
+ threadLoadSeries.setBarWidth(1);
+
+ threadAPISeries = new DAChartSeries(ThreadPageLabels.THREAD_CHART_SERIES_API,
+ DAChartSeries.SERIES_STYLE_EVENT, ColorResources.YELLOW);
+
+ threadEventSeries = new DAChartSeries(ThreadPageLabels.THREAD_CHART_SERIES_EVENT,
+ DAChartSeries.SERIES_STYLE_ARROW, ColorResources.THREAD_GRAPH_CALLEE_COLOR);
+
+ threadAPISeries.setSummarizeTooltipText(ThreadPageLabels.THREAD_TOOLTIP_APIS);
+ threadEventSeries.setFont(FontResources.CHART_ARROW_TID_FONT);
+
+ chart.addSeries(threadLoadSeries);
+ chart.addSeries(threadAPISeries);
+ chart.addSeries(threadEventSeries);
+ }
+
+ public void clearSeries() {
+ super.clearSeries();
+ if (null != threadLoadSeries) {
+ threadLoadSeries.clear();
+ }
+ if (null != threadEventSeries) {
+ threadEventSeries.clear();
+ }
+ if (null != threadAPISeries) {
+ threadAPISeries.clear();
+ }
+ }
+
+ public void updateThreadSeries(List<ThreadPageThreadDataEvent> eventList) {
+ for (ThreadPageThreadDataEvent threadEvent : eventList) {
+ if (getChartType() != THREAD_CHART || chartID != threadEvent.getThreadDataID()) {
+ continue;
+ }
+ addThreadSeriesItem(threadEvent);
+ }
+ chart.redraw();
+ }
+
+ private void addThreadSeriesItem(ThreadPageThreadDataEvent threadEvent) {
+ switch (threadEvent.getEventType()) {
+ case ThreadPageThreadDataEvent.TYPE_LOAD:
+ updateLoadSeries(threadEvent);
+ break;
+ case ThreadPageThreadDataEvent.TYPE_EVENT:
+ updateEventSeries(threadEvent);
+ break;
+ case ThreadPageThreadDataEvent.TYPE_API:
+ updateAPISeries(threadEvent);
+ break;
+ default:
+ break;
+ }
+ }
+
+ private void updateLoadSeries(ThreadPageThreadDataEvent threadEvent) {
+ DAChartSeriesItem seriesItem = new DAChartSeriesItem(threadEvent.getDoubleTime(),
+ (double) (threadEvent.getThreadType() * 2.55), threadEvent.getTooltipContent());
+ threadLoadSeries.addSeriesItem(seriesItem);
+ }
+
+ private void updateEventSeries(ThreadPageThreadDataEvent threadEvent) {
+ DAChartSeriesItem seriesItem;
+ int eventApiType = threadEvent.getApiType();
+ if (eventApiType == LogCenterConstants.THREAD_API_TYPE_INTERNAL_START) {
+ seriesItem = new DAChartSeriesItem(threadEvent.getDoubleTime(),
+ DAChartSeriesItem.SERIES_ARROW_LEFT, threadEvent.getTooltipContent());
+ seriesItem.setBarWidth(threadEvent.getCallerTid());
+ } else if (eventApiType == LogCenterConstants.THREAD_API_TYPE_WAIT_END) {
+ if (threadEvent.isJoinAPI()) {
+ seriesItem = new DAChartSeriesItem(threadEvent.getDoubleTime(),
+ DAChartSeriesItem.SERIES_ARROW_LEFT,
+ ThreadPageLabels.THREAD_CHART_ITEM_JOINED);
+ seriesItem.setBarWidth(threadEvent.getCallerTid());
+ } else {
+ seriesItem = new DAChartSeriesItem(threadEvent.getDoubleTime(),
+ DAChartSeriesItem.SERIES_ARROW_NONE, threadEvent.getTooltipContent());
+ }
+ } else if (eventApiType == LogCenterConstants.THREAD_API_TYPE_INTERNAL_STOP) {
+ if (threadEvent.getCallerTid() != -1) {
+ seriesItem = new DAChartSeriesItem(threadEvent.getDoubleTime(),
+ DAChartSeriesItem.SERIES_ARROW_RIGHT, threadEvent.getTooltipContent());
+ seriesItem.setBarWidth(threadEvent.getCallerTid());
+ } else {
+ seriesItem = new DAChartSeriesItem(threadEvent.getDoubleTime(),
+ DAChartSeriesItem.SERIES_ARROW_NONE, threadEvent.getTooltipContent());
+ }
+ } else {
+ seriesItem = new DAChartSeriesItem(threadEvent.getDoubleTime(),
+ DAChartSeriesItem.SERIES_ARROW_NONE, threadEvent.getTooltipContent());
+ }
+ threadEventSeries.addSeriesItem(seriesItem);
+ }
+
+ private void updateAPISeries(ThreadPageThreadDataEvent threadEvent) {
+ long errorNum = threadEvent.getErrorNum();
+ DAChartSeriesItem seriesItem = createAPIItem(threadEvent, errorNum);
+ threadAPISeries.addSeriesItem(seriesItem);
+ }
+
+ private DAChartSeriesItem createAPIItem(ThreadPageThreadDataEvent event, long errno) {
+ DAChartSeriesItem apiItem = null;
+ if (0 != errno) {
+ apiItem = new DAChartSeriesItem(event.getDoubleTime(),
+ DAChartSeriesItem.SERIES_STATE_BAR, ColorResources.RED,
+ event.getTooltipContent() + ThreadPageLabels.SYNC_CHART_ITEM_FAILED);
+ } else {
+ apiItem = new DAChartSeriesItem(event.getDoubleTime(),
+ DAChartSeriesItem.SERIES_STATE_BAR, ColorResources.YELLOW,
+ event.getTooltipContent());
+ }
+ return apiItem;
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Hyunjong Park <phjwithyou.park@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.chart;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import org.eclipse.swt.widgets.Composite;
+import org.tizen.dynamicanalyzer.database.SqlConnectionManager;
+import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;
+import org.tizen.dynamicanalyzer.ui.thread.data.ThreadDataManager;
+import org.tizen.dynamicanalyzer.ui.thread.db.ThreadEventDBTable;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageSyncData;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageThreadData;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageThreadDataEvent;
+import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants;
+import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
+import org.tizen.dynamicanalyzer.widgets.chart.DAChart;
+import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoardItem;
+
+public class ThreadChartBoard extends SyncChartBoard {
+
+ private List<ThreadChart> threadChartItemList = new ArrayList<ThreadChart>();
+
+ private int threadListCount = -1;
+ private int preSelectionPId = -1;
+
+ public ThreadChartBoard(Composite parent, String title) {
+ super(parent, title);
+ initIntervalMarkers();
+ }
+
+ public ThreadChartBoard(Composite parent, String title, int[] scaleValues) {
+ super(parent, title, scaleValues);
+ }
+
+ public ThreadChartBoard(Composite parent, String title, int boardStyle) {
+ super(parent, title, boardStyle);
+ }
+
+ @Override
+ protected void callBackScaleChanged() {
+ super.callBackScaleChanged();
+ updateChart();
+ }
+
+ @Override
+ protected void callBackScrollChanged() {
+ super.callBackScrollChanged();
+ updateChart();
+ }
+
+ @Override
+ protected void callBackSizeChanged() {
+ super.callBackSizeChanged();
+ layout(true, true);
+ }
+
+ public void updateChart() {
+ createChartItem();
+ clearSeries();
+ updateSeries();
+ chartFilteringByPId();
+ }
+
+ protected void chartFilteringByPId() {
+ super.chartFilteringByPId();
+ if (null == getItemList()) {
+ return;
+ }
+ int selectedPid = ToolbarArea.getInstance().getSelectedPid();
+ if (preSelectionPId != -1 && preSelectionPId != selectedPid) {
+ return;
+ }
+
+ int parentIndex = 0;
+ for (ThreadChart chart : threadChartItemList) {
+ if (!chart.isParentChartRow()) {
+ continue;
+ }
+ if (selectedPid == 0) {
+ showItem(parentIndex);
+ } else if (selectedPid == chart.getpId()) {
+ showItem(parentIndex);
+ } else {
+ hideItem(parentIndex);
+ }
+ parentIndex++;
+ }
+ preSelectionPId = selectedPid;
+ }
+
+ public void clear() {
+ super.clear();
+ threadChartItemList.clear();
+ threadListCount = -1;
+ preSelectionPId = -1;
+ initIntervalMarkers();
+ }
+
+ public boolean createChartItem() {
+ createThreadItem();
+ createSyncItem();
+ return true;
+ }
+
+ private void createThreadItem() {
+ if (threadListCount == ThreadDataManager.getInstance().getThreadDataMaker()
+ .getChartRowData().size()) {
+ return;
+ }
+
+ List<ThreadPageThreadData> sortList = sortThreadChartByTID(ThreadDataManager.getInstance()
+ .getThreadDataMaker().getChartRowData());
+ for (ThreadPageThreadData data : sortList) {
+ if (isExistThreadChartRow(data)) {
+ continue;
+ }
+ addThreadParentChartItemList(data);
+ }
+ threadListCount = ThreadDataManager.getInstance().getThreadDataMaker().getChartRowData()
+ .size();
+ }
+
+ private List<ThreadPageThreadData> sortThreadChartByTID(List<ThreadPageThreadData> list) {
+ Comparator<ThreadPageThreadData> comparator = new Comparator<ThreadPageThreadData>() {
+ @Override
+ public int compare(ThreadPageThreadData arg0, ThreadPageThreadData arg1) {
+ if (arg0.getTid() > arg1.getTid()) {
+ return 1;
+ } else if (arg0.getTid() < arg1.getTid()) {
+ return -1;
+ } else {
+ return 0;
+ }
+ }
+ };
+ Collections.sort(list, comparator);
+ return list;
+ }
+
+ private void createSyncItem() {
+ if (syncListCount == ThreadDataManager.getInstance().getSyncDataMaker().getChartRowData()
+ .size()) {
+ return;
+ }
+ for (ThreadPageSyncData data : ThreadDataManager.getInstance().getSyncDataMaker()
+ .getChartRowData()) {
+ if (isExistSyncChartRow(data)) {
+ continue;
+ }
+ addChartChildItemList(data);
+ }
+ syncListCount = ThreadDataManager.getInstance().getSyncDataMaker().getChartRowData().size();
+ }
+
+ private boolean isExistThreadChartRow(ThreadPageThreadData data) {
+ for (ThreadChart chart : threadChartItemList) {
+ if (chart.getChartID() == data.getThreadDataID()) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private void addChartChildItemList(ThreadPageSyncData data) {
+ ThreadChart parent = getParentChartData(data);
+ if (null != parent) {
+ addSyncChildChartItemList(parent, data);
+ }
+ }
+
+ private ThreadChart getParentChartData(ThreadPageSyncData syncData) {
+ if (syncData.getSyncDataType() != ThreadPageSyncData.THREAD_CHILD) {
+ return null;
+ }
+ for (ThreadChart chart : threadChartItemList) {
+ if (chart.getChartID() == syncData.getParentID()) {
+ return chart;
+ }
+ }
+ return null;
+ }
+
+ private void addThreadParentChartItemList(ThreadPageThreadData data) {
+ DAChartBoardItem parentItem = new DAChartBoardItem(this, data.getTypeString()
+ + ThreadPageLabels.THREAD_CHART_NAME_PREFIX
+ + ThreadPageLabels.THREAD_CHART_NAME_PID + data.getPid()
+ + ThreadPageLabels.THREAD_CHART_NAME_COMMA + ThreadPageLabels.THREAD_CHART_NAME_TID
+ + data.getKey() + ThreadPageLabels.THREAD_CHART_NAME_POSTFIX);
+ parentItem.setData(data);
+ DAChart parentDAChart = parentItem.getChart();
+ initChart(parentDAChart, true);
+ ThreadChart parentChartData = new ThreadChart(data.getThreadDataID(), parentItem,
+ parentDAChart, ThreadChart.THREAD_CHART);
+ parentChartData.setpId(Integer.parseInt(data.getPid()));
+ threadChartItemList.add(parentChartData);
+ }
+
+ public void clearSeries() {
+ super.clearSeries();
+ clearThreadSeries();
+ }
+
+ private void clearThreadSeries() {
+ if (null == threadChartItemList) {
+ return;
+ }
+ for (ThreadChart chart : threadChartItemList) {
+ chart.clearSeries();
+ }
+ }
+
+ private void updateSeries() {
+ updateThreadEventSeries();
+ updateSyncEventSeries();
+ }
+
+ private void updateThreadEventSeries() {
+ if (null == threadChartItemList) {
+ return;
+ }
+ List<ThreadPageThreadDataEvent> seriesList = selectThreadEventSeriesListFromDB();
+ if (null == seriesList) {
+ return;
+ }
+ for (ThreadChart chart : threadChartItemList) {
+ chart.updateThreadSeries(seriesList);
+ }
+ }
+
+ private List<ThreadPageThreadDataEvent> selectThreadEventSeriesListFromDB() {
+ List<ThreadPageThreadDataEvent> returnValue = new ArrayList<ThreadPageThreadDataEvent>();
+ String query = String.format(ThreadEventDBTable.SELECT_QUERY, (getVisibleStartTime() - 2)
+ * TimelineConstants.MEGA_LONG, getVisibleEndTime() * TimelineConstants.MEGA_LONG);
+
+ ResultSet rs = SqlConnectionManager.executeQueryRS(query);
+ if (rs == null) {
+ SqlConnectionManager.releaseResultSet(rs);
+ return null;
+ }
+ try {
+ while (rs.next()) {
+ int chartID = rs.getInt(ThreadEventDBTable.COLUMN.THREADDATAID.index + 1);
+ long time = rs.getLong(ThreadEventDBTable.COLUMN.EVENTTIME.index + 1);
+ int tID = rs.getInt(ThreadEventDBTable.COLUMN.TID.index + 1);
+ int apiType = rs.getByte(ThreadEventDBTable.COLUMN.APITYPE.index + 1);
+ String tooltip = rs.getString(ThreadEventDBTable.COLUMN.TOOLTIP.index + 1);
+ long errorNum = rs.getLong(ThreadEventDBTable.COLUMN.ERRORNO.index + 1);
+ int eventType = rs.getByte(ThreadEventDBTable.COLUMN.EVENTTYPE.index + 1);
+ int threadType = rs.getInt(ThreadEventDBTable.COLUMN.THREADTYPE.index + 1);
+ int callerID = rs.getInt(ThreadEventDBTable.COLUMN.CALLERID.index + 1);
+ ThreadPageThreadDataEvent chartData = new ThreadPageThreadDataEvent(eventType,
+ threadType, apiType, time, tID, tooltip, errorNum, null);
+ chartData.setThreadDataID(chartID);
+ chartData.setCallerTid(callerID);
+ returnValue.add(chartData);
+ }
+ SqlConnectionManager.releaseResultSet(rs);
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+ return returnValue;
+ }
+}
* Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
*
* Contact:
- * WooJin Jung <woojin2.jung@samsung.com>
- * yeongtaik byeon <yeongtaik.byeon@samsung.com>
+ * Hyunjong Park <phjwithyou.park@samsung.com>
* Juyoung Kim <j0.kim@samsung.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* - S-Core Co., Ltd
*
*/
-package org.tizen.dynamicanalyzer.ui.thread;
+
+package org.tizen.dynamicanalyzer.ui.thread.chart;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.StackLayout;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.DASelectionData;
import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;
import org.tizen.dynamicanalyzer.resources.ColorResources;
import org.tizen.dynamicanalyzer.resources.FontResources;
import org.tizen.dynamicanalyzer.resources.ImageResources;
+import org.tizen.dynamicanalyzer.swap.model.data.LogDataFactory;
import org.tizen.dynamicanalyzer.swap.model.data.ProbeCommonData;
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.thread.thread.ThreadPageThreadData;
+import org.tizen.dynamicanalyzer.ui.thread.ThreadPage;
+import org.tizen.dynamicanalyzer.ui.thread.data.ThreadDataManager;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageThreadData;
import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants;
import org.tizen.dynamicanalyzer.ui.timeline.logparser.LifecycleLogParser;
import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
import org.tizen.dynamicanalyzer.widgets.timeline.DATimeline;
public class ThreadChartView extends DAViewComposite {
+ public static final String ID = ThreadChartView.class.getName();
public final static int THREAD_CHART_HEIGHT = 70;
- public final static int THREAD_COMBO_ITEM_HEIGHT = 24;
-
private final Composite contents;
- private DAChartBoard threadChart;
- private DAChartBoard syncChart;
+ private ThreadChartBoard threadChartBoard;
+ private SyncChartBoard syncChartBoard;
private DACustomCombo threadCombo;
private DACustomCombo syncCombo;
private final StackLayout stackLayout;
- ThreadChartManager manager;
-
- private final RangeDataManager rangeDataManager = RangeDataManager.getInstance();
-
public ThreadChartView(Composite parent, int style) {
super(parent, style, false);
- this.setLayout(new FillLayout());
+ setLayout(new FillLayout());
setTitle(ThreadPageLabels.THREAD_CHART_TITLE);
stackLayout = new StackLayout();
contents.setLayout(stackLayout);
- threadChart = new DAChartBoard(contents, ThreadPageLabels.THREAD_CHART_TITLE);
- threadChart.setItemHeight(THREAD_CHART_HEIGHT);
- threadChart.setNameFont(FontResources.CHART_NAME_FONT);
- threadChart.addSelectionListener(new DAChartBoardSelectionListener() {
- @Override
- public void handleSelectionEvent(DAChartBoardItem item) {
- callUpdatePage(item);
- }
- });
+ initThreadChart();
+ initSyncChart();
+
+ stackLayout.topControl = threadChartBoard;
- initIntervalMarkers(threadChart);
- syncChart = new DAChartBoard(contents, ThreadPageLabels.SYNC_CHART_TITLE);
- syncChart.setItemHeight(THREAD_CHART_HEIGHT);
- syncChart.setNameFont(FontResources.CHART_NAME_FONT);
+ syncChartBoard.setSelectable(true);
+ threadChartBoard.setSelectable(true);
- syncChart.addSelectionListener(new DAChartBoardSelectionListener() {
+ initializeCharts();
+ }
+
+ private void initSyncChart() {
+ syncChartBoard = new SyncChartBoard(contents, ThreadPageLabels.THREAD_CHART_SYNC,
+ DAChartBoard.BOARD_STYLE_TIME);
+ syncChartBoard.setItemHeight(THREAD_CHART_HEIGHT);
+ syncChartBoard.setNameFont(FontResources.CHART_NAME_FONT);
+ syncChartBoard.addSelectionListener(new DAChartBoardSelectionListener() {
@Override
public void handleSelectionEvent(DAChartBoardItem item) {
callUpdatePage(item);
-
}
});
- initIntervalMarkers(syncChart);
-
- stackLayout.topControl = threadChart;
- threadCombo = makeDACustomCombo(threadChart.getTitleComp());
- threadCombo.initCombo();
- threadCombo.add("Thread");
- threadCombo.add("Sync");
- threadCombo.select(0);
- threadCombo.setEnabled(true);
- threadCombo.addSelectionListener(new DACustomComboSelectionListener() {
+ syncCombo = makeDACustomCombo(syncChartBoard.getTitleComp());
+ syncCombo.initCombo();
+ syncCombo.add(ThreadPageLabels.THREAD_CHART_THREAD);
+ syncCombo.add(ThreadPageLabels.THREAD_CHART_SYNC);
+ syncCombo.select(1);
+ syncCombo.setEnabled(true);
+ syncCombo.addSelectionListener(new DACustomComboSelectionListener() {
@Override
public void selectionEvent(DACustomCombo combo) {
String selected = combo.getText();
if (null == selected || selected.isEmpty()) {
return;
}
- if (selected.equals("Sync")) {
- changeComboThreadToSync();
+ if (selected.equals(ThreadPageLabels.THREAD_CHART_THREAD)) {
+ changeComboSyncToThread();
} else {
return;
}
}
});
+ }
- syncCombo = makeDACustomCombo(syncChart.getTitleComp());
- syncCombo.initCombo();
- syncCombo.add("Thread");
- syncCombo.add("Sync");
- syncCombo.select(1);
- syncCombo.setEnabled(true);
- syncCombo.addSelectionListener(new DACustomComboSelectionListener() {
+ private void initThreadChart() {
+ threadChartBoard = new ThreadChartBoard(contents, ThreadPageLabels.THREAD_CHART_THREAD,
+ DAChartBoard.BOARD_STYLE_TIME);
+ threadChartBoard.setItemHeight(THREAD_CHART_HEIGHT);
+ threadChartBoard.setNameFont(FontResources.CHART_NAME_FONT);
+ threadChartBoard.addSelectionListener(new DAChartBoardSelectionListener() {
+ @Override
+ public void handleSelectionEvent(DAChartBoardItem item) {
+ callUpdatePage(item);
+ }
+ });
+ threadCombo = makeDACustomCombo(threadChartBoard.getTitleComp());
+ threadCombo.initCombo();
+ threadCombo.add(ThreadPageLabels.THREAD_CHART_THREAD);
+ threadCombo.add(ThreadPageLabels.THREAD_CHART_SYNC);
+ threadCombo.select(0);
+ threadCombo.setEnabled(true);
+ threadCombo.addSelectionListener(new DACustomComboSelectionListener() {
@Override
public void selectionEvent(DACustomCombo combo) {
String selected = combo.getText();
if (null == selected || selected.isEmpty()) {
return;
}
- if (selected.equals("Thread")) {
- changeComboSyncToThread();
+ if (selected.equals(ThreadPageLabels.THREAD_CHART_SYNC)) {
+ changeComboThreadToSync();
} else {
return;
}
}
});
+ }
- DATimeline threadTimeline = threadChart.getTimeline();
- DATimeline syncTimeline = syncChart.getTimeline();
-
- threadTimeline.setTimeTickFont(FontResources.TIMELINE_TICK_FONT);
- threadTimeline.setTimeBalloonFont(FontResources.TIMELINE_BALLOON_FONT);
- syncTimeline.setTimeTickFont(FontResources.TIMELINE_TICK_FONT);
- syncTimeline.setTimeBalloonFont(FontResources.TIMELINE_BALLOON_FONT);
-
- LifecycleLogParser.getInstance().registerLifecycleBar(threadChart.getLifecycleBar());
- LifecycleLogParser.getInstance().registerTimeline(threadTimeline);
- LifecycleLogParser.getInstance().registerLifecycleBar(syncChart.getLifecycleBar());
- LifecycleLogParser.getInstance().registerTimeline(syncTimeline);
-
- setTimelineMouseListener(threadTimeline, threadChart);
- setTimelineMouseListener(syncTimeline, syncChart);
-
- manager = ThreadChartManager.getInstance();
- manager.setBoard(threadChart, syncChart);
+ private void callUpdatePage(DAChartBoardItem selectItem) {
+ if (null == selectItem) {
+ AnalyzerManager.getCurrentPage()
+ .updateView(
+ new DASelectionData(ThreadPage.chartViewID,
+ (long) (((DAChartPlotIntervalMarker) threadChartBoard
+ .getMarkers().get(
+ UICommonConstants.SELECTION_MARKER_INDEX))
+ .getStartVal() * TimelineConstants.MEGA_DOUBLE),
+ (long) (((DAChartPlotIntervalMarker) threadChartBoard
+ .getMarkers().get(
+ UICommonConstants.SELECTION_MARKER_INDEX))
+ .getEndVal() * TimelineConstants.MEGA_DOUBLE),
+ new Integer(0), null));
+ } else {
+ AnalyzerManager.getCurrentPage()
+ .updateView(
+ new DASelectionData(ThreadPage.chartViewID,
+ (long) (((DAChartPlotIntervalMarker) threadChartBoard
+ .getMarkers().get(
+ UICommonConstants.SELECTION_MARKER_INDEX))
+ .getStartVal() * TimelineConstants.MEGA_DOUBLE),
+ (long) (((DAChartPlotIntervalMarker) threadChartBoard
+ .getMarkers().get(
+ UICommonConstants.SELECTION_MARKER_INDEX))
+ .getEndVal() * TimelineConstants.MEGA_DOUBLE),
+ selectItem.getData(), null));
+ }
}
private DACustomCombo makeDACustomCombo(Composite parent) {
returnCombo.setComboImages(ImageResources.TAB_COMBO_BUTTON_DOWN,
ImageResources.TAB_COMBO_BUTTON_DOWN, ImageResources.TAB_COMBO_BUTTON_DOWN,
ImageResources.TAB_COMBO_BUTTON_DOWN);
- returnCombo.setComboImagePoint(new Point(65, 9));
+ returnCombo.setComboImagePoint(new Point(71, 10));
returnCombo.setButtonImages(ImageResources.TAB_COMBO_BUTTON_DOWN,
ImageResources.TAB_COMBO_BUTTON_DOWN);
returnCombo.setFontPoint(new Point(7, 5));
return returnCombo;
}
- private void callUpdatePage(DAChartBoardItem selectItem) {
- if (null == selectItem) {
- AnalyzerManager.getCurrentPage()
- .updateView(
- new DASelectionData(ThreadPage.chartViewID,
- (long) (((DAChartPlotIntervalMarker) threadChart.getMarkers()
- .get(UICommonConstants.SELECTION_MARKER_INDEX))
- .getStartVal() * TimelineConstants.MEGA_DOUBLE),
- (long) (((DAChartPlotIntervalMarker) threadChart.getMarkers()
- .get(UICommonConstants.SELECTION_MARKER_INDEX))
- .getEndVal() * TimelineConstants.MEGA_DOUBLE),
- new Integer(0), null));
- } else {
- AnalyzerManager.getCurrentPage()
- .updateView(
- new DASelectionData(ThreadPage.chartViewID,
- (long) (((DAChartPlotIntervalMarker) threadChart.getMarkers()
- .get(UICommonConstants.SELECTION_MARKER_INDEX))
- .getStartVal() * TimelineConstants.MEGA_DOUBLE),
- (long) (((DAChartPlotIntervalMarker) threadChart.getMarkers()
- .get(UICommonConstants.SELECTION_MARKER_INDEX))
- .getEndVal() * TimelineConstants.MEGA_DOUBLE),
- selectItem.getData(), null));
- }
- }
-
- private void changeComboSyncToThread() {
- stackLayout.topControl = threadChart;
+ private void changeComboThreadToSync() {
+ stackLayout.topControl = syncChartBoard;
+ threadCombo.setText(ThreadPageLabels.THREAD_CHART_SYNC);
+ syncChartBoard.setScaleVal(threadChartBoard.getScaleVal());
+ syncChartBoard.setVisibleStart(threadChartBoard.getVisibleStart());
+ syncChartBoard.setItemsHeightMode(threadChartBoard.isItemMinimized());
contents.layout();
- threadCombo.setText("Thread");
- threadChart.setScaleVal(syncChart.getScaleVal());
- threadChart.setVisibleStart(syncChart.getVisibleStart());
- threadChart.setItemsHeightMode(syncChart.isItemMinimized());
- callUpdatePage(threadChart.getSelectItem());
updateView();
}
- private void changeComboThreadToSync() {
- stackLayout.topControl = syncChart;
+ private void changeComboSyncToThread() {
+ stackLayout.topControl = threadChartBoard;
+ threadCombo.setText(ThreadPageLabels.THREAD_CHART_THREAD);
+ threadChartBoard.setScaleVal(syncChartBoard.getScaleVal());
+ threadChartBoard.setVisibleStart(syncChartBoard.getVisibleStart());
+ threadChartBoard.setItemsHeightMode(syncChartBoard.isItemMinimized());
contents.layout();
- syncCombo.setText("Sync");
- syncChart.setScaleVal(threadChart.getScaleVal());
- syncChart.setVisibleStart(threadChart.getVisibleStart());
- syncChart.setItemsHeightMode(threadChart.isItemMinimized());
- callUpdatePage(syncChart.getSelectItem());
updateView();
}
- private void setTimelineMouseListener(final DATimeline timeline, DAChartBoard chartBoard) {
- timeline.addMouseMoveListener(new SetRangeMarkerMouseMoveListener(rangeDataManager,
- chartBoard, timeline));
- }
-
@Override
public void updateView() {
- threadChart.setTotalEndTime(ToolbarArea.getInstance().getTime());
- syncChart.setTotalEndTime(ToolbarArea.getInstance().getTime());
- manager.update();
+ if (stackLayout.topControl == syncChartBoard) {
+ updateTimeLine(syncChartBoard);
+ updateRange(syncChartBoard);
+ syncChartBoard.updateChart();
+ } else {
+ updateTimeLine(threadChartBoard);
+ updateRange(threadChartBoard);
+ threadChartBoard.updateChart();
+ }
+ }
- threadChart.setTimelineMarkerStartTime(rangeDataManager.getMarkerStartTime()
- / TimelineConstants.MEGA_DOUBLE);
- threadChart.setTimelineMarkerEndTime(rangeDataManager.getMarkerEndTime()
- / TimelineConstants.MEGA_DOUBLE);
- syncChart.setTimelineMarkerStartTime(rangeDataManager.getMarkerStartTime()
+ private void updateRange(DAChartBoard chartBoard) {
+ chartBoard.setTimelineMarkerStartTime(RangeDataManager.getInstance().getMarkerStartTime()
/ TimelineConstants.MEGA_DOUBLE);
- syncChart.setTimelineMarkerEndTime(rangeDataManager.getMarkerEndTime()
+ chartBoard.setTimelineMarkerEndTime(RangeDataManager.getInstance().getMarkerEndTime()
/ TimelineConstants.MEGA_DOUBLE);
-
if (RangeDataManager.getInstance().isBeingAnalyzed()) {
- ((DAChartPlotIntervalMarker) threadChart.getMarkers().get(
- UICommonConstants.RANGE_ANALYSIS_MARKER_INDEX)).setInterval(
- rangeDataManager.getAnalysisStartTime() / TimelineConstants.MEGA_DOUBLE,
- rangeDataManager.getAnalysisEndTime() / TimelineConstants.MEGA_DOUBLE);
-
- ((DAChartPlotIntervalMarker) syncChart.getMarkers().get(
- UICommonConstants.RANGE_ANALYSIS_MARKER_INDEX)).setInterval(
- rangeDataManager.getAnalysisStartTime() / TimelineConstants.MEGA_DOUBLE,
- rangeDataManager.getAnalysisEndTime() / TimelineConstants.MEGA_DOUBLE);
+ ((DAChartPlotIntervalMarker) chartBoard.getMarkers().get(
+ UICommonConstants.RANGE_ANALYSIS_MARKER_INDEX)).setInterval(RangeDataManager
+ .getInstance().getAnalysisStartTime() / TimelineConstants.MEGA_DOUBLE,
+ RangeDataManager.getInstance().getAnalysisEndTime()
+ / TimelineConstants.MEGA_DOUBLE);
} else {
- ((DAChartPlotIntervalMarker) threadChart.getMarkers().get(
- UICommonConstants.RANGE_ANALYSIS_MARKER_INDEX)).setInterval(-1, -1);
-
- ((DAChartPlotIntervalMarker) syncChart.getMarkers().get(
+ ((DAChartPlotIntervalMarker) chartBoard.getMarkers().get(
UICommonConstants.RANGE_ANALYSIS_MARKER_INDEX)).setInterval(-1, -1);
}
+ ((DAChartPlotIntervalMarker) chartBoard.getMarkers().get(
+ UICommonConstants.RANGE_MARKER_INDEX)).setInterval(RangeDataManager.getInstance()
+ .getMarkerStartTime() / TimelineConstants.MEGA_DOUBLE, RangeDataManager
+ .getInstance().getMarkerEndTime() / TimelineConstants.MEGA_DOUBLE);
+ }
- ((DAChartPlotIntervalMarker) threadChart.getMarkers().get(
- UICommonConstants.RANGE_MARKER_INDEX)).setInterval(
- rangeDataManager.getMarkerStartTime() / TimelineConstants.MEGA_DOUBLE,
- rangeDataManager.getMarkerEndTime() / TimelineConstants.MEGA_DOUBLE);
-
- ((DAChartPlotIntervalMarker) syncChart.getMarkers().get(
- UICommonConstants.RANGE_MARKER_INDEX)).setInterval(
- rangeDataManager.getMarkerStartTime() / TimelineConstants.MEGA_DOUBLE,
- rangeDataManager.getMarkerEndTime() / TimelineConstants.MEGA_DOUBLE);
-
+ private void updateTimeLine(DAChartBoard chartBoard) {
+ chartBoard.setTotalEndTime(ToolbarArea.getInstance().getTime());
}
@Override
public void updateView(DAViewData data) {
- if (data instanceof DASelectionData) {
- DASelectionData selData = (DASelectionData) data;
+ if (data instanceof DASelectionData == false) {
+ return;
+ }
+ DASelectionData selData = (DASelectionData) data;
+ if (selData.isLogData()) {
+ selectionFromSummary(selData);
+ } else {
+ selectionFromAPITable(selData);
+ }
+ }
- if (selData.isLogData()) {
- Object odata = selData.getData();
- if (stackLayout.topControl.equals(syncChart)) {
- changeComboSyncToThread();
- }
- String selectTid = Integer.toString(((ProbeCommonData) odata).getTid());
- threadChart.selectItem(getChartIndexOfSelected(selectTid));
- } else {
- long start = selData.getStartTime();
- long end = selData.getEndTime();
-
- double startTime = (double) start / TimelineConstants.MEGA_DOUBLE;
- double endTime = (double) end / TimelineConstants.MEGA_DOUBLE;
- // double middleTime = (startTime + endTime) / 2.0;
- // if (start == end) {
- // middleTime = startTime;
- // }
-
- DAChartBoard chartBoard = (DAChartBoard) stackLayout.topControl;
-
- // chartBoard.setVisibleMiddleTime(middleTime);
- DAChartPlotIntervalMarker intervalMarker = (DAChartPlotIntervalMarker) chartBoard
- .getMarkers().get(UICommonConstants.SELECTION_MARKER_INDEX);
- intervalMarker.setInterval(startTime, endTime);
- }
+ private void selectionFromSummary(DASelectionData selData) {
+ Object odata = selData.getData();
+ String category = LogDataFactory.getLogFormatName(((ProbeCommonData) odata).getId());
+ if(null == category){
+ return;
}
+ String selectTid = Integer.toString(((ProbeCommonData) odata).getTid());
+ if (category.equals(ThreadPageLabels.THREAD_CHART_THREAD)) {
+ changeComboSyncToThread();
+ threadChartBoard.selectItem(getThreadChartIndexOfSelected(selectTid));
+ } else {
+ changeComboThreadToSync();
+ syncChartBoard.selectItem(getSyncChartIndexOfSelected(selectTid));
+ }
+ DAChartBoard chartBoard = (DAChartBoard) stackLayout.topControl;
+ DAChartPlotIntervalMarker intervalMarker = (DAChartPlotIntervalMarker) chartBoard
+ .getMarkers().get(UICommonConstants.SELECTION_MARKER_INDEX);
+ long start = ((ProbeCommonData) odata).getTime();
+ long end = ((ProbeCommonData) odata).getTime();
+ double startTime = (double) start / TimelineConstants.MEGA_DOUBLE;
+ double endTime = (double) end / TimelineConstants.MEGA_DOUBLE;
+ intervalMarker.setInterval(startTime, endTime);
}
- private int getChartIndexOfSelected(String tID) {
- int itemSize = threadChart.getItemList().getItemSize();
- if (0 == itemSize) {
+ private void selectionFromAPITable(DASelectionData selData) {
+ DAChartBoard chartBoard = (DAChartBoard) stackLayout.topControl;
+ DAChartPlotIntervalMarker intervalMarker = (DAChartPlotIntervalMarker) chartBoard
+ .getMarkers().get(UICommonConstants.SELECTION_MARKER_INDEX);
+ long start = selData.getStartTime();
+ long end = selData.getEndTime();
+ double startTime = (double) start / TimelineConstants.MEGA_DOUBLE;
+ double endTime = (double) end / TimelineConstants.MEGA_DOUBLE;
+ intervalMarker.setInterval(startTime, endTime);
+ }
+
+ private int getThreadChartIndexOfSelected(String tID) {
+ int itemSize = threadChartBoard.getItemList().getItemSize();
+ if (null == tID || 0 == itemSize) {
return 0;
}
for (int i = 0; i < itemSize; i++) {
- DAChartBoardItem item = threadChart.getItemList().get(i);
+ DAChartBoardItem item = threadChartBoard.getItemList().get(i);
ThreadPageThreadData pageData = (ThreadPageThreadData) item.getData();
- if (pageData.getTid().equals(tID)) {
+ if (pageData.getTid() == Integer.parseInt(tID)) {
return i;
}
}
return 0;
}
-
- @Override
- public void clear() {
- threadChart.clear();
- syncChart.clear();
- initIntervalMarkers(threadChart);
- initIntervalMarkers(syncChart);
- manager.clear();
- manager.setBoard(threadChart, syncChart);
- }
-
- @Override
- public Control getControl() {
- return stackLayout.topControl;
- }
-
- private void initIntervalMarkers(DAChartBoard board) {
- // selection marker
- DAChartPlotIntervalMarker selectionMarker = new DAChartPlotIntervalMarker(-1, -1,
- DAChartPlotIntervalMarker.INTERVAL_MARKER_STYLE_AREA);
- selectionMarker.setBackgroundColor(ColorResources.SELECTION_RANGE);
- selectionMarker.setAlpha((int) (255 * 0.25));
- board.addIntervalMarker(selectionMarker);
-
- // range analysis marker
- DAChartPlotIntervalMarker rangeAnalyzeMarker = new DAChartPlotIntervalMarker(-1, -1,
- DAChartPlotIntervalMarker.INTERVAL_MARKER_STYLE_AREA);
- rangeAnalyzeMarker.setBackgroundColor(ColorResources.YELLOW);
- rangeAnalyzeMarker.setAlpha((int) (255 * 0.25));
- board.addIntervalMarker(rangeAnalyzeMarker);
-
- // range marker
- DAChartPlotIntervalMarker rangeMarker = new DAChartPlotIntervalMarker(-1, -1,
- DAChartPlotIntervalMarker.INTERVAL_MARKER_STYLE_LINE);
- rangeMarker.setForegroundColor(ColorResources.RED);
- rangeMarker.setAlpha((int) (255 * 0.25));
- board.addIntervalMarker(rangeMarker);
+
+ private int getSyncChartIndexOfSelected(String tID) {
+ int itemSize = syncChartBoard.getItemList().getItemSize();
+ if (null == tID || 0 == itemSize) {
+ return 0;
+ }
+ for (int i = 0; i < itemSize; i++) {
+ DAChartBoardItem item = syncChartBoard.getItemList().get(i);
+ ThreadPageThreadData pageData = (ThreadPageThreadData) item.getData();
+ if (pageData.getTid() == Integer.parseInt(tID)) {
+ return i;
+ }
+ }
+ return 0;
}
public void setRangeMarker(double starttime, double endtime) {
UICommonConstants.RANGE_MARKER_INDEX)).setInterval(starttime, endtime);
}
+ @Override
+ public void clear() {
+ ThreadDataManager.getInstance().clear();
+ syncChartBoard.contentsClear();
+ syncChartBoard.clear();
+ threadChartBoard.contentsClear();
+ threadChartBoard.clear();
+ initializeCharts();
+ }
+
+ private void initializeCharts() {
+ threadChartBoard.initIntervalMarkers();
+ syncChartBoard.initIntervalMarkers();
+ initTimeline();
+ }
+
+ private void initTimeline() {
+ DATimeline threadTimeline = threadChartBoard.getTimeline();
+ DATimeline syncTimeline = syncChartBoard.getTimeline();
+
+ threadTimeline.setTimeTickFont(FontResources.TIMELINE_TICK_FONT);
+ threadTimeline.setTimeBalloonFont(FontResources.TIMELINE_BALLOON_FONT);
+ syncTimeline.setTimeTickFont(FontResources.TIMELINE_TICK_FONT);
+ syncTimeline.setTimeBalloonFont(FontResources.TIMELINE_BALLOON_FONT);
+
+ LifecycleLogParser.getInstance().registerLifecycleBar(threadChartBoard.getLifecycleBar());
+ LifecycleLogParser.getInstance().registerTimeline(threadTimeline);
+ LifecycleLogParser.getInstance().registerLifecycleBar(syncChartBoard.getLifecycleBar());
+ LifecycleLogParser.getInstance().registerTimeline(syncTimeline);
+
+ threadTimeline.addMouseMoveListener(new SetRangeMarkerMouseMoveListener(RangeDataManager
+ .getInstance(), threadChartBoard, threadTimeline));
+ syncTimeline.addMouseMoveListener(new SetRangeMarkerMouseMoveListener(RangeDataManager
+ .getInstance(), syncChartBoard, syncTimeline));
+ }
}
+++ /dev/null
-/*\r
- * Dynamic Analyzer\r
- *\r
- * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.\r
- *\r
- * Contact: \r
- * WooJin Jung <woojin2.jung@samsung.com>\r
- * Juyoung Kim <j0.kim@samsung.com>\r
- *\r
- * Licensed under the Apache License, Version 2.0 (the "License");\r
- * you may not use this file except in compliance with the License.\r
- * You may obtain a copy of the License at\r
- *\r
- * http://www.apache.org/licenses/LICENSE-2.0\r
- *\r
- * Unless required by applicable law or agreed to in writing, software\r
- * distributed under the License is distributed on an "AS IS" BASIS,\r
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
- * See the License for the specific language governing permissions and\r
- * limitations under the License.\r
- * \r
- * Contributors:\r
- * - S-Core Co., Ltd\r
- * \r
- */\r
-\r
-package org.tizen.dynamicanalyzer.ui.thread.data;\r
-\r
-import java.util.ArrayList;\r
-import java.util.List;\r
-import java.util.concurrent.LinkedBlockingQueue;\r
-\r
-import org.tizen.dynamicanalyzer.common.AnalyzerConstants;\r
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;\r
-import org.tizen.dynamicanalyzer.swap.model.data.SyncData;\r
-import org.tizen.dynamicanalyzer.ui.thread.ThreadChartManager;\r
-//TODO: use DBInserter\r
-public class SyncAPIInserter implements Runnable {\r
- private static LinkedBlockingQueue<SyncData> syncAPIQueue = new LinkedBlockingQueue<SyncData>();\r
-\r
- private static volatile Thread inserterThread = null;\r
-\r
- public static void startThread() {\r
- if (inserterThread == null || !inserterThread.isAlive()) {\r
- synchronized (SyncAPIInserter.class) {\r
- if (inserterThread == null || !inserterThread.isAlive()) {\r
- inserterThread = new Thread(null,\r
- new SyncAPIInserter());\r
- inserterThread.start();\r
- }\r
- }\r
- }\r
- }\r
-\r
- public static void stopThread() {\r
- if (inserterThread != null && inserterThread.isAlive()) {\r
- try {\r
- sendNotify();\r
- inserterThread.join(AnalyzerConstants.THREAD_JOIN_WAIT_TIME);\r
- } catch (InterruptedException e) {\r
- e.printStackTrace();\r
- }\r
- }\r
- }\r
-\r
- public static void pushSyncEvent(SyncData syncAPI) {\r
- syncAPIQueue.offer(syncAPI);\r
- }\r
-\r
- public static void clear() {\r
- stopThread();\r
- }\r
-\r
- @Override\r
- public void run() {\r
- while (!AnalyzerManager.isExit()) {\r
- SyncData syncAPI = syncAPIQueue.poll();\r
-\r
- if (syncAPI != null) {\r
- ArrayList<List<Object>> insertData = new ArrayList<List<Object>>(); \r
- List<Object> insertRowData = new ArrayList<Object>();\r
- try {\r
- insertRowData.add(new Long(syncAPI.getSeq()));\r
- insertRowData.add(new Long(syncAPI.getTime()));\r
- insertRowData.add(new Integer(syncAPI.getApiId()));\r
- insertRowData.add(new Integer(syncAPI.getPid()));\r
- insertRowData.add(new Integer(syncAPI.getTid()));\r
- insertRowData.add(new String(syncAPI.getArgs()));\r
- insertRowData.add(new String(syncAPI.getReturn()));\r
- insertRowData.add(new Long(syncAPI.getErrno()));\r
- insertRowData.add(new Long(syncAPI.getSyncValue()));\r
- } catch (ArrayIndexOutOfBoundsException e) {\r
- e.printStackTrace();\r
- }\r
- insertData.add(insertRowData);\r
- if (insertData.size() > 0) {\r
- ThreadChartManager.getInstance().getSyncAPIDBTable().insertData(insertData);\r
- } \r
- }\r
- } \r
- }\r
-\r
- public static void sendNotify() {\r
-// syncAPIQueue.wake();\r
- }\r
-}\r
+++ /dev/null
-/*
- * Dynamic Analyzer
- *
- * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * WooJin Jung <woojin2.jung@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.data;
-
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.util.ArrayList;
-import java.util.List;
-
-import org.tizen.dynamicanalyzer.constant.CommonConstants;
-import org.tizen.dynamicanalyzer.database.DBColumn;
-import org.tizen.dynamicanalyzer.database.DBConstants;
-import org.tizen.dynamicanalyzer.database.DBTable;
-import org.tizen.dynamicanalyzer.database.IResultSet;
-
-public class SyncDataDBTable extends DBTable implements IResultSet {
- public static final String TABLENAME="SyncData";
-
- public static final String QUERY_OPTION = "order by " + COLUMN.SYNCDATAID.name;
-
- private static final String SELECT_COLUMN =
- COLUMN.SYNCDATAID.name + CommonConstants.COMMA +
- COLUMN.PID.name + CommonConstants.COMMA +
- COLUMN.TID.name + CommonConstants.COMMA +
- COLUMN.SYNCTYPE.name + CommonConstants.COMMA +
- COLUMN.SYNCVALUE.name + CommonConstants.COMMA +
- COLUMN.ATTRIBUTETYPE.name + CommonConstants.COMMA +
- COLUMN.SYNCDATATYPE.name + CommonConstants.COMMA +
- COLUMN.PARENTID.name;
- public static final String SELECT_QUERY =
- "select " + SELECT_COLUMN + " from " + TABLENAME +
- " order by " + COLUMN.SYNCDATAID.name;
-
- public enum COLUMN {
- SYNCDATAID(0, "SyncDataID"),
- PID(1, "PID"),
- TID(2, "TID"),
- SYNCTYPE(3, "SyncType"),
- SYNCVALUE(4, "SyncValue"),
- ATTRIBUTETYPE(5, "AttributeType"),
- SYNCDATATYPE(6, "SyncDataType"),
- PARENTID(7, "ParentId");
-
- public final int index;
- public final String name;
-
- COLUMN(int index, String name) {
- this.index = index;
- this.name = name;
- }
- }
-
- @Override
- public String getTableName() {
- return TABLENAME;
- }
-
- public SyncDataDBTable() {
- addColumn(new DBColumn(COLUMN.SYNCDATAID.name, DBConstants.PRIMARY_KEY, DBConstants.DBTYPE_INT4));
- addColumn(new DBColumn(COLUMN.PID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
- addColumn(new DBColumn(COLUMN.TID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
- addColumn(new DBColumn(COLUMN.SYNCTYPE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT1));
- addColumn(new DBColumn(COLUMN.SYNCVALUE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
- addColumn(new DBColumn(COLUMN.ATTRIBUTETYPE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT1));
- addColumn(new DBColumn(COLUMN.SYNCDATATYPE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT1));
- addColumn(new DBColumn(COLUMN.PARENTID.name, DBConstants.EMPTY, DBConstants.DBTYPE_INT4));
- }
-
- public List<List<Object>> getSyncDataFromDB() {
- return selectAllColumnData(QUERY_OPTION);
- }
-
- @Override
- public boolean prepare(PreparedStatement prep, List<Object> rowData) {
- boolean isPrepared = true;
-
- int columnsize = getColumnSize();
- if (columnsize != rowData.size()) {
- isPrepared = false;
- } else {
- try {
- prep.setInt(COLUMN.SYNCDATAID.index + 1, (Integer) (rowData.get(COLUMN.SYNCDATAID.index)));
- prep.setInt(COLUMN.PID.index + 1, (Integer) (rowData.get(COLUMN.PID.index)));
- prep.setInt(COLUMN.TID.index + 1, (Integer) (rowData.get(COLUMN.TID.index)));
- prep.setByte(COLUMN.SYNCTYPE.index + 1, (Byte) (rowData.get(COLUMN.SYNCTYPE.index)));
- prep.setLong(COLUMN.SYNCVALUE.index + 1, (Long) (rowData.get(COLUMN.SYNCVALUE.index)));
- prep.setByte(COLUMN.ATTRIBUTETYPE.index + 1, (Byte) (rowData.get(COLUMN.ATTRIBUTETYPE.index)));
- prep.setByte(COLUMN.SYNCDATATYPE.index + 1, (Byte) (rowData.get(COLUMN.SYNCDATATYPE.index)));
- prep.setInt(COLUMN.PARENTID.index + 1, (Integer) (rowData.get(COLUMN.PARENTID.index)));
-
- } catch (SQLException e) {
- e.printStackTrace();
- isPrepared = false;
- }
- }
-
- return isPrepared;
- }
-
- @Override
- public List<Object> extractDataFromResultSet(ResultSet rs) {
- List<Object> row = new ArrayList<Object>();
- try {
- row.add(Integer.valueOf(rs.getInt(COLUMN.SYNCDATAID.index + 1)));
- row.add(Integer.valueOf(rs.getInt(COLUMN.PID.index + 1)));
- row.add(Integer.valueOf(rs.getInt(COLUMN.TID.index + 1)));
- row.add(Byte.valueOf(rs.getByte(COLUMN.SYNCTYPE.index + 1)));
- row.add(Long.valueOf(rs.getLong(COLUMN.SYNCVALUE.index + 1)));
- row.add(Byte.valueOf(rs.getByte(COLUMN.ATTRIBUTETYPE.index + 1)));
- row.add(Byte.valueOf(rs.getByte(COLUMN.SYNCDATATYPE.index + 1)));
- row.add(Integer.valueOf(rs.getInt(COLUMN.PARENTID.index + 1)));
- } catch (SQLException e) {
- e.printStackTrace();
- return null;
- }
-
- return row;
- }
-}
+++ /dev/null
-/*\r
- * Dynamic Analyzer\r
- *\r
- * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.\r
- *\r
- * Contact: \r
- * WooJin Jung <woojin2.jung@samsung.com>\r
- * Juyoung Kim <j0.kim@samsung.com>\r
- *\r
- * Licensed under the Apache License, Version 2.0 (the "License");\r
- * you may not use this file except in compliance with the License.\r
- * You may obtain a copy of the License at\r
- *\r
- * http://www.apache.org/licenses/LICENSE-2.0\r
- *\r
- * Unless required by applicable law or agreed to in writing, software\r
- * distributed under the License is distributed on an "AS IS" BASIS,\r
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
- * See the License for the specific language governing permissions and\r
- * limitations under the License.\r
- * \r
- * Contributors:\r
- * - S-Core Co., Ltd\r
- * \r
- */\r
-\r
-package org.tizen.dynamicanalyzer.ui.thread.data;\r
-\r
-import java.util.ArrayList;\r
-import java.util.List;\r
-import java.util.concurrent.LinkedBlockingQueue;\r
-\r
-import org.tizen.dynamicanalyzer.common.AnalyzerConstants;\r
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;\r
-import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;\r
-import org.tizen.dynamicanalyzer.ui.thread.ThreadChartManager;\r
-import org.tizen.dynamicanalyzer.ui.thread.sync.ThreadPageSyncData;\r
-import org.tizen.dynamicanalyzer.ui.thread.sync.ThreadPageSyncDataManager;\r
-//TODO: use DBInserter\r
-public class SyncDataInserter implements Runnable {\r
- private static LinkedBlockingQueue<ThreadPageSyncData> syncDataQueue = new LinkedBlockingQueue<ThreadPageSyncData>();\r
-\r
- private static volatile Thread inserterThread = null;\r
-\r
- public static void startThread() {\r
- if (inserterThread == null || !inserterThread.isAlive()) {\r
- synchronized (SyncDataInserter.class) {\r
- if (inserterThread == null || !inserterThread.isAlive()) {\r
- inserterThread = new Thread(null,\r
- new SyncDataInserter());\r
- inserterThread.start();\r
- }\r
- }\r
- }\r
- }\r
-\r
- public static void stopThread() {\r
- if (inserterThread != null && inserterThread.isAlive()) {\r
- try {\r
- sendNotify();\r
- inserterThread.join(AnalyzerConstants.THREAD_JOIN_WAIT_TIME);\r
- } catch (InterruptedException e) {\r
- e.printStackTrace();\r
- }\r
- }\r
- }\r
-\r
- public static void pushSyncData(ThreadPageSyncData syncData) {\r
- syncDataQueue.offer(syncData);\r
- }\r
-\r
- public static void clear() {\r
- stopThread();\r
- }\r
-\r
- @Override\r
- public void run() {\r
- while (!AnalyzerManager.isExit()) {\r
- ThreadPageSyncData syncData = syncDataQueue.poll();\r
-\r
- if (syncData != null) {\r
- ArrayList<List<Object>> insertData = new ArrayList<List<Object>>(); \r
- List<Object> insertRowData = new ArrayList<Object>();\r
- try {\r
- insertRowData.add(new Integer(syncData.getSyncDataID()));\r
- insertRowData.add(new Integer(syncData.getPid()));\r
- insertRowData.add(new Integer(syncData.getTid()));\r
- Integer type = new Integer(syncData.getType());\r
- byte syncType = type.byteValue();\r
- insertRowData.add(new Byte(syncType));\r
- insertRowData.add(new Long(syncData.getKey()));\r
- String attrTypeStr = syncData.getAttrType();\r
- byte attrType = -1;\r
- if (attrTypeStr.equals(ThreadPageLabels.SYNC_ATTR_TYPE_NORMAL)) {\r
- attrType = ThreadPageSyncDataManager.PTHREAD_MUTEX_NORMAL;\r
- } else if (attrTypeStr.equals(ThreadPageLabels.SYNC_ATTR_TYPE_RECURSIVE)) {\r
- attrType = ThreadPageSyncDataManager.PTHREAD_MUTEX_RECURSIVE;\r
- } else if (attrTypeStr.equals(ThreadPageLabels.SYNC_ATTR_TYPE_ERRORCHECK)) {\r
- attrType = ThreadPageSyncDataManager.PTHREAD_MUTEX_ERRORCHECK; \r
- } else if (attrTypeStr.equals(ThreadPageLabels.SYNC_ATTR_TYPE_DEFAULT)) {\r
- attrType = ThreadPageSyncDataManager.PTHREAD_MUTEX_DEFAULT;\r
- } else {\r
- attrType = -1;\r
- }\r
- insertRowData.add(new Byte(attrType));\r
- insertRowData.add(new Byte(syncData.getSyncDataType()));\r
- insertRowData.add(new Integer(syncData.getParentID()));\r
- } catch (ArrayIndexOutOfBoundsException e) {\r
- e.printStackTrace();\r
- }\r
- insertData.add(insertRowData);\r
- if (insertData.size() > 0) {\r
- ThreadChartManager.getInstance().getSyncDataDBTable().insertData(insertData);\r
- }\r
- }\r
- } \r
- }\r
-\r
- public static void sendNotify() {\r
-// syncDataQueue.wake();\r
- }\r
-}\r
+++ /dev/null
-/*
- * Dynamic Analyzer
- *
- * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * WooJin Jung <woojin2.jung@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.data;
-
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.util.ArrayList;
-import java.util.List;
-
-import org.tizen.dynamicanalyzer.common.DALimit;
-import org.tizen.dynamicanalyzer.constant.CommonConstants;
-import org.tizen.dynamicanalyzer.database.DBColumn;
-import org.tizen.dynamicanalyzer.database.DBConstants;
-import org.tizen.dynamicanalyzer.database.DBTable;
-import org.tizen.dynamicanalyzer.database.IResultSet;
-
-public class SyncEventDBTable extends DBTable implements IResultSet {
- public static final String TABLENAME="SyncEvent";
-
- private static final String SELECT_COLUMN =
- COLUMN.EVENTTIME.name + CommonConstants.COMMA +
- COLUMN.APITYPE.name + CommonConstants.COMMA +
- COLUMN.TOOLTIP.name + CommonConstants.COMMA +
- COLUMN.ERRORNO.name + CommonConstants.COMMA +
- COLUMN.SYNCVALUE.name;
- public static final String SELECT_QUERY =
- "select " + SELECT_COLUMN + " from " + TABLENAME +
- " where " + COLUMN.SYNCDATAID.name + " = %s ";
-
- public enum COLUMN {
- API_SEQNUMBER(0, "APISEQNUMBER"),
- SYNCDATAID(1, "SyncDataID"),
- EVENTTIME(2, "EventTime"),
- APITYPE(3, "APIType"),
- TOOLTIP(4, "Tooltip"),
- ERRORNO(5, DBConstants.DBCOLUMN_ERROR_NUMBER),
- SYNCVALUE(6, "SyncValue");
-
- public final int index;
- public final String name;
-
- COLUMN(int index, String name) {
- this.index = index;
- this.name = name;
- }
- }
-
- @Override
- public String getTableName() {
- return TABLENAME;
- }
-
- public SyncEventDBTable() {
- addColumn(new DBColumn(COLUMN.API_SEQNUMBER.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
- addColumn(new DBColumn(COLUMN.SYNCDATAID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
- addColumn(new DBColumn(COLUMN.EVENTTIME.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
- addColumn(new DBColumn(COLUMN.APITYPE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT1));
- addColumn(new DBColumn(COLUMN.TOOLTIP.name, DBConstants.EMPTY,
- DBConstants.VARCHAR, DALimit.TOOLTIP_LENGTH));
- addColumn(new DBColumn(COLUMN.ERRORNO.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
- addColumn(new DBColumn(COLUMN.SYNCVALUE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
- setIndexColumn(COLUMN.SYNCDATAID.index);
- }
-
- public List<List<Object>> getSyncEventFromDB() {
- return selectAllColumnData(null);
- }
-
- @Override
- public boolean prepare(PreparedStatement prep, List<Object> rowData) {
- boolean isPrepared = true;
-
- int columnsize = getColumnSize();
- if (columnsize != rowData.size()) {
- isPrepared = false;
- } else {
- try {
- prep.setLong(COLUMN.API_SEQNUMBER.index + 1, (Long) (rowData.get(COLUMN.API_SEQNUMBER.index)));
- prep.setInt(COLUMN.SYNCDATAID.index + 1, (Integer) (rowData.get(COLUMN.SYNCDATAID.index)));
- prep.setLong(COLUMN.EVENTTIME.index + 1, (Long) (rowData.get(COLUMN.EVENTTIME.index)));
- prep.setByte(COLUMN.APITYPE.index + 1, (Byte) (rowData.get(COLUMN.APITYPE.index)));
- String tooltipStr = clipString((String) (rowData.get(COLUMN.TOOLTIP.index)),
- DALimit.TOOLTIP_LENGTH, rowData.get(COLUMN.EVENTTIME.index).toString());
- prep.setString(COLUMN.TOOLTIP.index + 1, tooltipStr);
- prep.setLong(COLUMN.ERRORNO.index + 1, (Long) (rowData.get(COLUMN.ERRORNO.index)));
- prep.setLong(COLUMN.SYNCVALUE.index + 1, (Long) (rowData.get(COLUMN.SYNCVALUE.index)));
- } catch (SQLException e) {
- e.printStackTrace();
- isPrepared = false;
- }
- }
-
- return isPrepared;
- }
-
- @Override
- public List<Object> extractDataFromResultSet(ResultSet rs) {
- List<Object> row = new ArrayList<Object>();
- try {
- row.add(Long.valueOf(rs.getLong(COLUMN.API_SEQNUMBER.index + 1)));
- row.add(Integer.valueOf(rs.getInt(COLUMN.SYNCDATAID.index + 1)));
- row.add(Long.valueOf(rs.getLong(COLUMN.EVENTTIME.index + 1)));
- row.add(Byte.valueOf(rs.getByte(COLUMN.APITYPE.index + 1)));
- row.add(rs.getString(COLUMN.TOOLTIP.index + 1));
- row.add(Long.valueOf(rs.getLong(COLUMN.ERRORNO.index + 1)));
- row.add(Long.valueOf(rs.getLong(COLUMN.SYNCVALUE.index + 1)));
- } catch (SQLException e) {
- e.printStackTrace();
- return null;
- }
-
- return row;
- }
-}
+++ /dev/null
-/*\r
- * Dynamic Analyzer\r
- *\r
- * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.\r
- *\r
- * Contact: \r
- * WooJin Jung <woojin2.jung@samsung.com>\r
- * Juyoung Kim <j0.kim@samsung.com>\r
- *\r
- * Licensed under the Apache License, Version 2.0 (the "License");\r
- * you may not use this file except in compliance with the License.\r
- * You may obtain a copy of the License at\r
- *\r
- * http://www.apache.org/licenses/LICENSE-2.0\r
- *\r
- * Unless required by applicable law or agreed to in writing, software\r
- * distributed under the License is distributed on an "AS IS" BASIS,\r
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
- * See the License for the specific language governing permissions and\r
- * limitations under the License.\r
- * \r
- * Contributors:\r
- * - S-Core Co., Ltd\r
- * \r
- */\r
-\r
-package org.tizen.dynamicanalyzer.ui.thread.data;\r
-\r
-import java.util.ArrayList;\r
-import java.util.List;\r
-import java.util.concurrent.LinkedBlockingQueue;\r
-\r
-import org.tizen.dynamicanalyzer.common.AnalyzerConstants;\r
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;\r
-import org.tizen.dynamicanalyzer.ui.thread.ThreadChartManager;\r
-import org.tizen.dynamicanalyzer.ui.thread.sync.ThreadPageSyncDataEvent;\r
-//TODO: use DBInserter\r
-public class SyncEventInserter implements Runnable {\r
- private static LinkedBlockingQueue<ThreadPageSyncDataEvent> syncEventQueue = new LinkedBlockingQueue<ThreadPageSyncDataEvent>();\r
-\r
- private static volatile Thread inserterThread = null;\r
-\r
- public static void startThread() {\r
- if (inserterThread == null || !inserterThread.isAlive()) {\r
- synchronized (SyncEventInserter.class) {\r
- if (inserterThread == null || !inserterThread.isAlive()) {\r
- inserterThread = new Thread(null,\r
- new SyncEventInserter());\r
- inserterThread.start();\r
- }\r
- }\r
- }\r
- }\r
-\r
- public static void stopThread() {\r
- if (inserterThread != null && inserterThread.isAlive()) {\r
- try {\r
- sendNotify();\r
- inserterThread.join(AnalyzerConstants.THREAD_JOIN_WAIT_TIME);\r
- } catch (InterruptedException e) {\r
- e.printStackTrace();\r
- }\r
- }\r
- }\r
-\r
- public static void pushSyncEvent(ThreadPageSyncDataEvent syncEvent) {\r
- syncEventQueue.offer(syncEvent);\r
- }\r
-\r
- public static void clear() {\r
- stopThread();\r
- }\r
-\r
- @Override\r
- public void run() {\r
- while (!AnalyzerManager.isExit()) {\r
- ThreadPageSyncDataEvent syncEvent = syncEventQueue.poll();\r
-\r
- if (syncEvent != null) {\r
- ArrayList<List<Object>> insertData = new ArrayList<List<Object>>(); \r
- List<Object> insertRowData = new ArrayList<Object>();\r
- try {\r
- insertRowData.add(new Long(syncEvent.getContents().getSeq()));\r
- insertRowData.add(new Integer(syncEvent.getSyncDataID()));\r
- insertRowData.add(new Long(syncEvent.getTime()));\r
- Integer apiType = new Integer(syncEvent.getApiType());\r
- insertRowData.add(new Byte(apiType.byteValue()));\r
- insertRowData.add(new String(syncEvent.getTooltipContent()));\r
- insertRowData.add(new Long(syncEvent.getErrorNum()));\r
- insertRowData.add(new Long(syncEvent.getSyncVal()));\r
- } catch (ArrayIndexOutOfBoundsException e) {\r
- e.printStackTrace();\r
- }\r
- insertData.add(insertRowData);\r
- if (insertData.size() > 0) {\r
- ThreadChartManager.getInstance().getSyncEventDBTable().insertData(insertData);\r
- }\r
- }\r
- } \r
- }\r
-\r
- public static void sendNotify() {\r
-// syncEventQueue.wake();\r
- }\r
-}\r
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Hyunjong Park <phjwithyou.park@samsung.com>
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * yeongtaik byeon <yeongtaik.byeon@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+
+package org.tizen.dynamicanalyzer.ui.thread.data;
+
+import java.util.List;
+import java.util.Map;
+
+import org.tizen.dynamicanalyzer.common.DALimit;
+import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants;
+import org.tizen.dynamicanalyzer.swap.logparser.LogPackage;
+import org.tizen.dynamicanalyzer.swap.logparser.Logs;
+import org.tizen.dynamicanalyzer.swap.logparser.PageDataManager;
+import org.tizen.dynamicanalyzer.swap.model.data.LogData;
+import org.tizen.dynamicanalyzer.ui.thread.db.SyncAPIDBTable;
+import org.tizen.dynamicanalyzer.ui.thread.db.SyncDataDBTable;
+import org.tizen.dynamicanalyzer.ui.thread.db.SyncEventDBTable;
+import org.tizen.dynamicanalyzer.ui.thread.db.ThreadAPIDBTable;
+import org.tizen.dynamicanalyzer.ui.thread.db.ThreadDataDBTable;
+import org.tizen.dynamicanalyzer.ui.thread.db.ThreadEventDBTable;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageSyncData;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageThreadData;
+
+public class ThreadDataManager extends PageDataManager {
+ private static ThreadDataManager instance = null;
+ public final static double THREAD_DATA_MEMORY_KB = 0.3;
+ public final static double SYNC_DATA_MEMORY_KB = 0.3;
+ public final static double CHART_TYPE_HEAP_MEMORY_KB = 4.6 * 5;
+ public final static double MAX_THREAD_HEAP_MEMORY_KB = 10000; // possible to
+ // make
+ // approximately
+ // 400 chart
+
+ private ThreadDataDBTable threadDataTable = null;
+ private ThreadEventDBTable threadEventTable = null;
+ private ThreadAPIDBTable threadAPITable = null;
+
+ private SyncDataDBTable syncDataTable = null;
+ private SyncEventDBTable syncEventTable = null;
+ private SyncAPIDBTable syncAPITable = null;
+
+ private ThreadLoadDataMaker loadManager;
+ private ThreadThreadDataMaker tManager;
+ private ThreadSyncDataMaker sManager;
+
+ private ThreadDataManager() {
+ threadDataTable = new ThreadDataDBTable();
+ threadEventTable = new ThreadEventDBTable();
+ threadAPITable = new ThreadAPIDBTable();
+
+ syncDataTable = new SyncDataDBTable();
+ syncEventTable = new SyncEventDBTable();
+ syncAPITable = new SyncAPIDBTable();
+
+ loadManager = new ThreadLoadDataMaker();
+ tManager = new ThreadThreadDataMaker();
+ sManager = new ThreadSyncDataMaker();
+ }
+
+ public static ThreadDataManager getInstance() {
+ if (null == instance) {
+ instance = new ThreadDataManager();
+ }
+ return instance;
+ }
+
+ public ThreadLoadDataMaker getThreadLoadDataMamker() {
+ return loadManager;
+ }
+
+ public ThreadThreadDataMaker getThreadDataMaker() {
+ return tManager;
+ }
+
+ public ThreadSyncDataMaker getSyncDataMaker() {
+ return sManager;
+ }
+
+ public ThreadEventDBTable getThreadEventDBTable() {
+ return threadEventTable;
+ }
+
+ public ThreadAPIDBTable getThreadAPIDBTable() {
+ return threadAPITable;
+ }
+
+ public SyncDataDBTable getSyncDataDBTable() {
+ return syncDataTable;
+ }
+
+ public SyncEventDBTable getSyncEventDBTable() {
+ return syncEventTable;
+ }
+
+ public SyncAPIDBTable getSyncAPIDBTable() {
+ return syncAPITable;
+ }
+
+ public void clear() {
+ tManager.clear();
+ sManager.clear();
+ }
+
+ public void saveData(Map<String, String> dataMap) {
+ threadDataTable.inserthreadPageThreadData(tManager.getChartRowData());
+ sManager.insertNoBlockEndTimeSyncEvent();
+ sManager.getNotInsertSyncEventList().clear();
+ }
+
+ public void openData(Map<String, String> dataMap) {
+ selectThreadDataWhenOpen();
+ selectSyncDataWhenOpen();
+ }
+
+ @Override
+ protected void onThreadStop() {
+ tManager.insertRemainingCallEvent();
+ }
+
+ private void checkHeapMemory() {
+ double useHeapMemory = 0;
+ useHeapMemory += tManager.getChartRowData().size() * THREAD_DATA_MEMORY_KB;
+ useHeapMemory += sManager.getChartRowData().size() * SYNC_DATA_MEMORY_KB;
+ int chartItemCount = tManager.getChartRowData().size() + sManager.getChartRowData().size();
+ useHeapMemory += CHART_TYPE_HEAP_MEMORY_KB * chartItemCount;
+ if ((MAX_THREAD_HEAP_MEMORY_KB < useHeapMemory)) {
+ DALimit.stopTraceAndOpenWarningDialog();
+ }
+ }
+
+ private void selectThreadDataWhenOpen() {
+ List<List<Object>> threadDatas = threadDataTable.getThreadDataFromDB();
+ int size = threadDatas.size();
+ for (int i = 0; i < size; i++) {
+ List<Object> rowData = threadDatas.get(i);
+ int id = (Integer) rowData.get(ThreadDataDBTable.COLUMN.THREADDATAID.index);
+ int pid = (Integer) rowData.get(ThreadDataDBTable.COLUMN.PID.index);
+ int tid = (Integer) rowData.get(ThreadDataDBTable.COLUMN.TID.index);
+ byte threadType = (Byte) rowData.get(ThreadDataDBTable.COLUMN.THREADTYPE.index);
+ byte attrType = (Byte) rowData.get(ThreadDataDBTable.COLUMN.ATTRIBUTETYPE.index);
+ String attributeType = ThreadThreadDataMaker.getAttrTypeByTypeInt(attrType);
+ long startTime = (Long) rowData.get(ThreadDataDBTable.COLUMN.STARTTIME.index);
+ long endTime = (Long) rowData.get(ThreadDataDBTable.COLUMN.ENDTIME.index);
+ int functionID = (Integer) rowData.get(ThreadDataDBTable.COLUMN.FUNCTIONID.index);
+ String className = (String) rowData.get(ThreadDataDBTable.COLUMN.CLASSNAME.index);
+
+ ThreadPageThreadData threadData = new ThreadPageThreadData(id, pid, tid, threadType,
+ attributeType, startTime, endTime, functionID, className);
+ tManager.setChartRowData(threadData);
+ }
+ }
+
+ private void selectSyncDataWhenOpen() {
+ List<List<Object>> syncDatas = syncDataTable.getSyncDataFromDB();
+ int syncSize = syncDatas.size();
+ for (int i = 0; i < syncSize; i++) {
+ ThreadPageSyncData syncData = makeSyncData(syncDatas.get(i));
+ sManager.setChartRowData(syncData);
+ }
+ }
+
+ private ThreadPageSyncData makeSyncData(List<Object> rowData) {
+ ThreadPageSyncData syncData = null;
+ int id = (Integer) rowData.get(SyncDataDBTable.COLUMN.SYNCDATAID.index);
+ int pid = (Integer) rowData.get(SyncDataDBTable.COLUMN.PID.index);
+ int tid = (Integer) rowData.get(SyncDataDBTable.COLUMN.TID.index);
+ byte syncType = (Byte) rowData.get(SyncDataDBTable.COLUMN.SYNCTYPE.index);
+ long syncValue = (Long) rowData.get(SyncDataDBTable.COLUMN.SYNCVALUE.index);
+ byte attrType = (Byte) rowData.get(SyncDataDBTable.COLUMN.ATTRIBUTETYPE.index);
+ String attributeType = ThreadSyncDataMaker.getAttrTypeByTypeInt(attrType);
+ byte syncDataType = (Byte) rowData.get(SyncDataDBTable.COLUMN.SYNCDATATYPE.index);
+ int parentID = (Integer) rowData.get(SyncDataDBTable.COLUMN.PARENTID.index);
+ syncData = new ThreadPageSyncData(id, pid, tid, syncType, syncValue, attributeType,
+ syncDataType, parentID);
+ return syncData;
+ }
+
+ @Override
+ protected void makeData(LogPackage pack) {
+ List<LogData> loadInputs = getLogsFromLogPackage(pack, DataChannelConstants.MSG_DATA_SYSTEM);
+ if (null != loadInputs) {
+ loadManager.makeLoadData(loadInputs);
+ }
+ List<LogData> threadInputs = getLogsFromLogPackage(pack,
+ DataChannelConstants.MSG_PROBE_THREAD);
+ if (null != threadInputs) {
+ tManager.makeThreadData(threadInputs);
+ checkHeapMemory();
+ }
+ List<LogData> syncInputs = getLogsFromLogPackage(pack, DataChannelConstants.MSG_PROBE_SYNC);
+ if (null != syncInputs) {
+ sManager.makeSyncData(syncInputs);
+ checkHeapMemory();
+ }
+ }
+
+ private List<LogData> getLogsFromLogPackage(LogPackage logPack, int logCenterConstants) {
+ Logs logs = logPack.getLogs(logCenterConstants);
+ if (null == logs || logs.getRawLogs().size() == 0) {
+ return null;
+ }
+ List<LogData> ret = logs.getLogs();
+ return ret;
+ }
+}
\ No newline at end of file
+++ /dev/null
-/*\r
- * Dynamic Analyzer\r
- *\r
- * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.\r
- *\r
- * Contact: \r
- * WooJin Jung <woojin2.jung@samsung.com>\r
- * Juyoung Kim <j0.kim@samsung.com>\r
- *\r
- * Licensed under the Apache License, Version 2.0 (the "License");\r
- * you may not use this file except in compliance with the License.\r
- * You may obtain a copy of the License at\r
- *\r
- * http://www.apache.org/licenses/LICENSE-2.0\r
- *\r
- * Unless required by applicable law or agreed to in writing, software\r
- * distributed under the License is distributed on an "AS IS" BASIS,\r
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
- * See the License for the specific language governing permissions and\r
- * limitations under the License.\r
- * \r
- * Contributors:\r
- * - S-Core Co., Ltd\r
- * \r
- */\r
-\r
-package org.tizen.dynamicanalyzer.ui.thread.data;\r
-\r
-import java.util.ArrayList;\r
-import java.util.List;\r
-import java.util.concurrent.LinkedBlockingQueue;\r
-\r
-import org.tizen.dynamicanalyzer.common.AnalyzerConstants;\r
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;\r
-import org.tizen.dynamicanalyzer.swap.model.data.ThreadData;\r
-import org.tizen.dynamicanalyzer.ui.thread.ThreadChartManager;\r
-import org.tizen.dynamicanalyzer.ui.thread.thread.ThreadPageThreadDataEvent;\r
-// TODO: use DBInserter\r
-public class ThreadEventInserter implements Runnable {\r
- private static LinkedBlockingQueue<ThreadPageThreadDataEvent> threadEventQueue = new LinkedBlockingQueue<ThreadPageThreadDataEvent>();\r
-\r
- private static volatile Thread inserterThread = null;\r
-\r
- public static void startThread() {\r
- if (inserterThread == null || !inserterThread.isAlive()) {\r
- synchronized (ThreadEventInserter.class) {\r
- if (inserterThread == null || !inserterThread.isAlive()) {\r
- inserterThread = new Thread(null,\r
- new ThreadEventInserter());\r
- inserterThread.start();\r
- }\r
- }\r
- }\r
- }\r
-\r
- public static void stopThread() {\r
- if (inserterThread != null && inserterThread.isAlive()) {\r
- try {\r
- sendNotify();\r
- inserterThread.join(AnalyzerConstants.THREAD_JOIN_WAIT_TIME);\r
- } catch (InterruptedException e) {\r
- e.printStackTrace();\r
- }\r
- }\r
- }\r
-\r
- public static void pushThreadEvent(ThreadPageThreadDataEvent threadEvent) {\r
- threadEventQueue.offer(threadEvent);\r
- }\r
-\r
- public static void clear() {\r
- stopThread();\r
- }\r
-\r
- @Override\r
- public void run() {\r
- while (!AnalyzerManager.isExit()) {\r
- ThreadPageThreadDataEvent threadEvent = threadEventQueue.poll();\r
-\r
- if (threadEvent != null) {\r
- ArrayList<List<Object>> insertData = new ArrayList<List<Object>>(); \r
- List<Object> insertRowData = new ArrayList<Object>();\r
- try {\r
- insertRowData.add(new Integer(threadEvent.getThreadDataID()));\r
- insertRowData.add(new Long(threadEvent.getTime()));\r
- insertRowData.add(new Integer(threadEvent.getTid()));\r
- Integer apiType = new Integer(threadEvent.getApiType());\r
- insertRowData.add(new Byte(apiType.byteValue()));\r
- insertRowData.add(new String(threadEvent.getTooltipContent()));\r
- insertRowData.add(new Long(threadEvent.getErrorNum()));\r
- Integer eventType = new Integer(threadEvent.getEventType());\r
- insertRowData.add(new Byte(eventType.byteValue()));\r
- insertRowData.add(new Integer(threadEvent.getThreadType()));\r
- Integer callerTid = -1;\r
- if (threadEvent.getCallerTid() != null) {\r
- callerTid = new Integer(threadEvent.getCallerTid()); \r
- }\r
- insertRowData.add(callerTid);\r
- } catch (ArrayIndexOutOfBoundsException e) {\r
- e.printStackTrace();\r
- }\r
- insertData.add(insertRowData);\r
- if (insertData.size() > 0) {\r
- ThreadChartManager.getInstance().getThreadEventDBTable().insertData(insertData);\r
- }\r
- // save ThreadAPI\r
- if (threadEvent.getEventType() == ThreadPageThreadDataEvent.TYPE_API) {\r
- ArrayList<List<Object>> apiData = new ArrayList<List<Object>>(); \r
- List<Object> apiRowData = new ArrayList<Object>();\r
- ThreadData tData = (ThreadData) threadEvent.getContents();\r
- try {\r
- apiRowData.add(new Long(tData.getSeq()));\r
- apiRowData.add(new Integer(threadEvent.getThreadDataID()));\r
- apiRowData.add(new Long(tData.getTime()));\r
- apiRowData.add(new Integer(tData.getApiId()));\r
- apiRowData.add(new Integer(tData.getPid()));\r
- apiRowData.add(new Integer(tData.getTid()));\r
- apiRowData.add(new String(tData.getArgs()));\r
- apiRowData.add(new String(tData.getReturn()));\r
- apiRowData.add(new Long(tData.getErrno()));\r
- } catch (ArrayIndexOutOfBoundsException e) {\r
- e.printStackTrace();\r
- }\r
- apiData.add(apiRowData);\r
- if (apiData.size() > 0) {\r
- ThreadChartManager.getInstance().getThreadAPIDBTable().insertData(apiData);\r
- } \r
- }\r
- }\r
- } \r
- }\r
-\r
- public static void sendNotify() {\r
-// threadEventQueue.wake();\r
- }\r
-}\r
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Hyunjong Park <phjwithyou.park@samsung.com>
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * yeongtaik byeon <yeongtaik.byeon@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+package org.tizen.dynamicanalyzer.ui.thread.data;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;
+import org.tizen.dynamicanalyzer.swap.model.data.LogData;
+import org.tizen.dynamicanalyzer.swap.model.data.ProcessProfileData;
+import org.tizen.dynamicanalyzer.swap.model.data.SystemData;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageThreadDataEvent;
+import org.tizen.dynamicanalyzer.util.Logger;
+
+public class ThreadLoadDataMaker {
+
+ public void makeLoadData(List<LogData> loadInputs) {
+ int logSize = loadInputs.size();
+ for (int i = 0; i < logSize; i++) {
+ parseLoad(loadInputs.get(i));
+ }
+ }
+
+ public void parseLoad(LogData input) {
+ if (null == input) {
+ return;
+ }
+
+ if (!(input instanceof SystemData)) {
+ return;
+ }
+
+ ProcessProfileData[] processDataList = ((SystemData) input).getProcessProfileDataList();
+ List<ThreadPageThreadDataEvent> insertThreadEventList = new ArrayList<ThreadPageThreadDataEvent>();
+ for (int i = 0; i < processDataList.length; i++) {
+ String loads = processDataList[i].getThreadLoad();
+ String[] temp = loads.split(",");
+ String tid;
+ for (int j = 0; j + 1 < temp.length; j += 2) {
+ try {
+ tid = temp[j];
+ } catch (NumberFormatException nfe) {
+ Logger.error("parseLoad - tid parsing");
+ break;
+ }
+ int load = (int) (Double.parseDouble(temp[j + 1]));
+ long time = input.getTime();
+ ThreadPageThreadDataEvent event = new ThreadPageThreadDataEvent(
+ ThreadPageThreadDataEvent.TYPE_LOAD, load, -1, time, Integer.parseInt(tid),
+ String.valueOf(load) + ThreadPageLabels.THREAD_CHART_ITEM_PERCENT, -1, null);
+ event.setThreadDataID(ThreadDataManager.getInstance().getThreadDataMaker()
+ .getThreadDataID(event.getTid()));
+ insertThreadEventList.add(event);
+ }
+ }
+ ThreadDataManager.getInstance().getThreadEventDBTable()
+ .insertThreadEventData(insertThreadEventList);
+ }
+}
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Hyunjong Park <phjwithyou.park@samsung.com>
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * yeongtaik byeon <yeongtaik.byeon@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+package org.tizen.dynamicanalyzer.ui.thread.data;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+
+import org.tizen.dynamicanalyzer.constant.CommonConstants;
+import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
+import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;
+import org.tizen.dynamicanalyzer.swap.model.data.LogData;
+import org.tizen.dynamicanalyzer.swap.model.data.SyncData;
+import org.tizen.dynamicanalyzer.ui.summary.SummaryDataManager;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageSyncData;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageSyncDataEvent;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageThreadData;
+import org.tizen.dynamicanalyzer.util.Logger;
+
+public class ThreadSyncDataMaker {
+ private List<ThreadPageSyncData> chartRowData = new ArrayList<ThreadPageSyncData>();
+ private List<ThreadPageSyncDataEvent> noBlockEndTimeSyncEventQueue = new ArrayList<ThreadPageSyncDataEvent>();
+ private List<ThreadPageSyncDataEvent> syncEventQueue = new ArrayList<ThreadPageSyncDataEvent>();
+ private List<ThreadPageSyncDataEvent> syncEventQueueOfThread = new ArrayList<ThreadPageSyncDataEvent>();
+ private HashMap<String, Integer> syncAttrMap = new HashMap<String, Integer>();
+
+ public static final int PTHREAD_MUTEX_NORMAL = 0;
+ public static final int PTHREAD_MUTEX_RECURSIVE = 1;
+ public static final int PTHREAD_MUTEX_ERRORCHECK = 2;
+ public static final int PTHREAD_MUTEX_DEFAULT = 3;
+
+ public ThreadSyncDataMaker() {
+ }
+
+ public void makeSyncData(List<LogData> syncInputs) {
+ int logSize = syncInputs.size();
+ for (int i = 0; i < logSize; i++) {
+ parseSync(syncInputs.get(i));
+ }
+ insertSyncData();
+ }
+
+ public void parseSync(LogData input) {
+ if (null == input || !(input instanceof SyncData)) {
+ return;
+ }
+ SyncData syncData = (SyncData) input;
+ long time = syncData.getTime();
+ int tID = syncData.getTid();
+ int type = syncData.getSyncType();
+ int apiType = syncData.getApiType();
+ String apiName = syncData.getApiName();
+ String name = Long.toString(syncData.getSyncValue());
+ long errorNum = syncData.getErrno();
+ if (errorNum != 0) {
+ SummaryDataManager.getInstance().getFailedApiDataMaker().makeData(syncData);
+ }
+ ThreadPageSyncDataEvent event;
+ switch (type) {
+ case LogCenterConstants.SYNC_TYPE_TIZEN_MUTEX:
+ case LogCenterConstants.SYNC_TYPE_TIZEN_MONITOR:
+ case LogCenterConstants.SYNC_TYPE_TIZEN_SEMAPHORE:
+ event = new ThreadPageSyncDataEvent(name, type, apiType, time, tID, apiName, errorNum,
+ input);
+ syncEventQueue.add(event);
+ syncEventQueueOfThread.add(event);
+ break;
+ case LogCenterConstants.SYNC_TYPE_PTHREAD_MUTEX:
+ case LogCenterConstants.SYNC_TYPE_PTHREAD_COND_VARIABLE:
+ if (apiName.equals(ThreadPageLabels.SYNC_API_PTHREAD_MUTEXATTR_INIT)) {
+ syncAttrMap.put(syncData.getArgs(), PTHREAD_MUTEX_NORMAL);
+ } else if (apiName.equals(ThreadPageLabels.SYNC_API_PTHREAD_MUTEXATTR_SETTYPE)) {
+ checkMutexAttrType(syncData.getArgs());
+ } else {
+ if (apiName.equals(ThreadPageLabels.SYNC_API_PTHREAD_MUTEX_INIT)) {
+ checkMutexType(syncData.getArgs());
+ }
+ event = new ThreadPageSyncDataEvent(name, type, apiType, time, tID, apiName,
+ errorNum, input);
+ syncEventQueue.add(event);
+ syncEventQueueOfThread.add(event);
+ }
+ break;
+ case LogCenterConstants.SYNC_TYPE_PTHREAD_RWLOCK:
+ case LogCenterConstants.SYNC_TYPE_PTHREAD_SPINLOCK:
+ case LogCenterConstants.SYNC_TYPE_PTHREAD_BARRIER:
+ event = new ThreadPageSyncDataEvent(name, type, apiType, time, tID, apiName, errorNum,
+ input);
+ syncEventQueue.add(event);
+ syncEventQueueOfThread.add(event);
+ Logger.error("sync parse - type = " + type);
+ break;
+ default:
+ Logger.error("sync parse unknown - type = " + type);
+ }
+ }
+
+ public void insertSyncData() {
+ makeSyncDataOfThread();
+ makeSyncData();
+ }
+
+ private void makeSyncData() {
+ int size = syncEventQueue.size();
+ if (size == 0) {
+ return;
+ }
+ List<ThreadPageSyncDataEvent> insertSyncEventQueue = new ArrayList<ThreadPageSyncDataEvent>();
+ List<ThreadPageSyncData> insertSyncDataQueue = new ArrayList<ThreadPageSyncData>();
+ ThreadPageSyncData parent;
+ ThreadPageSyncData data;
+ ThreadPageSyncDataEvent event;
+ for (int i = 0; i < size; i++) {
+ event = syncEventQueue.get(0);
+ String syncVal = event.getSyncVal();
+ String pid = Integer.toString(event.getContents().getPid());
+ parent = findParentData(syncVal);
+ if (null == parent) {
+ Integer syncAttrTypeInt = syncAttrMap.get(syncVal);
+ String syncAttrType;
+
+ if (null != syncAttrTypeInt) {
+ syncAttrType = getAttrTypeByTypeInt(syncAttrTypeInt);
+ } else {
+ syncAttrType = getAttrTypeString(event);
+ }
+ parent = new ThreadPageSyncData(event.getType(), syncVal, pid, event.getTid(),
+ syncAttrType, ThreadPageSyncData.SYNC_PARENT);
+ chartRowData.add(parent);
+ insertSyncDataQueue.add(parent);
+ }
+ event.setSyncDataID(parent.getSyncDataID());
+ data = parent.findChildData(event.getTid());
+ insertSyncEventQueue.add(event);
+ if (null == data) {
+ String attrType = parent.getAttrType();
+ data = new ThreadPageSyncData(event.getType(), syncVal, pid, event.getTid(),
+ attrType, ThreadPageSyncData.SYNC_CHILD);
+ data.setParentID(parent.getSyncDataID());
+ parent.pushSync(data);
+ chartRowData.add(data);
+ insertSyncDataQueue.add(data);
+ }
+ try {
+ ThreadPageSyncDataEvent cloneEvent = (ThreadPageSyncDataEvent) event.clone();
+ cloneEvent.setSyncDataID(data.getSyncDataID());
+ insertSyncEventQueue.add(cloneEvent);
+ } catch (CloneNotSupportedException e) {
+ e.printStackTrace();
+ continue;
+ } finally {
+ syncEventQueue.remove(0);
+ }
+ }
+ insertSyncEvent(insertSyncEventQueue);
+ ThreadDataManager.getInstance().getSyncDataDBTable().insertSyncData(insertSyncDataQueue);
+ }
+
+ public void makeSyncDataOfThread() {
+ int size = syncEventQueueOfThread.size();
+ if (size == 0) {
+ return;
+ }
+ List<ThreadPageSyncDataEvent> insertSyncEventQueue = new ArrayList<ThreadPageSyncDataEvent>();
+ List<ThreadPageSyncData> insertSyncDataQueue = new ArrayList<ThreadPageSyncData>();
+ List<SyncData> insertSyncAPIQueue = new ArrayList<SyncData>();
+ ThreadPageThreadData data;
+ ThreadPageSyncDataEvent event;
+ ThreadPageSyncData sync;
+ for (int i = 0; i < size; i++) {
+ event = syncEventQueueOfThread.get(0);
+ String pid = Integer.toString(event.getContents().getPid());
+ data = ThreadDataManager.getInstance().getThreadDataMaker()
+ .findParentDataOfThread(event.getTid());
+ if (null != data) {
+ String syncVal = event.getSyncVal();
+ sync = data.findSyncData(syncVal);
+ if (null == sync) {
+ Integer syncAttrTypeInt = syncAttrMap.get(syncVal);
+ String syncAttrType;
+ if (null != syncAttrTypeInt) {
+ syncAttrType = ThreadSyncDataMaker.getAttrTypeByTypeInt(syncAttrTypeInt);
+ } else {
+ syncAttrType = ThreadSyncDataMaker.getAttrTypeString(event);
+ }
+ sync = new ThreadPageSyncData(event.getType(), syncVal, pid, event.getTid(),
+ syncAttrType, ThreadPageSyncData.THREAD_CHILD);
+ sync.setParentID(data.getThreadDataID());
+ chartRowData.add(sync);
+ data.pushSync(sync);
+ insertSyncDataQueue.add(sync);
+ }
+ event.setSyncDataID(sync.getSyncDataID());
+ insertSyncEventQueue.add(event);
+ if (ThreadPageSyncData.isSyncApi(event.getApiType())) {
+ insertSyncAPIQueue.add((SyncData) event.getContents());
+ }
+ }
+ syncEventQueueOfThread.remove(0);
+ }
+ insertSyncEvent(insertSyncEventQueue);
+ ThreadDataManager.getInstance().getSyncDataDBTable().insertSyncData(insertSyncDataQueue);
+ ThreadDataManager.getInstance().getSyncAPIDBTable().insertSyncAPIData(insertSyncAPIQueue);
+ }
+
+ private ThreadPageSyncData findParentData(String name) {
+ int size = chartRowData.size();
+ ThreadPageSyncData ret;
+ for (int i = 0; i < size; i++) {
+ ret = chartRowData.get(i);
+ if (ret.getKey().equals(name)
+ && ret.getSyncDataType() == ThreadPageSyncData.SYNC_PARENT) {
+ return ret;
+ }
+ }
+ return null;
+ }
+
+ public static String getAttrTypeByTypeInt(int typeInt) {
+ if (typeInt == PTHREAD_MUTEX_NORMAL) {
+ return ThreadPageLabels.SYNC_ATTR_TYPE_NORMAL;
+ } else if (typeInt == PTHREAD_MUTEX_RECURSIVE) {
+ return ThreadPageLabels.SYNC_ATTR_TYPE_RECURSIVE;
+ } else if (typeInt == PTHREAD_MUTEX_ERRORCHECK) {
+ return ThreadPageLabels.SYNC_ATTR_TYPE_ERRORCHECK;
+ } else if (typeInt == PTHREAD_MUTEX_DEFAULT) { // for open trace
+ return ThreadPageLabels.SYNC_ATTR_TYPE_DEFAULT;
+ } else {
+ return CommonConstants.EMPTY;
+ }
+ }
+
+ public static String getAttrTypeString(ThreadPageSyncDataEvent event) {
+ int type = event.getType();
+ if (type == LogCenterConstants.SYNC_TYPE_TIZEN_MUTEX) {
+ return ThreadPageLabels.SYNC_ATTR_TYPE_RECURSIVE;
+ } else if (type == LogCenterConstants.SYNC_TYPE_PTHREAD_MUTEX) {
+ return ThreadPageLabels.SYNC_ATTR_TYPE_DEFAULT;
+ }
+ return CommonConstants.EMPTY;
+ }
+
+ private void checkMutexAttrType(String input) {
+ String[] temp = input.split(",");
+ if (temp.length != 2) {
+ return;
+ }
+ String obj = temp[0];
+ String type = temp[1].trim();
+ if (null != syncAttrMap.get(obj)) {
+ syncAttrMap.put(obj, Integer.valueOf(type));
+ }
+ }
+
+ private void checkMutexType(String input) {
+ String[] temp = input.split(",");
+ if (temp.length != 2) {
+ return;
+ }
+ String obj = temp[0];
+ String attrObj = temp[1].trim();
+ Integer attrType = syncAttrMap.get(attrObj);
+ if (attrType != null) {
+ syncAttrMap.put(obj, attrType);
+ }
+ }
+
+ public void insertNoBlockEndTimeSyncEvent() {
+ ThreadDataManager.getInstance().getSyncEventDBTable()
+ .insertSyncEventData(noBlockEndTimeSyncEventQueue);
+ }
+
+ private void insertSyncEvent(List<ThreadPageSyncDataEvent> insertSyncEventQueue) {
+ makeBlockEndTime(insertSyncEventQueue);
+ ThreadDataManager.getInstance().getSyncEventDBTable()
+ .insertSyncEventData(insertSyncEventQueue);
+ }
+
+ private void makeBlockEndTime(List<ThreadPageSyncDataEvent> insertSyncEventQueue) {
+ setBlockEndTimeOfInsertList(insertSyncEventQueue);
+ updateNoBlockEndTimeList(insertSyncEventQueue);
+ addInsertListFromNoBlockEndTimeList(insertSyncEventQueue);
+ }
+
+ private void setBlockEndTimeOfInsertList(List<ThreadPageSyncDataEvent> list) {
+ setBlockEndTime(list, list);
+ setBlockEndTime(noBlockEndTimeSyncEventQueue, list);
+ }
+
+ private void setBlockEndTimeOfNoBlockEndTimeList(List<ThreadPageSyncDataEvent> insertSyncEventQueue) {
+ for (ThreadPageSyncDataEvent event : insertSyncEventQueue) {
+ updateBlockEndTimeOfNotReleaseSyncEventQueue(event);
+ }
+ }
+
+ private void setBlockEndTime(List<ThreadPageSyncDataEvent> targetList,
+ List<ThreadPageSyncDataEvent> refList) {
+ sortListByTime(targetList);
+ for (ThreadPageSyncDataEvent targerEvent : targetList) {
+ setBlockEndTime(targerEvent, refList);
+ }
+ }
+
+ private void updateBlockEndTimeOfNotReleaseSyncEventQueue(ThreadPageSyncDataEvent event) {
+ setBlockEndTime(event, noBlockEndTimeSyncEventQueue);
+ }
+
+ private void setBlockEndTime(ThreadPageSyncDataEvent targetEvent,
+ List<ThreadPageSyncDataEvent> refList) {
+ for (ThreadPageSyncDataEvent refEvent : refList) {
+ if (targetEvent.equals(refEvent)
+ || targetEvent.getSyncDataID() != refEvent.getSyncDataID()
+ || targetEvent.getBlockEndTime() != -1
+ || targetEvent.getTime() >= refEvent.getTime()
+ || !isMappingBlockTimeLog(targetEvent.getApiType(), refEvent.getApiType())
+ || targetEvent.getErrorNum() != 0) {
+ continue;
+ }
+ targetEvent.setBlockEndTime(refEvent.getTime());
+ return;
+ }
+ }
+
+ private void sortListByTime(List<ThreadPageSyncDataEvent> list) {
+ Comparator<ThreadPageSyncDataEvent> comparator = new Comparator<ThreadPageSyncDataEvent>() {
+ @Override
+ public int compare(ThreadPageSyncDataEvent arg0, ThreadPageSyncDataEvent arg1) {
+ if (arg0.getTime() > arg1.getTime()) {
+ return 1;
+ } else if (arg0.getTime() < arg1.getTime()) {
+ return -1;
+ } else {
+ return 0;
+ }
+ }
+ };
+ Collections.sort(list, comparator);
+ }
+
+ private void updateNoBlockEndTimeList(List<ThreadPageSyncDataEvent> insertSyncEventQueue) {
+ List<ThreadPageSyncDataEvent> removeEveneList = new ArrayList<ThreadPageSyncDataEvent>();
+ int size = insertSyncEventQueue.size();
+ for (int i = 0; i < size; i++) {
+ ThreadPageSyncDataEvent event = insertSyncEventQueue.get(i);
+ if (event.getBlockEndTime() == -1) {
+ try {
+ removeEveneList.add(event);
+ noBlockEndTimeSyncEventQueue.add(event.clone());
+ } catch (CloneNotSupportedException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+ insertSyncEventQueue.removeAll(removeEveneList);
+ setBlockEndTimeOfNoBlockEndTimeList(insertSyncEventQueue);
+ }
+
+ private void addInsertListFromNoBlockEndTimeList(
+ List<ThreadPageSyncDataEvent> insertSyncEventQueue) {
+ List<ThreadPageSyncDataEvent> removeEveneList = new ArrayList<ThreadPageSyncDataEvent>();
+ int size = noBlockEndTimeSyncEventQueue.size();
+ for (int i = 0; i < size; i++) {
+ ThreadPageSyncDataEvent event = noBlockEndTimeSyncEventQueue.get(i);
+ if (event.getBlockEndTime() != -1 || isRequireOnlyEventTimeLog(event.getApiType())) {
+ try {
+ removeEveneList.add(event);
+ insertSyncEventQueue.add(event.clone());
+ } catch (CloneNotSupportedException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+ noBlockEndTimeSyncEventQueue.removeAll(removeEveneList);
+ }
+
+ private boolean isRequireOnlyEventTimeLog(int apiType) {
+ if (apiType == LogCenterConstants.SYNC_API_TYPE_NEW
+ || apiType == LogCenterConstants.SYNC_API_TYPE_NOTIFY
+ || apiType == LogCenterConstants.SYNC_API_TYPE_NOTIFY_ALL
+ || apiType == LogCenterConstants.SYNC_API_TYPE_OTHER) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ private boolean isMappingBlockTimeLog(int targetType, int refAPIType) {
+ if (targetType == LogCenterConstants.SYNC_API_TYPE_ACQUIRE_WAIT_START
+ && refAPIType == LogCenterConstants.SYNC_API_TYPE_ACQUIRE_WAIT_END) {
+ return true;
+ }
+ if (targetType == LogCenterConstants.SYNC_API_TYPE_ACQUIRE_WAIT_END
+ && refAPIType == LogCenterConstants.SYNC_API_TYPE_RELEASE) {
+ return true;
+ }
+ if (targetType == LogCenterConstants.SYNC_API_TYPE_RELEASE
+ && refAPIType == LogCenterConstants.SYNC_API_TYPE_ACQUIRE_WAIT_START) {
+ return true;
+ }
+ if (targetType == LogCenterConstants.SYNC_API_TYPE_COND_WAIT_START
+ && refAPIType == LogCenterConstants.SYNC_API_TYPE_COND_WAIT_END) {
+ return true;
+ }
+ if (targetType == LogCenterConstants.SYNC_API_TYPE_COND_WAIT_END
+ && refAPIType == LogCenterConstants.SYNC_API_TYPE_RELEASE) {
+ return true;
+ }
+ if (targetType == LogCenterConstants.SYNC_API_TYPE_RELEASE
+ && refAPIType == LogCenterConstants.SYNC_API_TYPE_COND_WAIT_START) {
+ return true;
+ }
+ if (targetType == LogCenterConstants.SYNC_API_TYPE_TRY_ACQUIRE
+ && refAPIType == LogCenterConstants.SYNC_API_TYPE_RELEASE) {
+ return true;
+ }
+ return false;
+ }
+
+ public void setChartRowData(ThreadPageSyncData data) {
+ chartRowData.add(data);
+ }
+
+ public List<ThreadPageSyncData> getChartRowData() {
+ List<ThreadPageSyncData> returnList = new ArrayList<ThreadPageSyncData>();
+ for(ThreadPageSyncData data : chartRowData){
+ returnList.add(data);
+ }
+ return returnList;
+ }
+
+ public List<ThreadPageSyncDataEvent> getNotInsertSyncEventList() {
+ return noBlockEndTimeSyncEventQueue;
+ }
+
+ public void clear() {
+ noBlockEndTimeSyncEventQueue.clear();
+ chartRowData.clear();
+ syncEventQueue.clear();
+ syncEventQueueOfThread.clear();
+ syncAttrMap.clear();
+ ThreadPageSyncData.clear(); // reset internal seq number
+ }
+
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Hyunjong Park <phjwithyou.park@samsung.com>
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * yeongtaik byeon <yeongtaik.byeon@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+package org.tizen.dynamicanalyzer.ui.thread.data;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+import org.tizen.dynamicanalyzer.common.Global;
+import org.tizen.dynamicanalyzer.common.SymbolManager;
+import org.tizen.dynamicanalyzer.constant.CommonConstants;
+import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
+import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;
+import org.tizen.dynamicanalyzer.swap.model.data.LogData;
+import org.tizen.dynamicanalyzer.swap.model.data.ThreadData;
+import org.tizen.dynamicanalyzer.ui.summary.SummaryDataManager;
+import org.tizen.dynamicanalyzer.ui.summary.warning.WarningCase;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageThreadData;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageThreadDataEvent;
+import org.tizen.dynamicanalyzer.util.Logger;
+
+public class ThreadThreadDataMaker {
+ private List<ThreadPageThreadDataEvent> eventQueue = new ArrayList<ThreadPageThreadDataEvent>();
+ private HashMap<String, Integer> joinableThreadMap = new HashMap<String, Integer>();
+ private List<ThreadPageThreadData> chartRowData = new ArrayList<ThreadPageThreadData>();
+ private HashMap<String, Long> threadFuncMap = new HashMap<String, Long>();
+ private HashMap<String, Integer> threadAttrMap = new HashMap<String, Integer>();
+ private List<ThreadPageThreadDataEvent> callEventQueue = new ArrayList<ThreadPageThreadDataEvent>();
+
+ public static final int PTHREAD_CREATE_JOINABLE = 0;
+ public static final int PTHREAD_CREATE_DETACHED = 1;
+
+ public void makeThreadData(List<LogData> threadInputs) {
+ int logSize = threadInputs.size();
+ for (int i = 0; i < logSize; i++) {
+ parseAPI(threadInputs.get(i));
+ }
+ int size = eventQueue.size();
+ if (size == 0) {
+ return;
+ }
+
+ List<ThreadPageThreadDataEvent> insertThreadEvent = new ArrayList<ThreadPageThreadDataEvent>();
+ for (ThreadPageThreadDataEvent event : eventQueue) {
+ if (true == checkPairEvent(event)) {
+ event.setThreadDataID(getThreadDataID(event.getTid()));
+ insertThreadEvent.add(event);
+ }
+ }
+
+ eventQueue.removeAll(insertThreadEvent);
+ ThreadDataManager.getInstance().getThreadEventDBTable()
+ .insertThreadEventData(insertThreadEvent);
+ ThreadDataManager.getInstance().getThreadAPIDBTable()
+ .insertThreadAPIData(insertThreadEvent);
+ }
+
+ public void parseAPI(LogData input) {
+ if (null == input) {
+ return;
+ }
+ if (!(input instanceof ThreadData)) {
+ return;
+ }
+ ThreadData log = (ThreadData) input;
+ int threadType = log.getThreadType();
+ switch (threadType) {
+ case LogCenterConstants.THREAD_TYPE_PTHREAD:
+ parsePthread(log);
+ break;
+ case LogCenterConstants.THREAD_TYPE_TIZEN:
+ // parseOSP(log);
+ break;
+ default:
+ Logger.error("thread page err: unknown thread type");
+ }
+ }
+
+ private void parsePthread(ThreadData input) {
+ long time = input.getTime();
+ String pid = Integer.toString(input.getPid());
+ int apiType = input.getApiType();
+ String apiName = input.getApiName();
+ long errorNum = input.getErrno();
+ ThreadPageThreadDataEvent event;
+ int tID = input.getTid();
+ String pthreadId = Long.toString(input.getPThreadId());
+ if (errorNum != 0) {
+ SummaryDataManager.getInstance().getFailedApiDataMaker().makeData(input);
+ }
+ switch (apiType) {
+ case LogCenterConstants.THREAD_API_TYPE_NEW:
+ case LogCenterConstants.THREAD_API_TYPE_STOP:
+ case LogCenterConstants.THREAD_API_TYPE_EXIT:
+ case LogCenterConstants.THREAD_API_TYPE_WAIT_START:
+ case LogCenterConstants.THREAD_API_TYPE_OTHER:
+ if (apiName.equals(ThreadPageLabels.THREAD_API_PTHREAD_ATTR_INIT)) {
+ threadAttrMap.put(input.getArgs(), PTHREAD_CREATE_JOINABLE);
+ } else if (apiName.equals(ThreadPageLabels.THREAD_API_PTHREAD_ATTR_SETDETACHSTATE)) {
+ checkThreadAttrType(input.getArgs());
+ }
+ event = new ThreadPageThreadDataEvent(ThreadPageThreadDataEvent.TYPE_API,
+ LogCenterConstants.THREAD_TYPE_PTHREAD, apiType, time, tID, apiName, errorNum,
+ input);
+ eventQueue.add(event);
+ break;
+ case LogCenterConstants.THREAD_API_TYPE_START:
+ if (apiName.equals(ThreadPageLabels.THREAD_API_PTHREAD_CREATE)) {
+ checkThreadType(input.getArgs(), pthreadId);
+ checkThreadFunc(input.getArgs(), pthreadId);
+ }
+ event = new ThreadPageThreadDataEvent(ThreadPageThreadDataEvent.TYPE_API,
+ LogCenterConstants.THREAD_TYPE_PTHREAD, apiType, time, tID, apiName, errorNum,
+ input);
+ event.setCallID(pthreadId);
+ callEventQueue.add(event);
+ break;
+ case LogCenterConstants.THREAD_API_TYPE_WAIT_END: {
+ event = new ThreadPageThreadDataEvent(ThreadPageThreadDataEvent.TYPE_EVENT,
+ LogCenterConstants.THREAD_TYPE_PTHREAD, apiType, time, tID, apiName, errorNum,
+ input);
+ eventQueue.add(event);
+ Integer joninTID = joinableThreadMap.get(pthreadId);
+ if (null != joninTID
+ && input.getApiName().equals(ThreadPageLabels.THREAD_API_PTHREAD_JOIN)) {
+ SummaryDataManager
+ .getInstance()
+ .getWarningDataMaker()
+ .removeData(event.getContents(),
+ ThreadPageLabels.THREAD_CHART_NAME_TID + findCallerTid(pthreadId),
+ WarningCase.JOINABLE_LEAK.getType());
+ joinableThreadMap.remove(pthreadId);
+ }
+ }
+ break;
+ case LogCenterConstants.THREAD_API_TYPE_INTERNAL_STOP: {
+ threadAttrMap.remove(pthreadId);
+ event = new ThreadPageThreadDataEvent(ThreadPageThreadDataEvent.TYPE_EVENT,
+ LogCenterConstants.THREAD_TYPE_PTHREAD, apiType, time, tID,
+ ThreadPageLabels.THREAD_CHART_ITEM_EXITED, errorNum, input);
+ event.setCallID(pthreadId);
+ Integer joninTID = joinableThreadMap.get(pthreadId);
+ if (null != joninTID && joninTID == tID) {
+ SummaryDataManager
+ .getInstance()
+ .getWarningDataMaker()
+ .add(input, ThreadPageLabels.THREAD_CHART_NAME_TID + tID,
+ WarningCase.JOINABLE_LEAK.getType());
+ }
+ callEventQueue.add(event);
+ setEndTime(tID, time);
+ }
+ break;
+ case LogCenterConstants.THREAD_API_TYPE_INTERNAL_START:
+ Integer threadAttrTypeInt = threadAttrMap.get(pthreadId);
+ String threadAttrType;
+ int funcID;
+ if (null != threadAttrTypeInt) {
+ threadAttrType = getAttrTypeByTypeInt(threadAttrTypeInt);
+ } else {
+ threadAttrType = ThreadPageLabels.THREAD_ATTR_TYPE_JOINABLE;
+ }
+ if (threadAttrType == ThreadPageLabels.THREAD_ATTR_TYPE_JOINABLE) {
+ joinableThreadMap.put(pthreadId, tID);
+ }
+
+ funcID = SymbolManager.getFuncId(null, threadFuncMap.get(pthreadId), input.getPid(),
+ input.getTime());
+ ThreadPageThreadData data = new ThreadPageThreadData(ThreadPageThreadData.TYPE_PTHREAD,
+ pid, tID, threadAttrType, funcID);
+ data.setStartTime(time);
+ chartRowData.add(data);
+ event = new ThreadPageThreadDataEvent(ThreadPageThreadDataEvent.TYPE_EVENT,
+ LogCenterConstants.THREAD_TYPE_PTHREAD, apiType, time, tID,
+ ThreadPageLabels.THREAD_CHART_ITEM_CREATED, errorNum, input);
+ eventQueue.add(event);
+
+ List<ThreadPageThreadDataEvent> insertThreadEvent = new ArrayList<ThreadPageThreadDataEvent>();
+ for (int i = 0; i < callEventQueue.size(); i++) {
+ ThreadPageThreadDataEvent callEvent = callEventQueue.get(i);
+ if (callEvent.getCallID().equals(pthreadId)
+ && callEvent.getApiType() == LogCenterConstants.THREAD_API_TYPE_INTERNAL_STOP) {
+ callEvent.setThreadDataID(getThreadDataID(callEvent.getTid()));
+ insertThreadEvent.add(callEvent);
+ }
+ }
+ callEventQueue.removeAll(insertThreadEvent);
+ ThreadDataManager.getInstance().getThreadEventDBTable()
+ .insertThreadEventData(insertThreadEvent);
+ ThreadDataManager.getInstance().getThreadAPIDBTable()
+ .insertThreadAPIData(insertThreadEvent);
+
+ break;
+ default:
+ Logger.error("thread page err: unknown thread api type");
+ }
+ }
+
+ public void insertRemainingCallEvent() {
+ List<ThreadPageThreadDataEvent> insertThreadEvent = new ArrayList<ThreadPageThreadDataEvent>();
+ for (int i = 0; i < callEventQueue.size(); i++) {
+ ThreadPageThreadDataEvent callEvent = callEventQueue.get(i);
+ callEvent.setThreadDataID(getThreadDataID(callEvent.getTid()));
+ insertThreadEvent.add(callEvent);
+ }
+ ThreadDataManager.getInstance().getThreadEventDBTable()
+ .insertThreadEventData(insertThreadEvent);
+ ThreadDataManager.getInstance().getThreadAPIDBTable()
+ .insertThreadAPIData(insertThreadEvent);
+ callEventQueue.clear();
+ }
+
+ private boolean checkPairEvent(ThreadPageThreadDataEvent event) {
+ if (event.getEventType() != ThreadPageThreadDataEvent.TYPE_EVENT) {
+ return true;
+ }
+
+ int apiType = event.getApiType();
+ int threadType = event.getThreadType();
+ ThreadData tData = (ThreadData) event.getContents();
+ if (LogCenterConstants.THREAD_API_TYPE_INTERNAL_START == apiType) {
+ int callEventQueueSize = callEventQueue.size();
+ ThreadPageThreadDataEvent callEvent;
+ for (int i = 0; i < callEventQueueSize; i++) {
+ callEvent = callEventQueue.get(i);
+ if (callEvent.getApiType() != LogCenterConstants.THREAD_API_TYPE_START) {
+ continue;
+ } else if (callEvent.getThreadType() != threadType) {
+ continue;
+ } else {
+ if (threadType == LogCenterConstants.THREAD_TYPE_TIZEN) {
+ String callerTizenID = callEvent.getCallID();
+ String eventTizenID = Long.toString(tData.getOspThreadId());
+ if (eventTizenID.equals(callerTizenID)) {
+ event.setCallerTid(callEvent.getTid());
+ callEventQueue.remove(i);
+ return true;
+ }
+ } else {
+ String callerPthreadID = callEvent.getCallID();
+ String eventPthreadID = Long.toString(tData.getPThreadId());
+ if (eventPthreadID.equals(callerPthreadID)) {
+ event.setCallerTid(callEvent.getTid());
+ callEventQueue.remove(i);
+
+ callEvent.setThreadDataID(getThreadDataID(callEvent.getTid()));
+
+ List<ThreadPageThreadDataEvent> insertThreadEvent = new ArrayList<ThreadPageThreadDataEvent>();
+ insertThreadEvent.add(callEvent);
+ ThreadDataManager.getInstance().getThreadEventDBTable()
+ .insertThreadEventData(insertThreadEvent);
+ ThreadDataManager.getInstance().getThreadAPIDBTable()
+ .insertThreadAPIData(insertThreadEvent);
+
+ return true;
+ }
+ }
+ }
+ }
+ return false;
+ } else if (LogCenterConstants.THREAD_API_TYPE_WAIT_END == apiType) {
+ if (!event.isJoinAPI()) {
+ return true;
+ }
+
+ int callEventQueueSize = callEventQueue.size();
+ ThreadPageThreadDataEvent callEvent;
+ for (int i = 0; i < callEventQueueSize; i++) {
+ callEvent = callEventQueue.get(i);
+ if (callEvent.getApiType() != LogCenterConstants.THREAD_API_TYPE_INTERNAL_STOP) {
+ continue;
+ } else if (callEvent.getThreadType() != threadType) {
+ continue;
+ } else {
+ if (threadType == LogCenterConstants.THREAD_TYPE_TIZEN) {
+ String callerTizenID = callEvent.getCallID();
+ String eventTizenID = Long.toString(tData.getOspThreadId());
+ if (eventTizenID.equals(callerTizenID)) {
+ event.setCallerTid(callEvent.getTid());
+ callEvent.setCallerTid(event.getTid());
+ // join, delete warning
+ SummaryDataManager
+ .getInstance()
+ .getWarningDataMaker()
+ .removeData(
+ event.getContents(),
+ ThreadPageLabels.THREAD_CHART_NAME_TID
+ + callEvent.getTid(),
+ WarningCase.JOINABLE_LEAK.getType());
+ callEventQueue.remove(i);
+ return true;
+ }
+ } else {
+ String callerPthreadID = callEvent.getCallID();
+ String eventPthreadID = Long.toString(tData.getPThreadId());
+ if (eventPthreadID.equals(callerPthreadID)) {
+ event.setCallerTid(callEvent.getTid());
+ callEvent.setCallerTid(event.getTid());
+ callEventQueue.remove(i);
+ callEvent.setThreadDataID(getThreadDataID(callEvent.getTid()));
+
+ List<ThreadPageThreadDataEvent> insertThreadEvent = new ArrayList<ThreadPageThreadDataEvent>();
+ insertThreadEvent.add(callEvent);
+ ThreadDataManager.getInstance().getThreadEventDBTable()
+ .insertThreadEventData(insertThreadEvent);
+ ThreadDataManager.getInstance().getThreadAPIDBTable()
+ .insertThreadAPIData(insertThreadEvent);
+ return true;
+ }
+ }
+ }
+ }
+ return false;
+ } else {
+ return true;
+ }
+ }
+
+ private int findCallerTid(String id) {
+ int callEventQueueSize = callEventQueue.size();
+ ThreadPageThreadDataEvent callEvent;
+ for (int i = 0; i < callEventQueueSize; i++) {
+ callEvent = callEventQueue.get(i);
+ if (callEvent.getApiType() != LogCenterConstants.THREAD_API_TYPE_INTERNAL_STOP) {
+ continue;
+ }
+ String callerTID = callEvent.getCallID();
+
+ if (callerTID != null && callerTID.equals(id)) {
+ return callEvent.getTid();
+ }
+ }
+ return -1;
+ }
+
+ public void setChartRowData(ThreadPageThreadData data) {
+ chartRowData.add(data);
+ }
+
+ public List<ThreadPageThreadData> getChartRowData() {
+ List<ThreadPageThreadData> returnList = new ArrayList<ThreadPageThreadData>();
+ for (ThreadPageThreadData data : chartRowData) {
+ returnList.add(data);
+ }
+ return returnList;
+ }
+
+ private void setEndTime(int tID, long endTime) {
+ for (ThreadPageThreadData threadData : chartRowData) {
+ if (threadData.getTid() == tID) {
+ threadData.setEndTime(endTime);
+ }
+ }
+ }
+
+ public int getThreadDataID(int tID) {
+ for (ThreadPageThreadData threadData : chartRowData) {
+ if (threadData.getTid() == tID) {
+ return threadData.getThreadDataID();
+ }
+ }
+ return 0;
+ }
+
+ public void createMainThreadItem(int tid) {
+ int funcID = Global.getFunctionID("main");
+ ThreadPageThreadData mainData = new ThreadPageThreadData(ThreadPageThreadData.TYPE_MAIN,
+ Integer.toString(tid), tid, CommonConstants.EMPTY, funcID);
+ chartRowData.add(mainData);
+ }
+
+ public static String getAttrTypeByTypeInt(int typeInt) {
+ if (typeInt == PTHREAD_CREATE_JOINABLE) {
+ return ThreadPageLabels.THREAD_ATTR_TYPE_JOINABLE;
+ } else if (typeInt == PTHREAD_CREATE_DETACHED) {
+ return ThreadPageLabels.THREAD_ATTR_TYPE_DETACHED;
+ } else {
+ return CommonConstants.EMPTY;
+ }
+ }
+
+ private void checkThreadAttrType(String input) {
+ String[] temp = input.split(",");
+ if (temp.length != 2) {
+ return;
+ }
+ String obj = temp[0];
+ String type = temp[1].trim();
+ if (null != threadAttrMap.get(obj)) {
+ threadAttrMap.put(obj, Integer.valueOf(type));
+ }
+ }
+
+ private void checkThreadType(String args, String pthreadId) {
+ String[] temp = args.split(",");
+ if (temp.length != 4) {
+ return;
+ }
+ String attrObj = temp[1].trim();
+
+ Integer attrType = threadAttrMap.get(attrObj);
+ if (attrType != null) {
+ threadAttrMap.put(pthreadId, attrType);
+ }
+ }
+
+ private void checkThreadFunc(String args, String pthreadId) {
+ String[] temp = args.split(",");
+ if (temp.length != 4) {
+ return;
+ }
+ // 3rd argument is function address
+ String strFuncAddr = temp[2].trim();
+ Long funcAddr = Long.decode(strFuncAddr);
+ threadFuncMap.put(pthreadId, funcAddr);
+ }
+
+ public ThreadPageThreadData findParentDataOfThread(int tID) {
+ for (ThreadPageThreadData threadData : chartRowData) {
+ if (threadData.getTid() == tID) {
+ return threadData;
+ }
+ }
+ return null;
+ }
+
+ public void clear() {
+ callEventQueue.clear();
+ eventQueue.clear();
+ joinableThreadMap.clear();
+ chartRowData.clear();
+ threadFuncMap.clear();
+ threadAttrMap.clear();
+ ThreadPageThreadData.clear(); // reset internal seq number
+ }
+
+ /*
+ * private void parseOSP(ThreadData input) { long time = input.getTime();
+ * String pid = Integer.toString(input.getPid()); int tID = input.getTid();
+ * String tid = Integer.toString(input.getTid()); int apiType =
+ * input.getApiType(); String apiName = input.getApiName(); String callID =
+ * Long.toString(input.getOspThreadId()); String className = null;
+ * ThreadPageThreadData data; ThreadPageThreadDataEvent event; long errorNum
+ * = input.getErrno();
+ *
+ * if (errorNum != 0) {
+ * SummaryDataManager.getInstance().getFailedApiDataMaker().makeData(input);
+ * }
+ *
+ * switch (apiType) { case LogCenterConstants.THREAD_API_TYPE_NEW: case
+ * LogCenterConstants.THREAD_API_TYPE_STOP: case
+ * LogCenterConstants.THREAD_API_TYPE_EXIT: case
+ * LogCenterConstants.THREAD_API_TYPE_WAIT_START: case
+ * LogCenterConstants.THREAD_API_TYPE_OTHER: event = new
+ * ThreadPageThreadDataEvent(ThreadPageThreadDataEvent.TYPE_API,
+ * LogCenterConstants.THREAD_TYPE_TIZEN, apiType, time, tID, apiName,
+ * errorNum, input); pushEvent(event); break; case
+ * LogCenterConstants.THREAD_API_TYPE_START: event = new
+ * ThreadPageThreadDataEvent(ThreadPageThreadDataEvent.TYPE_API,
+ * LogCenterConstants.THREAD_TYPE_TIZEN, apiType, time, tID, apiName,
+ * errorNum, input);
+ *
+ * event.setCallID(callID); data = findCallQueue(callID); if (null != data)
+ * { data.setThreadClassName(input.getClassName()); chartRowData.add(data);
+ * } pushEvent(event); pushCallEvent(event); break; case
+ * LogCenterConstants.THREAD_API_TYPE_WAIT_END: if
+ * (input.getApiName().equals(ThreadPageLabels.THREAD_API_TIZEN_JOIN)) {
+ * event = new
+ * ThreadPageThreadDataEvent(ThreadPageThreadDataEvent.TYPE_EVENT,
+ * LogCenterConstants.THREAD_TYPE_TIZEN, apiType, time, tID, apiName,
+ * errorNum, input); pushEvent(event); // join, delete warning //
+ * AnalyzerManager.getWarningChecker().removeData( //
+ * ThreadPageLabels.THREAD_CHART_NAME_TID // +
+ * findCallerTid(Long.toString(input // .getOspThreadId())), //
+ * WarningCase.JOINABLE_LEAK.getType()); SummaryDataManager .getInstance()
+ * .getWarningDataMaker() .removeData(event.getContents(),
+ * ThreadPageLabels.THREAD_CHART_NAME_TID + findCallerTid(callID),
+ * WarningCase.JOINABLE_LEAK.getType()); } // FIXME : do not shows sleep's
+ * wait end
+ *
+ * break; case LogCenterConstants.THREAD_API_TYPE_INTERNAL_STOP: event = new
+ * ThreadPageThreadDataEvent(ThreadPageThreadDataEvent.TYPE_EVENT,
+ * LogCenterConstants.THREAD_TYPE_TIZEN, apiType, time, tID,
+ * ThreadPageLabels.THREAD_CHART_ITEM_EXITED, errorNum, input);
+ * event.setCallID(Long.toString(input.getOspThreadId())); pushEvent(event);
+ * pushCallEvent(event); String joinableThread = joinableThreadMap.get(tID);
+ * if (null != joinableThread &&
+ * joinableThread.equals(ThreadPageLabels.THREAD_ATTR_TYPE_JOINABLE)) { //
+ * warningData // WarningData wData = new WarningData( //
+ * WarningCase.JOINABLE_LEAK.getType(), // event.getContents(), //
+ * ThreadPageLabels.THREAD_CHART_NAME_TID + tid); //
+ * AnalyzerManager.getWarningChecker().getWarningData().add(wData);
+ * SummaryDataManager .getInstance() .getWarningDataMaker()
+ * .add(event.getContents(), ThreadPageLabels.THREAD_CHART_NAME_TID + tid,
+ * WarningCase.JOINABLE_LEAK.getType()); } break; case
+ * LogCenterConstants.THREAD_API_TYPE_INTERNAL_START: Integer
+ * threadAttrTypeInt = threadAttrMap.get(tID); String threadAttrType; if
+ * (null != threadAttrTypeInt) { threadAttrType =
+ * getAttrTypeByTypeInt(threadAttrTypeInt); } else { threadAttrType =
+ * ThreadPageLabels.THREAD_ATTR_TYPE_JOINABLE; } joinableThreadMap.put(tID,
+ * threadAttrType);
+ *
+ * data = new ThreadPageThreadData(ThreadPageThreadData.TYPE_TIZEN, pid,
+ * tID, ThreadPageLabels.THREAD_ATTR_TYPE_JOINABLE, -1); // TIZEN thread
+ * includes the internal thread if ((className = checkCalledThread(callID))
+ * != null) { data.setThreadClassName(className); } chartRowData.add(data);
+ * event = new
+ * ThreadPageThreadDataEvent(ThreadPageThreadDataEvent.TYPE_EVENT,
+ * LogCenterConstants.THREAD_TYPE_TIZEN, apiType, time, tID,
+ * ThreadPageLabels.THREAD_CHART_ITEM_CREATED, errorNum, input);
+ * pushEvent(event); break; default:
+ * Logger.error("thread page err: unknown thread api type"); } }
+ *
+ * private ThreadPageThreadData findCallQueue(String callID) { int tid =
+ * findCallerTid(callID); int size; size = chartRowData.size();
+ * ThreadPageThreadData ret; for (int i = 0; i < size; i++) { ret =
+ * chartRowData.get(i); if (ret.getTid() == tid) { chartRowData.remove(i);
+ * return ret; } } return null; }
+ *
+ * private String checkCalledThread(String callId) { if (null == callId) {
+ * return null; } int callEventQueueSize = callEventQueue.size();
+ * ThreadPageThreadDataEvent callEvent; for (int i = 0; i <
+ * callEventQueueSize; i++) { callEvent = callEventQueue.get(i); if
+ * (callEvent.getApiType() != LogCenterConstants.THREAD_API_TYPE_START) {
+ * continue; } if (callId.equals(callEvent.getCallID())) { ThreadData
+ * threadData = (ThreadData) callEvent.getContents(); return
+ * threadData.getClassName(); } } return null; }
+ */
+}
*
* Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
*
- * Contact:
+ * Contact:
+ * Hyunjong Park <phjwithyou.park@samsung.com>
* WooJin Jung <woojin2.jung@samsung.com>
* Juyoung Kim <j0.kim@samsung.com>
*
*
*/
-package org.tizen.dynamicanalyzer.ui.thread.data;
+package org.tizen.dynamicanalyzer.ui.thread.db;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.database.DBColumn;
import org.tizen.dynamicanalyzer.database.DBConstants;
+import org.tizen.dynamicanalyzer.database.DBInsertManager;
+import org.tizen.dynamicanalyzer.database.DBInserter;
import org.tizen.dynamicanalyzer.database.DBTable;
-import org.tizen.dynamicanalyzer.database.IResultSet;
+import org.tizen.dynamicanalyzer.swap.model.data.SyncData;
+
+public class SyncAPIDBTable extends DBTable {
+ public static final String TABLENAME = "SYNCAPI";
+ private DBInserter dbInserter = null;
+
+ private static final String SELECT_COLUMN = COLUMN.SEQ.name + CommonConstants.COMMA
+ + COLUMN.APICALLTIME.name + CommonConstants.COMMA + COLUMN.APIID.name
+ + CommonConstants.COMMA + COLUMN.PID.name + CommonConstants.COMMA + COLUMN.TID.name
+ + CommonConstants.COMMA + COLUMN.ARGUMENT.name + CommonConstants.COMMA
+ + COLUMN.RETURN.name + CommonConstants.COMMA + COLUMN.ERRORNO.name;
+ public static final String SELECT_QUERY = "select " + SELECT_COLUMN + " from "
+ + SyncEventDBTable.TABLENAME + CommonConstants.COMMA + TABLENAME + " where "
+ + SyncEventDBTable.COLUMN.SYNCDATAID.name + " = %s and "
+ + SyncEventDBTable.COLUMN.API_SEQNUMBER.name + " = " + COLUMN.SEQ.name;
-public class SyncAPIDBTable extends DBTable implements IResultSet {
- public static final String TABLENAME="SyncAPI";
-
- private static final String SELECT_COLUMN =
- COLUMN.SEQ.name + CommonConstants.COMMA +
- COLUMN.APICALLTIME.name + CommonConstants.COMMA +
- COLUMN.APIID.name + CommonConstants.COMMA +
- COLUMN.PID.name + CommonConstants.COMMA +
- COLUMN.TID.name + CommonConstants.COMMA +
- COLUMN.ARGUMENT.name + CommonConstants.COMMA +
- COLUMN.RETURN.name + CommonConstants.COMMA +
- COLUMN.ERRORNO.name;
- public static final String SELECT_QUERY =
- "select " + SELECT_COLUMN + " from " + SyncEventDBTable.TABLENAME +
- CommonConstants.COMMA + TABLENAME +
- " where " + SyncEventDBTable.COLUMN.SYNCDATAID.name + " = %s and " +
- SyncEventDBTable.COLUMN.API_SEQNUMBER.name + " = " + COLUMN.SEQ.name;
-
public enum COLUMN {
- SEQ(0, "SEQNUMBER"),
- APICALLTIME(1, "APICallTime"),
- APIID(2, "APIID"),
- PID(3, "PID"),
- TID(4, "TID"),
- ARGUMENT(5, DBConstants.DBCOLUMN_ARGUMENT),
- RETURN(6, DBConstants.DBCOLUMN_RETURN_VALUE),
- ERRORNO(7, DBConstants.DBCOLUMN_ERROR_NUMBER),
- SYNCVALUE(8, "SyncValue");
-
+ SEQ(0, "SEQNUMBER"), APICALLTIME(1, "APICallTime"), APIID(2, "APIID"), PID(3, "PID"), TID(
+ 4, "TID"), ARGUMENT(5, DBConstants.DBCOLUMN_ARGUMENT), RETURN(6,
+ DBConstants.DBCOLUMN_RETURN_VALUE), ERRORNO(7, DBConstants.DBCOLUMN_ERROR_NUMBER), SYNCVALUE(
+ 8, "SyncValue");
+
public final int index;
public final String name;
-
+
COLUMN(int index, String name) {
this.index = index;
this.name = name;
}
}
-
+
@Override
public String getTableName() {
return TABLENAME;
}
-
+
public SyncAPIDBTable() {
addColumn(new DBColumn(COLUMN.SEQ.name, DBConstants.PRIMARY_KEY, DBConstants.DBTYPE_LONG));
- addColumn(new DBColumn(COLUMN.APICALLTIME.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
- addColumn(new DBColumn(COLUMN.APIID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.APICALLTIME.name, DBConstants.NOT_NULL,
+ DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.APIID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
addColumn(new DBColumn(COLUMN.PID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
addColumn(new DBColumn(COLUMN.TID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
- addColumn(new DBColumn(COLUMN.ARGUMENT.name, DBConstants.EMPTY,
- DBConstants.DBTYPE_VARCHAR, DALimit.FUNCTION_ARGUMENTS_VALUE_LENGTH));
- addColumn(new DBColumn(COLUMN.RETURN.name, DBConstants.EMPTY,
- DBConstants.DBTYPE_VARCHAR, DALimit.FUNCTION_RETURN_VALUE_LENGTH));
+ addColumn(new DBColumn(COLUMN.ARGUMENT.name, DBConstants.EMPTY, DBConstants.DBTYPE_VARCHAR,
+ DALimit.FUNCTION_ARGUMENTS_VALUE_LENGTH));
+ addColumn(new DBColumn(COLUMN.RETURN.name, DBConstants.EMPTY, DBConstants.DBTYPE_VARCHAR,
+ DALimit.FUNCTION_RETURN_VALUE_LENGTH));
addColumn(new DBColumn(COLUMN.ERRORNO.name, DBConstants.EMPTY, DBConstants.DBTYPE_LONG));
addColumn(new DBColumn(COLUMN.SYNCVALUE.name, DBConstants.EMPTY, DBConstants.DBTYPE_LONG));
+ dbInserter = DBInsertManager.makeInserter(this);
+ }
+
+ public void insertSyncAPIData(List<SyncData> insertSyncAPIList) {
+ if (insertSyncAPIList.size() == 0) {
+ return;
+ }
+ ArrayList<List<Object>> insertData = new ArrayList<List<Object>>();
+ for (SyncData syncAPI : insertSyncAPIList) {
+ List<Object> insertRowData = new ArrayList<Object>();
+ try {
+ insertRowData.add(new Long(syncAPI.getSeq()));
+ insertRowData.add(new Long(syncAPI.getTime()));
+ insertRowData.add(new Integer(syncAPI.getApiId()));
+ insertRowData.add(new Integer(syncAPI.getPid()));
+ insertRowData.add(new Integer(syncAPI.getTid()));
+ insertRowData.add(new String(syncAPI.getArgs()));
+ insertRowData.add(new String(syncAPI.getReturn()));
+ insertRowData.add(new Long(syncAPI.getErrno()));
+ insertRowData.add(new Long(syncAPI.getSyncValue()));
+ } catch (ArrayIndexOutOfBoundsException e) {
+ e.printStackTrace();
+ }
+ insertData.add(insertRowData);
+ }
+ if (insertData.size() > 0) {
+ dbInserter.pushData(insertData);
+ }
}
public List<List<Object>> getSyncAPIFromDB() {
return selectAllColumnData(null);
}
-
+
@Override
public boolean prepare(PreparedStatement prep, List<Object> rowData) {
boolean isPrepared = true;
-
int columnsize = getColumnSize();
if (columnsize != rowData.size()) {
isPrepared = false;
} else {
try {
prep.setLong(COLUMN.SEQ.index + 1, (Long) (rowData.get(COLUMN.SEQ.index)));
- prep.setLong(COLUMN.APICALLTIME.index + 1, (Long) (rowData.get(COLUMN.APICALLTIME.index)));
+ prep.setLong(COLUMN.APICALLTIME.index + 1,
+ (Long) (rowData.get(COLUMN.APICALLTIME.index)));
prep.setInt(COLUMN.APIID.index + 1, (Integer) (rowData.get(COLUMN.APIID.index)));
prep.setInt(COLUMN.PID.index + 1, (Integer) (rowData.get(COLUMN.PID.index)));
prep.setInt(COLUMN.TID.index + 1, (Integer) (rowData.get(COLUMN.TID.index)));
String argumentStr = clipString((String) (rowData.get(COLUMN.ARGUMENT.index)),
- DALimit.FUNCTION_ARGUMENTS_VALUE_LENGTH, rowData.get(COLUMN.SEQ.index).toString());
+ DALimit.FUNCTION_ARGUMENTS_VALUE_LENGTH, rowData.get(COLUMN.SEQ.index)
+ .toString());
prep.setString(COLUMN.ARGUMENT.index + 1, argumentStr);
String retStr = clipString((String) (rowData.get(COLUMN.RETURN.index)),
- DALimit.FUNCTION_RETURN_VALUE_LENGTH, rowData.get(COLUMN.SEQ.index).toString());
+ DALimit.FUNCTION_RETURN_VALUE_LENGTH, rowData.get(COLUMN.SEQ.index)
+ .toString());
prep.setString(COLUMN.RETURN.index + 1, retStr);
prep.setLong(COLUMN.ERRORNO.index + 1, (Long) (rowData.get(COLUMN.ERRORNO.index)));
- prep.setLong(COLUMN.SYNCVALUE.index + 1, (Long) (rowData.get(COLUMN.SYNCVALUE.index)));
+ prep.setLong(COLUMN.SYNCVALUE.index + 1,
+ (Long) (rowData.get(COLUMN.SYNCVALUE.index)));
} catch (SQLException e) {
e.printStackTrace();
isPrepared = false;
}
}
-
return isPrepared;
}
-
+
@Override
public List<Object> extractDataFromResultSet(ResultSet rs) {
List<Object> row = new ArrayList<Object>();
e.printStackTrace();
return null;
}
-
+
return row;
}
}
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Hyunjong Park <phjwithyou.park@samsung.com>
+ * WooJin Jung <woojin2.jung@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.db;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.tizen.dynamicanalyzer.constant.CommonConstants;
+import org.tizen.dynamicanalyzer.database.DBColumn;
+import org.tizen.dynamicanalyzer.database.DBConstants;
+import org.tizen.dynamicanalyzer.database.DBInsertManager;
+import org.tizen.dynamicanalyzer.database.DBInserter;
+import org.tizen.dynamicanalyzer.database.DBTable;
+import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;
+import org.tizen.dynamicanalyzer.ui.thread.data.ThreadSyncDataMaker;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageSyncData;
+
+public class SyncDataDBTable extends DBTable {
+ public static final String TABLENAME = "SYNCDATA";
+
+ public static final String QUERY_OPTION = "order by " + COLUMN.SYNCDATAID.name;
+
+ private DBInserter dbInserter = null;
+
+ private static final String SELECT_COLUMN = COLUMN.SYNCDATAID.name + CommonConstants.COMMA
+ + COLUMN.PID.name + CommonConstants.COMMA + COLUMN.TID.name + CommonConstants.COMMA
+ + COLUMN.SYNCTYPE.name + CommonConstants.COMMA + COLUMN.SYNCVALUE.name
+ + CommonConstants.COMMA + COLUMN.ATTRIBUTETYPE.name + CommonConstants.COMMA
+ + COLUMN.SYNCDATATYPE.name + CommonConstants.COMMA + COLUMN.PARENTID.name;
+ public static final String SELECT_QUERY = "select " + SELECT_COLUMN + " from " + TABLENAME
+ + " order by " + COLUMN.SYNCDATAID.name;
+
+ public enum COLUMN {
+ SYNCDATAID(0, "SyncDataID"), PID(1, "PID"), TID(2, "TID"), SYNCTYPE(3, "SyncType"), SYNCVALUE(
+ 4, "SyncValue"), ATTRIBUTETYPE(5, "AttributeType"), SYNCDATATYPE(6, "SyncDataType"), PARENTID(
+ 7, "ParentId");
+
+ public final int index;
+ public final String name;
+
+ COLUMN(int index, String name) {
+ this.index = index;
+ this.name = name;
+ }
+ }
+
+ @Override
+ public String getTableName() {
+ return TABLENAME;
+ }
+
+ public SyncDataDBTable() {
+ addColumn(new DBColumn(COLUMN.SYNCDATAID.name, DBConstants.PRIMARY_KEY,
+ DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.PID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.TID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.SYNCTYPE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT1));
+ addColumn(new DBColumn(COLUMN.SYNCVALUE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.ATTRIBUTETYPE.name, DBConstants.NOT_NULL,
+ DBConstants.DBTYPE_INT1));
+ addColumn(new DBColumn(COLUMN.SYNCDATATYPE.name, DBConstants.NOT_NULL,
+ DBConstants.DBTYPE_INT1));
+ addColumn(new DBColumn(COLUMN.PARENTID.name, DBConstants.EMPTY, DBConstants.DBTYPE_INT4));
+ dbInserter = DBInsertManager.makeInserter(this);
+ }
+
+ public List<List<Object>> getSyncDataFromDB() {
+ return selectAllColumnData(QUERY_OPTION);
+ }
+
+ public void insertSyncData(List<ThreadPageSyncData> insertSyncDataQueue) {
+ if (insertSyncDataQueue.size() == 0) {
+ return;
+ }
+ ArrayList<List<Object>> insertData = new ArrayList<List<Object>>();
+ for (ThreadPageSyncData syncData : insertSyncDataQueue) {
+ List<Object> insertRowData = new ArrayList<Object>();
+ try {
+ insertRowData.add(new Integer(syncData.getSyncDataID()));
+ insertRowData.add(new Integer(syncData.getPid()));
+ insertRowData.add(new Integer(syncData.getTid()));
+ Integer type = new Integer(syncData.getType());
+ byte syncType = type.byteValue();
+ insertRowData.add(new Byte(syncType));
+ insertRowData.add(new Long(syncData.getKey()));
+ String attrTypeStr = syncData.getAttrType();
+ byte attrType = -1;
+ if (attrTypeStr.equals(ThreadPageLabels.SYNC_ATTR_TYPE_NORMAL)) {
+ attrType = ThreadSyncDataMaker.PTHREAD_MUTEX_NORMAL;
+ } else if (attrTypeStr.equals(ThreadPageLabels.SYNC_ATTR_TYPE_RECURSIVE)) {
+ attrType = ThreadSyncDataMaker.PTHREAD_MUTEX_RECURSIVE;
+ } else if (attrTypeStr.equals(ThreadPageLabels.SYNC_ATTR_TYPE_ERRORCHECK)) {
+ attrType = ThreadSyncDataMaker.PTHREAD_MUTEX_ERRORCHECK;
+ } else if (attrTypeStr.equals(ThreadPageLabels.SYNC_ATTR_TYPE_DEFAULT)) {
+ attrType = ThreadSyncDataMaker.PTHREAD_MUTEX_DEFAULT;
+ } else {
+ attrType = -1;
+ }
+ insertRowData.add(new Byte(attrType));
+ insertRowData.add(new Byte(syncData.getSyncDataType()));
+ insertRowData.add(new Integer(syncData.getParentID()));
+ insertData.add(insertRowData);
+ } catch (ArrayIndexOutOfBoundsException e) {
+ e.printStackTrace();
+ }
+ }
+ if (insertData.size() > 0) {
+ dbInserter.pushData(insertData);
+ }
+ }
+
+ @Override
+ public boolean prepare(PreparedStatement prep, List<Object> rowData) {
+ boolean isPrepared = true;
+ int columnsize = getColumnSize();
+ if (columnsize != rowData.size()) {
+ isPrepared = false;
+ } else {
+ try {
+ prep.setInt(COLUMN.SYNCDATAID.index + 1,
+ (Integer) (rowData.get(COLUMN.SYNCDATAID.index)));
+ prep.setInt(COLUMN.PID.index + 1, (Integer) (rowData.get(COLUMN.PID.index)));
+ prep.setInt(COLUMN.TID.index + 1, (Integer) (rowData.get(COLUMN.TID.index)));
+ prep.setByte(COLUMN.SYNCTYPE.index + 1, (Byte) (rowData.get(COLUMN.SYNCTYPE.index)));
+ prep.setLong(COLUMN.SYNCVALUE.index + 1,
+ (Long) (rowData.get(COLUMN.SYNCVALUE.index)));
+ prep.setByte(COLUMN.ATTRIBUTETYPE.index + 1,
+ (Byte) (rowData.get(COLUMN.ATTRIBUTETYPE.index)));
+ prep.setByte(COLUMN.SYNCDATATYPE.index + 1,
+ (Byte) (rowData.get(COLUMN.SYNCDATATYPE.index)));
+ prep.setInt(COLUMN.PARENTID.index + 1,
+ (Integer) (rowData.get(COLUMN.PARENTID.index)));
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ isPrepared = false;
+ }
+ }
+ return isPrepared;
+ }
+
+ @Override
+ public List<Object> extractDataFromResultSet(ResultSet rs) {
+ List<Object> row = new ArrayList<Object>();
+ try {
+ row.add(Integer.valueOf(rs.getInt(COLUMN.SYNCDATAID.index + 1)));
+ row.add(Integer.valueOf(rs.getInt(COLUMN.PID.index + 1)));
+ row.add(Integer.valueOf(rs.getInt(COLUMN.TID.index + 1)));
+ row.add(Byte.valueOf(rs.getByte(COLUMN.SYNCTYPE.index + 1)));
+ row.add(Long.valueOf(rs.getLong(COLUMN.SYNCVALUE.index + 1)));
+ row.add(Byte.valueOf(rs.getByte(COLUMN.ATTRIBUTETYPE.index + 1)));
+ row.add(Byte.valueOf(rs.getByte(COLUMN.SYNCDATATYPE.index + 1)));
+ row.add(Integer.valueOf(rs.getInt(COLUMN.PARENTID.index + 1)));
+ } catch (SQLException e) {
+ e.printStackTrace();
+ return null;
+ }
+
+ return row;
+ }
+}
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Hyunjong Park <phjwithyou.park@samsung.com>
+ * WooJin Jung <woojin2.jung@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.db;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.tizen.dynamicanalyzer.common.DALimit;
+import org.tizen.dynamicanalyzer.communicator.DACommunicator;
+import org.tizen.dynamicanalyzer.constant.CommonConstants;
+import org.tizen.dynamicanalyzer.database.DBColumn;
+import org.tizen.dynamicanalyzer.database.DBConstants;
+import org.tizen.dynamicanalyzer.database.DBInsertManager;
+import org.tizen.dynamicanalyzer.database.DBInserter;
+import org.tizen.dynamicanalyzer.database.DBTable;
+import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageSyncDataEvent;
+
+public class SyncEventDBTable extends DBTable {
+ public static final String TABLENAME = "SYNCEVENT";
+ private DBInserter dbInserter = null;
+
+ private static final String SELECT_COLUMN = COLUMN.API_SEQNUMBER.name + CommonConstants.COMMA
+ + COLUMN.SYNCDATAID.name + CommonConstants.COMMA + COLUMN.EVENTTIME.name
+ + CommonConstants.COMMA + COLUMN.APITYPE.name + CommonConstants.COMMA
+ + COLUMN.TOOLTIP.name + CommonConstants.COMMA + COLUMN.ERRORNO.name
+ + CommonConstants.COMMA + COLUMN.SYNCVALUE.name + CommonConstants.COMMA
+ + COLUMN.RELEASETIME.name;
+
+ public static final String SELECT_QUERY = "select " + SELECT_COLUMN +
+ " from " + TABLENAME
+ + " where ((" + COLUMN.APITYPE.name + " = " + LogCenterConstants.SYNC_API_TYPE_NEW
+ + " OR " + COLUMN.APITYPE.name + " = " + LogCenterConstants.SYNC_API_TYPE_NOTIFY
+ + " OR " + COLUMN.APITYPE.name + " = " + LogCenterConstants.SYNC_API_TYPE_NOTIFY_ALL
+ + " OR " + COLUMN.APITYPE.name + " = " + LogCenterConstants.SYNC_API_TYPE_OTHER
+ + " ) and " + COLUMN.EVENTTIME.name + " between %s and %s)" +
+ " OR " + " (("
+ + COLUMN.APITYPE.name + " = " + LogCenterConstants.SYNC_API_TYPE_ACQUIRE_WAIT_START + " OR "
+ + COLUMN.APITYPE.name + " = " + LogCenterConstants.SYNC_API_TYPE_ACQUIRE_WAIT_END + " OR "
+ + COLUMN.APITYPE.name + " = " + LogCenterConstants.SYNC_API_TYPE_RELEASE + " OR "
+ + COLUMN.APITYPE.name + " = " + LogCenterConstants.SYNC_API_TYPE_TRY_ACQUIRE + " OR "
+ + COLUMN.APITYPE.name + " = " + LogCenterConstants.SYNC_API_TYPE_COND_WAIT_START + " OR "
+ + COLUMN.APITYPE.name + " = " + LogCenterConstants.SYNC_API_TYPE_COND_WAIT_END + ") AND ("
+ + COLUMN.EVENTTIME.name + " >= %s AND " + COLUMN.EVENTTIME.name + " <= %s))";
+
+ public enum COLUMN {
+ API_SEQNUMBER(0, "APISEQNUMBER"), SYNCDATAID(1, "SyncDataID"), EVENTTIME(2, "EventTime"), APITYPE(
+ 3, "APIType"), TOOLTIP(4, "Tooltip"), ERRORNO(5, DBConstants.DBCOLUMN_ERROR_NUMBER), SYNCVALUE(
+ 6, "SyncValue"), RELEASETIME(7, "ReleaseTime");
+
+ public final int index;
+ public final String name;
+
+ COLUMN(int index, String name) {
+ this.index = index;
+ this.name = name;
+ }
+ }
+
+ @Override
+ public String getTableName() {
+ return TABLENAME;
+ }
+
+ public SyncEventDBTable() {
+ addColumn(new DBColumn(COLUMN.API_SEQNUMBER.name, DBConstants.NOT_NULL,
+ DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.SYNCDATAID.name, DBConstants.NOT_NULL,
+ DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.EVENTTIME.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.APITYPE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT1));
+ addColumn(new DBColumn(COLUMN.TOOLTIP.name, DBConstants.EMPTY, DBConstants.VARCHAR,
+ DALimit.TOOLTIP_LENGTH));
+ addColumn(new DBColumn(COLUMN.ERRORNO.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.SYNCVALUE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.RELEASETIME.name, DBConstants.NOT_NULL,
+ DBConstants.DBTYPE_LONG));
+ setIndexColumn(COLUMN.SYNCDATAID.index);
+
+ dbInserter = DBInsertManager.makeInserter(this);
+ }
+
+ public List<List<Object>> getSyncEventFromDB() {
+ return selectAllColumnData(null);
+ }
+
+ public List<List<Object>> getInsertDBData(ThreadPageSyncDataEvent syncEvent) {
+ List<List<Object>> insertData = new ArrayList<List<Object>>();
+ List<Object> insertRowData = new ArrayList<Object>();
+ try {
+ insertRowData.add(new Long(syncEvent.getContents().getSeq()));
+ insertRowData.add(new Integer(syncEvent.getSyncDataID()));
+ insertRowData.add(new Long(syncEvent.getTime()));
+ Integer apiType = new Integer(syncEvent.getApiType());
+ insertRowData.add(new Byte(apiType.byteValue()));
+ insertRowData.add(new String(syncEvent.getTooltipContent()));
+ insertRowData.add(new Long(syncEvent.getErrorNum()));
+ insertRowData.add(new Long(syncEvent.getSyncVal()));
+ insertRowData.add(new Long(syncEvent.getBlockEndTime()));
+ } catch (ArrayIndexOutOfBoundsException e) {
+ e.printStackTrace();
+ }
+ return insertData;
+ }
+
+ public void insertSyncEventData(List<ThreadPageSyncDataEvent> syncEventQueue) {
+ if (syncEventQueue.size() == 0) {
+ return;
+ }
+ List<List<Object>> insertData = new ArrayList<List<Object>>();
+ for (ThreadPageSyncDataEvent syncEvent : syncEventQueue) {
+ List<Object> insertRowData = new ArrayList<Object>();
+ try {
+ insertRowData.add(new Long(syncEvent.getContents().getSeq()));
+ insertRowData.add(new Integer(syncEvent.getSyncDataID()));
+ insertRowData.add(new Long(syncEvent.getTime()));
+ Integer apiType = new Integer(syncEvent.getApiType());
+ insertRowData.add(new Byte(apiType.byteValue()));
+ insertRowData.add(new String(syncEvent.getTooltipContent()));
+ insertRowData.add(new Long(syncEvent.getErrorNum()));
+ insertRowData.add(new Long(syncEvent.getSyncVal()));
+ insertRowData.add(new Long(syncEvent.getBlockEndTime()));
+ } catch (ArrayIndexOutOfBoundsException e) {
+ e.printStackTrace();
+ }
+ insertData.add(insertRowData);
+ }
+ if (DACommunicator.isRunning()) {
+ dbInserter.pushData(insertData);
+ } else {
+ insertData(insertData);
+ }
+ }
+
+ @Override
+ public boolean prepare(PreparedStatement prep, List<Object> rowData) {
+ boolean isPrepared = true;
+
+ int columnsize = getColumnSize();
+ if (columnsize != rowData.size()) {
+ isPrepared = false;
+ } else {
+ try {
+ prep.setLong(COLUMN.API_SEQNUMBER.index + 1,
+ (Long) (rowData.get(COLUMN.API_SEQNUMBER.index)));
+ prep.setInt(COLUMN.SYNCDATAID.index + 1,
+ (Integer) (rowData.get(COLUMN.SYNCDATAID.index)));
+ prep.setLong(COLUMN.EVENTTIME.index + 1,
+ (Long) (rowData.get(COLUMN.EVENTTIME.index)));
+ prep.setByte(COLUMN.APITYPE.index + 1, (Byte) (rowData.get(COLUMN.APITYPE.index)));
+ String tooltipStr = clipString((String) (rowData.get(COLUMN.TOOLTIP.index)),
+ DALimit.TOOLTIP_LENGTH, rowData.get(COLUMN.EVENTTIME.index).toString());
+ prep.setString(COLUMN.TOOLTIP.index + 1, tooltipStr);
+ prep.setLong(COLUMN.ERRORNO.index + 1, (Long) (rowData.get(COLUMN.ERRORNO.index)));
+ prep.setLong(COLUMN.SYNCVALUE.index + 1,
+ (Long) (rowData.get(COLUMN.SYNCVALUE.index)));
+ prep.setLong(COLUMN.RELEASETIME.index + 1,
+ (Long) (rowData.get(COLUMN.RELEASETIME.index)));
+ } catch (SQLException e) {
+ e.printStackTrace();
+ isPrepared = false;
+ }
+ }
+
+ return isPrepared;
+ }
+
+ @Override
+ public List<Object> extractDataFromResultSet(ResultSet rs) {
+ List<Object> row = new ArrayList<Object>();
+ try {
+ row.add(Long.valueOf(rs.getLong(COLUMN.API_SEQNUMBER.index + 1)));
+ row.add(Integer.valueOf(rs.getInt(COLUMN.SYNCDATAID.index + 1)));
+ row.add(Long.valueOf(rs.getLong(COLUMN.EVENTTIME.index + 1)));
+ row.add(Byte.valueOf(rs.getByte(COLUMN.APITYPE.index + 1)));
+ row.add(rs.getString(COLUMN.TOOLTIP.index + 1));
+ row.add(Long.valueOf(rs.getLong(COLUMN.ERRORNO.index + 1)));
+ row.add(Long.valueOf(rs.getLong(COLUMN.SYNCVALUE.index + 1)));
+ row.add(Long.valueOf(rs.getLong(COLUMN.RELEASETIME.index + 1)));
+ } catch (SQLException e) {
+ e.printStackTrace();
+ return null;
+ }
+
+ return row;
+ }
+}
* Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
*
* Contact:
+ * Hyunjong Park <phjwithyou.park@samsung.com>
* WooJin Jung <woojin2.jung@samsung.com>
* Juyoung Kim <j0.kim@samsung.com>
*
*
*/
-package org.tizen.dynamicanalyzer.ui.thread.data;
+package org.tizen.dynamicanalyzer.ui.thread.db;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.List;
import org.tizen.dynamicanalyzer.common.DALimit;
+import org.tizen.dynamicanalyzer.communicator.DACommunicator;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.database.DBColumn;
import org.tizen.dynamicanalyzer.database.DBConstants;
+import org.tizen.dynamicanalyzer.database.DBInsertManager;
+import org.tizen.dynamicanalyzer.database.DBInserter;
import org.tizen.dynamicanalyzer.database.DBTable;
-import org.tizen.dynamicanalyzer.database.IResultSet;
+import org.tizen.dynamicanalyzer.swap.model.data.ThreadData;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageThreadDataEvent;
+
+public class ThreadAPIDBTable extends DBTable {
+ public static final String TABLENAME = "THREADAPI";
+ private DBInserter dbInserter = null;
+ private static final String SELECT_COLUMN = COLUMN.SEQ.name + CommonConstants.COMMA
+ + COLUMN.APICALLTIME.name + CommonConstants.COMMA + COLUMN.APIID.name
+ + CommonConstants.COMMA + COLUMN.PID.name + CommonConstants.COMMA + COLUMN.TID.name
+ + CommonConstants.COMMA + COLUMN.ARGUMENT.name + CommonConstants.COMMA
+ + COLUMN.RETURN.name + CommonConstants.COMMA + COLUMN.ERRORNO.name;
+ public static final String SELECT_QUERY = "select " + SELECT_COLUMN + " from " + TABLENAME
+ + " where " + COLUMN.THREADDATAID.name + " = %s";
-public class ThreadAPIDBTable extends DBTable implements IResultSet {
- public static final String TABLENAME="ThreadAPI";
-
- private static final String SELECT_COLUMN =
- COLUMN.SEQ.name + CommonConstants.COMMA +
- COLUMN.APICALLTIME.name + CommonConstants.COMMA +
- COLUMN.APIID.name + CommonConstants.COMMA +
- COLUMN.PID.name + CommonConstants.COMMA +
- COLUMN.TID.name + CommonConstants.COMMA +
- COLUMN.ARGUMENT.name + CommonConstants.COMMA +
- COLUMN.RETURN.name + CommonConstants.COMMA +
- COLUMN.ERRORNO.name;
- public static final String SELECT_QUERY =
- "select " + SELECT_COLUMN + " from " + TABLENAME +
- " where " + COLUMN.THREADDATAID.name + " = %s";
-
public enum COLUMN {
- SEQ(0, "SEQNUMBER"),
- THREADDATAID(1, "ThreadDataID"),
- APICALLTIME(2, "APICallTime"),
- APIID(3, "APIID"),
- PID(4, "PID"),
- TID(5, "TID"),
- ARGUMENT(6, DBConstants.DBCOLUMN_ARGUMENT),
- RETURN(7, DBConstants.DBCOLUMN_RETURN_VALUE),
- ERRORNO(8, DBConstants.DBCOLUMN_ERROR_NUMBER);
-
+ SEQ(0, "SEQNUMBER"), THREADDATAID(1, "ThreadDataID"), APICALLTIME(2, "APICallTime"), APIID(
+ 3, "APIID"), PID(4, "PID"), TID(5, "TID"), ARGUMENT(6,
+ DBConstants.DBCOLUMN_ARGUMENT), RETURN(7, DBConstants.DBCOLUMN_RETURN_VALUE), ERRORNO(
+ 8, DBConstants.DBCOLUMN_ERROR_NUMBER);
+
public final int index;
public final String name;
-
+
COLUMN(int index, String name) {
this.index = index;
this.name = name;
}
}
-
+
@Override
public String getTableName() {
return TABLENAME;
}
-
+
public ThreadAPIDBTable() {
addColumn(new DBColumn(COLUMN.SEQ.name, DBConstants.PRIMARY_KEY, DBConstants.DBTYPE_LONG));
- addColumn(new DBColumn(COLUMN.THREADDATAID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
- addColumn(new DBColumn(COLUMN.APICALLTIME.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
- addColumn(new DBColumn(COLUMN.APIID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.THREADDATAID.name, DBConstants.NOT_NULL,
+ DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.APICALLTIME.name, DBConstants.NOT_NULL,
+ DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.APIID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
addColumn(new DBColumn(COLUMN.PID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
addColumn(new DBColumn(COLUMN.TID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
- addColumn(new DBColumn(COLUMN.ARGUMENT.name, DBConstants.EMPTY,
- DBConstants.DBTYPE_VARCHAR, DALimit.FUNCTION_ARGUMENTS_VALUE_LENGTH));
- addColumn(new DBColumn(COLUMN.RETURN.name, DBConstants.EMPTY,
- DBConstants.DBTYPE_VARCHAR, DALimit.FUNCTION_RETURN_VALUE_LENGTH));
+ addColumn(new DBColumn(COLUMN.ARGUMENT.name, DBConstants.EMPTY, DBConstants.DBTYPE_VARCHAR,
+ DALimit.FUNCTION_ARGUMENTS_VALUE_LENGTH));
+ addColumn(new DBColumn(COLUMN.RETURN.name, DBConstants.EMPTY, DBConstants.DBTYPE_VARCHAR,
+ DALimit.FUNCTION_RETURN_VALUE_LENGTH));
addColumn(new DBColumn(COLUMN.ERRORNO.name, DBConstants.EMPTY, DBConstants.DBTYPE_LONG));
setIndexColumn(COLUMN.THREADDATAID.index);
+ dbInserter = DBInsertManager.makeInserter(this);
}
public List<List<Object>> getThreadAPIFromDB() {
return selectAllColumnData(null);
}
-
+
+ public void insertThreadAPIData(List<ThreadPageThreadDataEvent> insertThreadEventList) {
+ ArrayList<List<Object>> apiData = new ArrayList<List<Object>>();
+ for (ThreadPageThreadDataEvent threadEvent : insertThreadEventList) {
+ if (threadEvent.getEventType() != ThreadPageThreadDataEvent.TYPE_API) {
+ continue;
+ }
+ List<Object> apiRowData = new ArrayList<Object>();
+ ThreadData tData = (ThreadData) threadEvent.getContents();
+ try {
+ apiRowData.add(new Long(tData.getSeq()));
+ apiRowData.add(new Integer(threadEvent.getThreadDataID()));
+ apiRowData.add(new Long(tData.getTime()));
+ apiRowData.add(new Integer(tData.getApiId()));
+ apiRowData.add(new Integer(tData.getPid()));
+ apiRowData.add(new Integer(tData.getTid()));
+ apiRowData.add(new String(tData.getArgs()));
+ apiRowData.add(new String(tData.getReturn()));
+ apiRowData.add(new Long(tData.getErrno()));
+ } catch (ArrayIndexOutOfBoundsException e) {
+ e.printStackTrace();
+ }
+ apiData.add(apiRowData);
+ }
+ if (apiData.size() == 0) {
+ return;
+ }
+ if (DACommunicator.isRunning()) {
+ dbInserter.pushData(apiData);
+ } else {
+ insertData(apiData);
+ }
+ }
+
@Override
public boolean prepare(PreparedStatement prep, List<Object> rowData) {
boolean isPrepared = true;
-
int columnsize = getColumnSize();
if (columnsize != rowData.size()) {
isPrepared = false;
} else {
try {
prep.setLong(COLUMN.SEQ.index + 1, (Long) (rowData.get(COLUMN.SEQ.index)));
- prep.setInt(COLUMN.THREADDATAID.index + 1, (Integer) (rowData.get(COLUMN.THREADDATAID.index)));
- prep.setLong(COLUMN.APICALLTIME.index + 1, (Long) (rowData.get(COLUMN.APICALLTIME.index)));
+ prep.setInt(COLUMN.THREADDATAID.index + 1,
+ (Integer) (rowData.get(COLUMN.THREADDATAID.index)));
+ prep.setLong(COLUMN.APICALLTIME.index + 1,
+ (Long) (rowData.get(COLUMN.APICALLTIME.index)));
prep.setInt(COLUMN.APIID.index + 1, (Integer) (rowData.get(COLUMN.APIID.index)));
prep.setInt(COLUMN.PID.index + 1, (Integer) (rowData.get(COLUMN.PID.index)));
prep.setInt(COLUMN.TID.index + 1, (Integer) (rowData.get(COLUMN.TID.index)));
String argumentStr = clipString((String) (rowData.get(COLUMN.ARGUMENT.index)),
- DALimit.FUNCTION_ARGUMENTS_VALUE_LENGTH, rowData.get(COLUMN.SEQ.index).toString());
+ DALimit.FUNCTION_ARGUMENTS_VALUE_LENGTH, rowData.get(COLUMN.SEQ.index)
+ .toString());
prep.setString(COLUMN.ARGUMENT.index + 1, argumentStr);
String retStr = clipString((String) (rowData.get(COLUMN.RETURN.index)),
- DALimit.FUNCTION_RETURN_VALUE_LENGTH, rowData.get(COLUMN.SEQ.index).toString());
+ DALimit.FUNCTION_RETURN_VALUE_LENGTH, rowData.get(COLUMN.SEQ.index)
+ .toString());
prep.setString(COLUMN.RETURN.index + 1, retStr);
prep.setLong(COLUMN.ERRORNO.index + 1, (Long) (rowData.get(COLUMN.ERRORNO.index)));
-
+
} catch (SQLException e) {
e.printStackTrace();
isPrepared = false;
}
}
-
return isPrepared;
}
-
+
@Override
public List<Object> extractDataFromResultSet(ResultSet rs) {
List<Object> row = new ArrayList<Object>();
e.printStackTrace();
return null;
}
-
+
return row;
}
}
* Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
*
* Contact:
+ * Hyunjong Park <phjwithyou.park@samsung.com>
* WooJin Jung <woojin2.jung@samsung.com>
* Juyoung Kim <j0.kim@samsung.com>
*
*
*/
-package org.tizen.dynamicanalyzer.ui.thread.data;
+package org.tizen.dynamicanalyzer.ui.thread.db;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import org.tizen.dynamicanalyzer.database.DBColumn;
import org.tizen.dynamicanalyzer.database.DBConstants;
import org.tizen.dynamicanalyzer.database.DBTable;
-import org.tizen.dynamicanalyzer.database.IResultSet;
+import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;
+import org.tizen.dynamicanalyzer.ui.thread.data.ThreadThreadDataMaker;
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageThreadData;
+
+public class ThreadDataDBTable extends DBTable {
+ public static final String TABLENAME = "THREADDATA";
-public class ThreadDataDBTable extends DBTable implements IResultSet {
- public static final String TABLENAME="ThreadData";
-
public enum COLUMN {
- THREADDATAID(0, "ThreadDataID"),
- PID(1, "PID"),
- TID(2, "TID"),
- THREADTYPE(3, "ThreadType"),
- ATTRIBUTETYPE(4, "AttributeType"),
- STARTTIME(5, "StartTime"),
- ENDTIME(6, "EndTime"),
- FUNCTIONID(7, "FunctionId"),
- CLASSNAME(8, "ClassName");
-
+ THREADDATAID(0, "ThreadDataID"), PID(1, "PID"), TID(2, "TID"), THREADTYPE(3, "ThreadType"), ATTRIBUTETYPE(
+ 4, "AttributeType"), STARTTIME(5, "StartTime"), ENDTIME(6, "EndTime"), FUNCTIONID(
+ 7, "FunctionId"), CLASSNAME(8, "ClassName");
+
public final int index;
public final String name;
-
+
COLUMN(int index, String name) {
this.index = index;
this.name = name;
}
}
-
+
@Override
public String getTableName() {
return TABLENAME;
}
-
+
public ThreadDataDBTable() {
- addColumn(new DBColumn(COLUMN.THREADDATAID.name, DBConstants.PRIMARY_KEY, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.THREADDATAID.name, DBConstants.PRIMARY_KEY,
+ DBConstants.DBTYPE_INT4));
addColumn(new DBColumn(COLUMN.PID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
addColumn(new DBColumn(COLUMN.TID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
- addColumn(new DBColumn(COLUMN.THREADTYPE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT1));
- addColumn(new DBColumn(COLUMN.ATTRIBUTETYPE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT1));
- addColumn(new DBColumn(COLUMN.STARTTIME.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
+ addColumn(new DBColumn(COLUMN.THREADTYPE.name, DBConstants.NOT_NULL,
+ DBConstants.DBTYPE_INT1));
+ addColumn(new DBColumn(COLUMN.ATTRIBUTETYPE.name, DBConstants.NOT_NULL,
+ DBConstants.DBTYPE_INT1));
+ addColumn(new DBColumn(COLUMN.STARTTIME.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
addColumn(new DBColumn(COLUMN.ENDTIME.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
addColumn(new DBColumn(COLUMN.FUNCTIONID.name, DBConstants.EMPTY, DBConstants.DBTYPE_INT4));
- addColumn(new DBColumn(COLUMN.CLASSNAME.name, DBConstants.EMPTY,
- DBConstants.VARCHAR, DALimit.CLASS_NAME_LENGTH));
+ addColumn(new DBColumn(COLUMN.CLASSNAME.name, DBConstants.EMPTY, DBConstants.VARCHAR,
+ DALimit.CLASS_NAME_LENGTH));
}
public List<List<Object>> getThreadDataFromDB() {
return selectAllColumnData(null);
}
-
+
+ public void inserthreadPageThreadData(List<ThreadPageThreadData> remainedThreadData) {
+ List<List<Object>> insertData = new ArrayList<List<Object>>();
+ for (ThreadPageThreadData threadPageData : remainedThreadData) {
+ if (threadPageData instanceof ThreadPageThreadData == false) {
+ continue;
+ }
+ List<Object> insertRowData = new ArrayList<Object>();
+ ThreadPageThreadData threadData = (ThreadPageThreadData) threadPageData;
+ try {
+ insertRowData.add(new Integer(threadData.getThreadDataID()));
+ insertRowData.add(new Integer(threadData.getPid()));
+ insertRowData.add(new Integer(threadData.getTid()));
+ Integer type = new Integer(threadData.getType());
+ byte threadType = type.byteValue();
+ insertRowData.add(new Byte(threadType));
+ String attrTypeStr = threadData.getAttrType();
+ byte attrType = -1;
+ if (attrTypeStr.equals(ThreadPageLabels.THREAD_ATTR_TYPE_JOINABLE)) {
+ attrType = ThreadThreadDataMaker.PTHREAD_CREATE_JOINABLE;
+ } else if (attrTypeStr.equals(ThreadPageLabels.THREAD_ATTR_TYPE_DETACHED)) {
+ attrType = ThreadThreadDataMaker.PTHREAD_CREATE_DETACHED;
+ } else { // main thread has no attribute
+ attrType = -1;
+ }
+ insertRowData.add(new Byte(attrType));
+ insertRowData.add(new Long(threadData.getStartTime()));
+ insertRowData.add(new Long(threadData.getEndTime()));
+ insertRowData.add(new Integer(threadData.getThreadFuncID()));
+ insertRowData.add(new String(threadData.getThreadClassName()));
+ } catch (ArrayIndexOutOfBoundsException e) {
+ e.printStackTrace();
+ }
+ insertData.add(insertRowData);
+ }
+ if (insertData.size() > 0) {
+ insertData(insertData);
+ }
+ }
+
@Override
public boolean prepare(PreparedStatement prep, List<Object> rowData) {
boolean isPrepared = true;
-
+
int columnsize = getColumnSize();
if (columnsize != rowData.size()) {
isPrepared = false;
} else {
try {
- prep.setInt(COLUMN.THREADDATAID.index + 1, (Integer) (rowData.get(COLUMN.THREADDATAID.index)));
+ prep.setInt(COLUMN.THREADDATAID.index + 1,
+ (Integer) (rowData.get(COLUMN.THREADDATAID.index)));
prep.setInt(COLUMN.PID.index + 1, (Integer) (rowData.get(COLUMN.PID.index)));
- prep.setInt(COLUMN.TID.index + 1, (Integer) (rowData.get(COLUMN.TID.index)));
- prep.setByte(COLUMN.THREADTYPE.index + 1, (Byte) (rowData.get(COLUMN.THREADTYPE.index)));
- prep.setByte(COLUMN.ATTRIBUTETYPE.index + 1, (Byte) (rowData.get(COLUMN.ATTRIBUTETYPE.index)));
- prep.setLong(COLUMN.STARTTIME.index + 1, (Long) (rowData.get(COLUMN.STARTTIME.index)));
+ prep.setInt(COLUMN.TID.index + 1, (Integer) (rowData.get(COLUMN.TID.index)));
+ prep.setByte(COLUMN.THREADTYPE.index + 1,
+ (Byte) (rowData.get(COLUMN.THREADTYPE.index)));
+ prep.setByte(COLUMN.ATTRIBUTETYPE.index + 1,
+ (Byte) (rowData.get(COLUMN.ATTRIBUTETYPE.index)));
+ prep.setLong(COLUMN.STARTTIME.index + 1,
+ (Long) (rowData.get(COLUMN.STARTTIME.index)));
prep.setLong(COLUMN.ENDTIME.index + 1, (Long) (rowData.get(COLUMN.ENDTIME.index)));
- prep.setInt(COLUMN.FUNCTIONID.index + 1, (Integer) (rowData.get(COLUMN.FUNCTIONID.index)));
+ prep.setInt(COLUMN.FUNCTIONID.index + 1,
+ (Integer) (rowData.get(COLUMN.FUNCTIONID.index)));
String classNameStr = clipString((String) (rowData.get(COLUMN.CLASSNAME.index)),
- DALimit.CLASS_NAME_LENGTH, rowData.get(COLUMN.THREADDATAID.index).toString());
- prep.setString(COLUMN.CLASSNAME.index + 1, classNameStr);
-
+ DALimit.CLASS_NAME_LENGTH, rowData.get(COLUMN.THREADDATAID.index)
+ .toString());
+ prep.setString(COLUMN.CLASSNAME.index + 1, classNameStr);
+
} catch (SQLException e) {
e.printStackTrace();
isPrepared = false;
}
}
-
+
return isPrepared;
}
-
+
@Override
public List<Object> extractDataFromResultSet(ResultSet rs) {
List<Object> row = new ArrayList<Object>();
row.add(Integer.valueOf(rs.getInt(COLUMN.PID.index + 1)));
row.add(Integer.valueOf(rs.getInt(COLUMN.TID.index + 1)));
row.add(Byte.valueOf(rs.getByte(COLUMN.THREADTYPE.index + 1)));
- row.add(Byte.valueOf(rs.getByte(COLUMN.ATTRIBUTETYPE.index + 1)));
+ row.add(Byte.valueOf(rs.getByte(COLUMN.ATTRIBUTETYPE.index + 1)));
row.add(Long.valueOf(rs.getLong(COLUMN.STARTTIME.index + 1)));
row.add(Long.valueOf(rs.getLong(COLUMN.ENDTIME.index + 1)));
row.add(Integer.valueOf(rs.getInt(COLUMN.FUNCTIONID.index + 1)));
e.printStackTrace();
return null;
}
-
+
return row;
}
}
* Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
*
* Contact:
+ * Hyunjong Park <phjwithyou.park@samsung.com>
* WooJin Jung <woojin2.jung@samsung.com>
* Juyoung Kim <j0.kim@samsung.com>
*
*
*/
-package org.tizen.dynamicanalyzer.ui.thread.data;
+package org.tizen.dynamicanalyzer.ui.thread.db;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.List;
import org.tizen.dynamicanalyzer.common.DALimit;
+import org.tizen.dynamicanalyzer.communicator.DACommunicator;
import org.tizen.dynamicanalyzer.constant.CommonConstants;
import org.tizen.dynamicanalyzer.database.DBColumn;
import org.tizen.dynamicanalyzer.database.DBConstants;
+import org.tizen.dynamicanalyzer.database.DBInsertManager;
+import org.tizen.dynamicanalyzer.database.DBInserter;
import org.tizen.dynamicanalyzer.database.DBTable;
-import org.tizen.dynamicanalyzer.database.IResultSet;
-
-public class ThreadEventDBTable extends DBTable implements IResultSet {
- public static final String TABLENAME="ThreadEvent";
-
- private static final String SELECT_COLUMN =
- COLUMN.EVENTTIME.name + CommonConstants.COMMA +
- COLUMN.TID.name + CommonConstants.COMMA +
- COLUMN.APITYPE.name + CommonConstants.COMMA +
- COLUMN.TOOLTIP.name + CommonConstants.COMMA +
- COLUMN.ERRORNO.name + CommonConstants.COMMA +
- COLUMN.EVENTTYPE.name + CommonConstants.COMMA +
- COLUMN.THREADTYPE.name + CommonConstants.COMMA +
- COLUMN.CALLERID.name;
- public static final String SELECT_QUERY =
- "select " + SELECT_COLUMN + " from " + TABLENAME +
- " where " + COLUMN.THREADDATAID.name + " = %s ";
-
+import org.tizen.dynamicanalyzer.ui.thread.type.ThreadPageThreadDataEvent;
+
+public class ThreadEventDBTable extends DBTable {
+ public static final String TABLENAME = "THREADEVENT";
+ private DBInserter dbInserter = null;
+
+ private static final String SELECT_COLUMN = COLUMN.THREADDATAID.name + CommonConstants.COMMA
+ + COLUMN.EVENTTIME.name + CommonConstants.COMMA + COLUMN.TID.name
+ + CommonConstants.COMMA + COLUMN.APITYPE.name + CommonConstants.COMMA
+ + COLUMN.TOOLTIP.name + CommonConstants.COMMA + COLUMN.ERRORNO.name
+ + CommonConstants.COMMA + COLUMN.EVENTTYPE.name + CommonConstants.COMMA
+ + COLUMN.THREADTYPE.name + CommonConstants.COMMA + COLUMN.CALLERID.name;
+
+ public static final String SELECT_QUERY = "select " + SELECT_COLUMN + " from " + TABLENAME
+ + " where " + COLUMN.EVENTTIME.name + " BETWEEN %s and %s";
+
public enum COLUMN {
- THREADDATAID(0, "ThreadDataID"),
- EVENTTIME(1, "EventTime"),
- TID(2, "TID"),
- APITYPE(3, "APIType"),
- TOOLTIP(4, "Tooltip"),
- ERRORNO(5, DBConstants.DBCOLUMN_ERROR_NUMBER),
- EVENTTYPE(6, "EventType"),
- THREADTYPE(7, "ThreadType"),
- CALLERID(8, "CallerID");
-
+ THREADDATAID(0, "ThreadDataID"), EVENTTIME(1, "EventTime"), TID(2, "TID"), APITYPE(3,
+ "APIType"), TOOLTIP(4, "Tooltip"), ERRORNO(5, DBConstants.DBCOLUMN_ERROR_NUMBER), EVENTTYPE(
+ 6, "EventType"), THREADTYPE(7, "ThreadType"), CALLERID(8, "CallerID");
+
public final int index;
public final String name;
-
+
COLUMN(int index, String name) {
this.index = index;
this.name = name;
}
}
-
+
@Override
public String getTableName() {
return TABLENAME;
}
-
+
public ThreadEventDBTable() {
- addColumn(new DBColumn(COLUMN.THREADDATAID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.THREADDATAID.name, DBConstants.NOT_NULL,
+ DBConstants.DBTYPE_INT4));
addColumn(new DBColumn(COLUMN.EVENTTIME.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
addColumn(new DBColumn(COLUMN.TID.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
addColumn(new DBColumn(COLUMN.APITYPE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT1));
- addColumn(new DBColumn(COLUMN.TOOLTIP.name, DBConstants.EMPTY,
- DBConstants.VARCHAR, DALimit.TOOLTIP_LENGTH));
+ addColumn(new DBColumn(COLUMN.TOOLTIP.name, DBConstants.EMPTY, DBConstants.VARCHAR,
+ DALimit.TOOLTIP_LENGTH));
addColumn(new DBColumn(COLUMN.ERRORNO.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_LONG));
addColumn(new DBColumn(COLUMN.EVENTTYPE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT1));
- addColumn(new DBColumn(COLUMN.THREADTYPE.name, DBConstants.NOT_NULL, DBConstants.DBTYPE_INT4));
- addColumn(new DBColumn(COLUMN.CALLERID.name, DBConstants.EMPTY, DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.THREADTYPE.name, DBConstants.NOT_NULL,
+ DBConstants.DBTYPE_INT4));
+ addColumn(new DBColumn(COLUMN.CALLERID.name, DBConstants.EMPTY, DBConstants.DBTYPE_INT4));
setIndexColumn(COLUMN.THREADDATAID.index);
+ dbInserter = DBInsertManager.makeInserter(this);
}
public List<List<Object>> getThreadEventFromDB() {
return selectAllColumnData(null);
}
-
+
+ public void insertThreadEventData(List<ThreadPageThreadDataEvent> insertThreadEventList) {
+ ArrayList<List<Object>> insertData = new ArrayList<List<Object>>();
+ for (ThreadPageThreadDataEvent threadEvent : insertThreadEventList) {
+ List<Object> insertRowData = new ArrayList<Object>();
+ try {
+ insertRowData.add(new Integer(threadEvent.getThreadDataID()));
+ insertRowData.add(new Long(threadEvent.getTime()));
+ insertRowData.add(new Integer(threadEvent.getTid()));
+ Integer apiType = new Integer(threadEvent.getApiType());
+ insertRowData.add(new Byte(apiType.byteValue()));
+ insertRowData.add(new String(threadEvent.getTooltipContent()));
+ insertRowData.add(new Long(threadEvent.getErrorNum()));
+ Integer eventType = new Integer(threadEvent.getEventType());
+ insertRowData.add(new Byte(eventType.byteValue()));
+ insertRowData.add(new Integer(threadEvent.getThreadType()));
+ insertRowData.add(new Integer(threadEvent.getCallerTid()));
+ } catch (ArrayIndexOutOfBoundsException e) {
+ e.printStackTrace();
+ }
+ insertData.add(insertRowData);
+ }
+ if (insertData.size() == 0) {
+ return;
+ }
+ if (DACommunicator.isRunning()) {
+ dbInserter.pushData(insertData);
+ } else {
+ insertData(insertData);
+ }
+ }
+
@Override
public boolean prepare(PreparedStatement prep, List<Object> rowData) {
boolean isPrepared = true;
-
int columnsize = getColumnSize();
if (columnsize != rowData.size()) {
isPrepared = false;
} else {
try {
- prep.setInt(COLUMN.THREADDATAID.index + 1, (Integer) (rowData.get(COLUMN.THREADDATAID.index)));
- prep.setLong(COLUMN.EVENTTIME.index + 1, (Long) (rowData.get(COLUMN.EVENTTIME.index)));
+ prep.setInt(COLUMN.THREADDATAID.index + 1,
+ (Integer) (rowData.get(COLUMN.THREADDATAID.index)));
+ prep.setLong(COLUMN.EVENTTIME.index + 1,
+ (Long) (rowData.get(COLUMN.EVENTTIME.index)));
prep.setInt(COLUMN.TID.index + 1, (Integer) (rowData.get(COLUMN.TID.index)));
prep.setByte(COLUMN.APITYPE.index + 1, (Byte) (rowData.get(COLUMN.APITYPE.index)));
String tooltipStr = clipString((String) (rowData.get(COLUMN.TOOLTIP.index)),
DALimit.TOOLTIP_LENGTH, rowData.get(COLUMN.EVENTTIME.index).toString());
- prep.setString(COLUMN.TOOLTIP.index + 1, tooltipStr);
+ prep.setString(COLUMN.TOOLTIP.index + 1, tooltipStr);
prep.setLong(COLUMN.ERRORNO.index + 1, (Long) (rowData.get(COLUMN.ERRORNO.index)));
- prep.setByte(COLUMN.EVENTTYPE.index + 1, (Byte) (rowData.get(COLUMN.EVENTTYPE.index)));
- prep.setInt(COLUMN.THREADTYPE.index + 1, (Integer) (rowData.get(COLUMN.THREADTYPE.index)));
- prep.setInt(COLUMN.CALLERID.index + 1, (Integer) (rowData.get(COLUMN.CALLERID.index)));
+ prep.setByte(COLUMN.EVENTTYPE.index + 1,
+ (Byte) (rowData.get(COLUMN.EVENTTYPE.index)));
+ prep.setInt(COLUMN.THREADTYPE.index + 1,
+ (Integer) (rowData.get(COLUMN.THREADTYPE.index)));
+ prep.setInt(COLUMN.CALLERID.index + 1,
+ (Integer) (rowData.get(COLUMN.CALLERID.index)));
} catch (SQLException e) {
e.printStackTrace();
isPrepared = false;
}
}
-
return isPrepared;
}
-
+
public List<Object> extractDataFromResultSet(ResultSet rs) {
List<Object> row = new ArrayList<Object>();
try {
e.printStackTrace();
return null;
}
-
+
return row;
}
}
+++ /dev/null
-/*
- * Dynamic Analyzer
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * WooJin Jung <woojin2.jung@samsung.com>
- * yeongtaik byeon <yeongtaik.byeon@samsung.com>
- * Juyoung Kim <j0.kim@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-package org.tizen.dynamicanalyzer.ui.thread.sync;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.tizen.dynamicanalyzer.constant.CommonConstants;
-import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
-import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;
-import org.tizen.dynamicanalyzer.resources.ColorResources;
-import org.tizen.dynamicanalyzer.ui.thread.ThreadPageData;
-import org.tizen.dynamicanalyzer.ui.thread.ThreadPageDataEvent;
-import org.tizen.dynamicanalyzer.util.Logger;
-import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeries;
-import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeriesItem;
-import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoardItem;
-
-public class ThreadPageSyncData extends ThreadPageData {
- private List<ThreadPageSyncData> children = new ArrayList<ThreadPageSyncData>();
- private DAChartSeries apiSeries;
- private DAChartSeries stateSeries;
-
- public static final byte SYNC_PARENT = 0;
- public static final byte SYNC_CHILD = 1;
- public static final byte THREAD_CHILD = 2;
-
- private static int internalSeq = 0;
- private int syncDataID = -1;
- private byte syncDataType = -1;
- private int parentID = -1;
-
- public ThreadPageSyncData(int type, String name, String pid, String tid,
- String attrType, byte syncDataType) {
- super(type, name, pid, tid, attrType);
- this.syncDataType = syncDataType;
- syncDataID = internalSeq++;
- }
-
- // using open trace
- public ThreadPageSyncData(int id, int pid, int tid, int type, long syncValue,
- String attrType, byte syncDataType, int parentID) {
- super(type, String.valueOf(syncValue), String.valueOf(pid), String.valueOf(tid), attrType);
- this.syncDataID = id;
- this.syncDataType = syncDataType;
- this.parentID = parentID;
- }
-
- protected void pushSync(ThreadPageSyncData sync) {
- children.add(sync);
- hasUpdate = true;
- }
-
- protected ThreadPageSyncData findChildData(String tId) {
- int size = children.size();
- ThreadPageSyncData ret;
- for (int i = 0; i < size; i++) {
- ret = children.get(i);
- if (ret.getTid().equals(tId)) {
- return ret;
- }
- }
- return null;
- }
-
- public List<ThreadPageSyncData> getChildren() {
- return children;
- }
-
- public void setItem(DAChartBoardItem item) {
- this.item = item;
- setChart(item.getChart());
- stateSeries = chart
- .getSeries(ThreadPageLabels.THREAD_SYNC_CHART_SERIES_STATE);
- apiSeries = chart.getSeries(ThreadPageLabels.THREAD_CHART_SERIES_API);
- }
-
- public static boolean isSyncApi(int apiType) {
- if (apiType == LogCenterConstants.SYNC_API_TYPE_ACQUIRE_WAIT_START) {
- return false;
- }
- if (apiType == LogCenterConstants.SYNC_API_TYPE_COND_WAIT_START) {
- return false;
- }
- return true;
- }
-
- public 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();
- }
-
- size = children.size();
- if (size > 0) {
- ThreadPageSyncData sync;
- for (int i = 0; i < size; i++) {
- sync = children.get(i);
- sync.checkUpdate();
- }
- }
- }
-
- protected int createChartItem(ThreadPageDataEvent event) {
- DAChartSeriesItem stateItem = null;
- DAChartSeriesItem apiItem = null;
- if (!(event instanceof ThreadPageSyncDataEvent)) {
- Logger.error("createChartItem");
- return -1;
- }
- ThreadPageSyncDataEvent syncEvent = (ThreadPageSyncDataEvent) event;
-
- int apiType = syncEvent.getApiType();
- long errorNum = syncEvent.getErrorNum();
- switch (apiType) {
- case LogCenterConstants.SYNC_API_TYPE_NEW:
- case LogCenterConstants.SYNC_API_TYPE_NOTIFY:
- case LogCenterConstants.SYNC_API_TYPE_NOTIFY_ALL:
- case LogCenterConstants.SYNC_API_TYPE_OTHER:
- if(((DAChartBoardItem)item).getChartBoard() != null){
- stateItem = new DAChartSeriesItem(syncEvent.getDoubleTime(),
- DAChartSeriesItem.SERIES_STATE_CONNECTION,
- ColorResources.THREAD_GRAPH_LOCK_RELEASE_COLOR,
- "");
- } else {
- stateItem = new DAChartSeriesItem(syncEvent.getDoubleTime(),
- DAChartSeriesItem.SERIES_STATE_CONNECTION,
- ColorResources.THREAD_GRAPH_LOCK_RELEASE_COLOR,
- ThreadPageLabels.SYNC_CHART_ITEM_UNUSED);
- }
- apiItem = createApiItem(syncEvent, errorNum);
- stateSeries.addSeriesItem(stateItem);
- apiSeries.addSeriesItem(apiItem);
- break;
- case LogCenterConstants.SYNC_API_TYPE_ACQUIRE_WAIT_START:
- case LogCenterConstants.SYNC_API_TYPE_COND_WAIT_START:
- if(((DAChartBoardItem)item).getChartBoard() != null){
- stateItem = new DAChartSeriesItem(syncEvent.getDoubleTime(),
- DAChartSeriesItem.SERIES_STATE_CONNECTION,
- ColorResources.THREAD_GRAPH_LOCK_RELEASE_COLOR,
- "");
- } else{
- stateItem = new DAChartSeriesItem(syncEvent.getDoubleTime(),
- DAChartSeriesItem.SERIES_STATE_CONTINUE,
- ColorResources.THREAD_GRAPH_LOCK_WAIT_COLOR,
- ThreadPageLabels.SYNC_CHART_ITEM_WAITED);
- }
- apiItem = createApiItem(syncEvent, errorNum);
- stateSeries.addSeriesItem(stateItem);
- apiSeries.addSeriesItem(apiItem);
- break;
- case LogCenterConstants.SYNC_API_TYPE_RELEASE:
- if(((DAChartBoardItem)item).getChartBoard() != null){
- stateItem = new DAChartSeriesItem(syncEvent.getDoubleTime(),
- DAChartSeriesItem.SERIES_STATE_CONNECTION,
- ColorResources.THREAD_GRAPH_LOCK_RELEASE_COLOR,
- "");
- } else{
- stateItem = new DAChartSeriesItem(syncEvent.getDoubleTime(),
- DAChartSeriesItem.SERIES_STATE_CONNECTION,
- ColorResources.THREAD_GRAPH_LOCK_RELEASE_COLOR,
- ThreadPageLabels.SYNC_CHART_ITEM_UNUSED);
- }
- apiItem = createApiItem(syncEvent, errorNum);
- stateSeries.addSeriesItem(stateItem);
- apiSeries.addSeriesItem(apiItem);
- break;
- case LogCenterConstants.SYNC_API_TYPE_ACQUIRE_WAIT_END:
- case LogCenterConstants.SYNC_API_TYPE_COND_WAIT_END:
- if(((DAChartBoardItem)item).getChartBoard() != null){
- stateItem = new DAChartSeriesItem(syncEvent.getDoubleTime(),
- DAChartSeriesItem.SERIES_STATE_CONNECTION,
- ColorResources.THREAD_GRAPH_LOCK_RELEASE_COLOR,
- "");
- } else{
- stateItem = new DAChartSeriesItem(syncEvent.getDoubleTime(),
- DAChartSeriesItem.SERIES_STATE_CONTINUE,
- ColorResources.THREAD_GRAPH_LOCK_ACQUIRE_COLOR,
- ThreadPageLabels.SYNC_CHART_ITEM_USED);
- }
- stateSeries.addSeriesItem(stateItem);
- break;
- case LogCenterConstants.SYNC_API_TYPE_TRY_ACQUIRE:
- if(((DAChartBoardItem)item).getChartBoard() != null){
- stateItem = new DAChartSeriesItem(syncEvent.getDoubleTime(),
- DAChartSeriesItem.SERIES_STATE_CONNECTION,
- ColorResources.THREAD_GRAPH_LOCK_RELEASE_COLOR,
- "");
- } else{
- stateItem = new DAChartSeriesItem(syncEvent.getDoubleTime(),
- DAChartSeriesItem.SERIES_STATE_CONTINUE,
- ColorResources.THREAD_GRAPH_LOCK_ACQUIRE_COLOR,
- ThreadPageLabels.SYNC_CHART_ITEM_USED);
- }
- apiItem = createApiItem(syncEvent, errorNum);
- stateSeries.addSeriesItem(stateItem);
- apiSeries.addSeriesItem(apiItem);
- break;
- default:
- return -1;
- }
-
- return apiType;
- }
-
- public String getTypeString() {
- switch (getType()) {
- case LogCenterConstants.SYNC_TYPE_TIZEN_MUTEX:
- return ThreadPageLabels.SYNC_TYPE_TIZEN_MUTEX;
- case LogCenterConstants.SYNC_TYPE_TIZEN_MONITOR:
- return ThreadPageLabels.SYNC_TYPE_TIZEN_MONITOR;
- case LogCenterConstants.SYNC_TYPE_TIZEN_SEMAPHORE:
- return ThreadPageLabels.SYNC_TYPE_TIZEN_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:
- Logger.error("unknown sync type!!");
- return CommonConstants.EMPTY;
- }
- }
-
- public int getSyncDataID() {
- return syncDataID;
- }
-
- public byte getSyncDataType() {
- return syncDataType;
- }
-
- public int getParentID() {
- return parentID;
- }
-
- public void setParentID(int parentID) {
- this.parentID = parentID;
- }
-
- public static void clear() {
- internalSeq = 0;
- }
-}
\ No newline at end of file
+++ /dev/null
-/*
- * Dynamic Analyzer
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * WooJin Jung <woojin2.jung@samsung.com>
- * yeongtaik byeon <yeongtaik.byeon@samsung.com>
- * Juyoung Kim <j0.kim@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-package org.tizen.dynamicanalyzer.ui.thread.sync;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Comparator;
-
-import org.tizen.dynamicanalyzer.constant.CommonConstants;
-import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
-import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;
-import org.tizen.dynamicanalyzer.nl.TimelineChartLabels;
-import org.tizen.dynamicanalyzer.resources.ColorResources;
-import org.tizen.dynamicanalyzer.resources.FontResources;
-import org.tizen.dynamicanalyzer.resources.ImageResources;
-import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants;
-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.SyncData;
-import org.tizen.dynamicanalyzer.ui.common.PopupAnalysisMenuItemClickListener;
-import org.tizen.dynamicanalyzer.ui.common.PopupClearMenuItemClickListener;
-import org.tizen.dynamicanalyzer.ui.common.PopupEndMenuItemClickListener;
-import org.tizen.dynamicanalyzer.ui.common.PopupFromSelectionMenuItemClickListener;
-import org.tizen.dynamicanalyzer.ui.common.PopupStartMenuItemClickListener;
-import org.tizen.dynamicanalyzer.ui.common.TimelineChartMouseEventListener;
-import org.tizen.dynamicanalyzer.ui.common.TimelineChartMouseTrackAdapter;
-import org.tizen.dynamicanalyzer.ui.summary.SummaryDataManager;
-import org.tizen.dynamicanalyzer.ui.thread.ThreadPageData;
-import org.tizen.dynamicanalyzer.ui.thread.data.SyncDataInserter;
-import org.tizen.dynamicanalyzer.ui.thread.data.SyncEventInserter;
-import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
-import org.tizen.dynamicanalyzer.util.Logger;
-import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
-import org.tizen.dynamicanalyzer.widgets.chart.DAChart;
-import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlot;
-import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlot.AutoRangeType;
-import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlotTooltip;
-import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeries;
-import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoard;
-import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoardItem;
-import org.tizen.dynamicanalyzer.widgets.popupMenu.DAPopupMenu;
-import org.tizen.dynamicanalyzer.widgets.popupMenu.DAPopupMenuItem;
-
-public class ThreadPageSyncDataManager {
- private DAChartBoard board;
- private List<ThreadPageSyncData> rows = new ArrayList<ThreadPageSyncData>();
- private List<ThreadPageSyncData> rowsQueue = new ArrayList<ThreadPageSyncData>();
- private List<ThreadPageSyncDataEvent> syncEventQueue = new ArrayList<ThreadPageSyncDataEvent>();
- private HashMap<String, Integer> syncAttrMap = new HashMap<String, Integer>();
- public static final int PTHREAD_MUTEX_NORMAL = 0;
- public static final int PTHREAD_MUTEX_RECURSIVE = 1;
- public static final int PTHREAD_MUTEX_ERRORCHECK = 2;
- public static final int PTHREAD_MUTEX_DEFAULT = 3;
- private int preSelectionPid = -1;
-
- public ThreadPageSyncDataManager(DAChartBoard board) {
- this.setBoard(board);
- }
-
- protected DAChartBoard getBoard() {
- return board;
- }
-
- public void setBoard(DAChartBoard board) {
- this.board = board;
- }
-
- public void pushRow(ThreadPageSyncData data) {
- rowsQueue.add(data);
- }
-
- private void pushEvent(ThreadPageSyncDataEvent event) {
- syncEventQueue.add(event);
- }
-
- private ThreadPageSyncData findParentData(String name) {
- int size = rows.size();
- ThreadPageSyncData ret;
- for (int i = 0; i < size; i++) {
- ret = rows.get(i);
- if (ret.getKey().equals(name)) {
- return ret;
- }
- }
- return null;
- }
-
- public static String getAttrTypeByTypeInt(int typeInt) {
- if (typeInt == PTHREAD_MUTEX_NORMAL) {
- return ThreadPageLabels.SYNC_ATTR_TYPE_NORMAL;
- } else if (typeInt == PTHREAD_MUTEX_RECURSIVE) {
- return ThreadPageLabels.SYNC_ATTR_TYPE_RECURSIVE;
- } else if (typeInt == PTHREAD_MUTEX_ERRORCHECK) {
- return ThreadPageLabels.SYNC_ATTR_TYPE_ERRORCHECK;
- } else if (typeInt == PTHREAD_MUTEX_DEFAULT) { // for open trace
- return ThreadPageLabels.SYNC_ATTR_TYPE_DEFAULT;
- } else {
- return CommonConstants.EMPTY;
- }
- }
-
- public static String getAttrTypeString(ThreadPageSyncDataEvent event) {
- int type = event.getType();
-
- if (type == LogCenterConstants.SYNC_TYPE_TIZEN_MUTEX) {
- return ThreadPageLabels.SYNC_ATTR_TYPE_RECURSIVE;
- } else if (type == LogCenterConstants.SYNC_TYPE_PTHREAD_MUTEX) {
- return ThreadPageLabels.SYNC_ATTR_TYPE_DEFAULT;
- }
- return CommonConstants.EMPTY;
- }
-
- public void parseSync(LogData input) {
-
- if (null == input || !(input instanceof SyncData)) {
- return;
- }
- SyncData syncData = (SyncData) input;
- // System.out.println("input : " + input);
- long time = syncData.getTime();
- String tid = Integer.toString(syncData.getTid());
-
- int type = syncData.getSyncType();
- int apiType = syncData.getApiType();
- String apiName = syncData.getApiName();
-
- String name = Long.toString(syncData.getSyncValue());
-
- long errorNum = syncData.getErrno();
- if (errorNum != 0) {
- SummaryDataManager.getInstance().getFailedApiDataMaker().makeData(syncData);
- }
-
- ThreadPageSyncDataEvent event;
- switch (type) {
- case LogCenterConstants.SYNC_TYPE_TIZEN_MUTEX:
- case LogCenterConstants.SYNC_TYPE_TIZEN_MONITOR:
- case LogCenterConstants.SYNC_TYPE_TIZEN_SEMAPHORE:
- event = new ThreadPageSyncDataEvent(name, type, apiType, time, tid,
- apiName, errorNum, input);
- pushEvent(event);
- // parseTIZENSync(input, type);
- break;
- case LogCenterConstants.SYNC_TYPE_PTHREAD_MUTEX:
- case LogCenterConstants.SYNC_TYPE_PTHREAD_COND_VARIABLE:
- if (apiName
- .equals(ThreadPageLabels.SYNC_API_PTHREAD_MUTEXATTR_INIT)) {
- syncAttrMap.put(syncData.getArgs(), PTHREAD_MUTEX_NORMAL);
- } else if (apiName
- .equals(ThreadPageLabels.SYNC_API_PTHREAD_MUTEXATTR_SETTYPE)) {
- checkMutexAttrType(syncData.getArgs());
- } else {
- if (apiName
- .equals(ThreadPageLabels.SYNC_API_PTHREAD_MUTEX_INIT)) {
- checkMutexType(syncData.getArgs());
- }
- event = new ThreadPageSyncDataEvent(name, type, apiType, time,
- tid, apiName, errorNum, input);
- pushEvent(event);
- }
- break;
- case LogCenterConstants.SYNC_TYPE_PTHREAD_RWLOCK:
- case LogCenterConstants.SYNC_TYPE_PTHREAD_SPINLOCK:
- case LogCenterConstants.SYNC_TYPE_PTHREAD_BARRIER:
- event = new ThreadPageSyncDataEvent(name, type, apiType, time, tid,
- apiName, errorNum, input);
- pushEvent(event);
- Logger.error("sync parse - type = " + type);
- break;
- default:
- Logger.error("sync parse unknown - type = " + type);
-
- }
- }
-
- private void parseSyncs(List<LogData> inputs) {
- if (null == inputs || inputs.isEmpty()) {
- return;
- }
-
- int size = inputs.size();
- SyncData input;
-
- for (int i = 0; i < size; i++) {
- input = (SyncData) inputs.get(i);
- // System.out.println("input : " + input);
- long time = input.getTime();
- String tid = Integer.toString(input.getTid());
-
- int type = input.getSyncType();
- int apiType = input.getApiType();
- String apiName = input.getApiName();
-
- String name = Long.toString(input.getSyncValue());
-
- long errorNum = input.getErrno();
-
- ThreadPageSyncDataEvent event;
- switch (type) {
- case LogCenterConstants.SYNC_TYPE_TIZEN_MUTEX:
- case LogCenterConstants.SYNC_TYPE_TIZEN_MONITOR:
- case LogCenterConstants.SYNC_TYPE_TIZEN_SEMAPHORE:
- event = new ThreadPageSyncDataEvent(name, type, apiType, time,
- tid, apiName, errorNum, input);
- pushEvent(event);
- // parseTIZENSync(input, type);
- break;
- case LogCenterConstants.SYNC_TYPE_PTHREAD_MUTEX:
- case LogCenterConstants.SYNC_TYPE_PTHREAD_COND_VARIABLE:
- if (apiName
- .equals(ThreadPageLabels.SYNC_API_PTHREAD_MUTEXATTR_INIT)) {
- syncAttrMap.put(input.getArgs(), PTHREAD_MUTEX_NORMAL);
- } else if (apiName
- .equals(ThreadPageLabels.SYNC_API_PTHREAD_MUTEXATTR_SETTYPE)) {
- checkMutexAttrType(input.getArgs());
- } else {
- if (apiName
- .equals(ThreadPageLabels.SYNC_API_PTHREAD_MUTEX_INIT)) {
- checkMutexType(input.getArgs());
- }
- event = new ThreadPageSyncDataEvent(name, type, apiType,
- time, tid, apiName, errorNum, input);
- pushEvent(event);
- }
- break;
- case LogCenterConstants.SYNC_TYPE_PTHREAD_RWLOCK:
- case LogCenterConstants.SYNC_TYPE_PTHREAD_SPINLOCK:
- case LogCenterConstants.SYNC_TYPE_PTHREAD_BARRIER:
- event = new ThreadPageSyncDataEvent(name, type, apiType, time,
- tid, apiName, errorNum, input);
- pushEvent(event);
- Logger.error("sync parse - type = " + type);
- break;
- default:
- Logger.error("sync parse unknown - type = "
- + type);
- }
- }
- }
-
- private void checkMutexAttrType(String input) {
- String[] temp = input.split(",");
- if (temp.length != 2) {
- return;
- }
- String obj = temp[0];
- String type = temp[1].trim();
-
- if (null != syncAttrMap.get(obj)) {
- syncAttrMap.put(obj, Integer.valueOf(type));
- }
- }
-
- private void checkMutexType(String input) {
- String[] temp = input.split(",");
- if (temp.length != 2) {
- return;
- }
- String obj = temp[0];
- String attrObj = temp[1].trim();
-
- Integer attrType = syncAttrMap.get(attrObj);
- if (attrType != null) {
- syncAttrMap.put(obj, attrType);
- }
- }
-
- public List<LogData> getLogsFromLogPackage(LogPackage logPack,
- int logCenterConstants) {
- Logs logs = logPack.getLogs(logCenterConstants);
- if (null == logs || null == logs.getRawLogs() || logs.getRawLogs().isEmpty()) {
- return null;
- }
- List<LogData> ret = logs.getRawLogs();
- return ret;
- }
-
- public void parsePageData(LogPackage logPack) {
- List<LogData> inputs = getLogsFromLogPackage(logPack,
- DataChannelConstants.MSG_PROBE_SYNC);
- parseSyncs(inputs);
- }
-
- private void initSyncChart(DAChart chart, boolean isParent) {
- if (null == chart) {
- return;
- }
-
- DAChartSeries apiSeries = new DAChartSeries(
- ThreadPageLabels.THREAD_CHART_SERIES_API,
- DAChartSeries.SERIES_STYLE_EVENT, ColorResources.YELLOW);
-
- DAChartSeries stateSeries = new DAChartSeries(
- ThreadPageLabels.THREAD_SYNC_CHART_SERIES_STATE,
- DAChartSeries.SERIES_STYLE_STATE, ColorResources.WHITE,
- isParent);
-
- apiSeries.setSummarizeTooltipText(ThreadPageLabels.THREAD_TOOLTIP_APIS);
-
- chart.addSeries(stateSeries);
- chart.addSeries(apiSeries);
-
- DAChartPlot plot = chart.getPlot();
- if (null == plot) {
- return;
- }
- if (true == isParent) {
- plot.setBackgroundImage(ImageResources.BG_GRADIENT);
- } else {
- plot.setBackgroundImage(ImageResources.BG_CHILD_GRADIENT);
- }
- plot.setAutoHeightRange(AutoRangeType.MANUAL);
- plot.setAxisFont(FontResources.CHART_AXIS_FONT);
- plot.setAxisRangeY(0, 101);
- plot.setAxisRangeX(board.getVisibleStartTime(),
- board.getVisibleEndTime());
- DAChartPlotTooltip tooltip = new DAChartPlotTooltip(-1);
- tooltip.setFont(FontResources.CHART_TOOLTIP_FONT);
- plot.setTooltip(tooltip);
-
- DAPopupMenu popupMenu = new DAPopupMenu(chart);
- popupMenu.setFont(FontResources.CONTEXT_MENU_ITEM_FONT);
- DAPopupMenuItem startItem = new DAPopupMenuItem(popupMenu);
- startItem.setText(TimelineChartLabels.RANGE_CONTEXT_SET_START);
- startItem.addListener(new PopupStartMenuItemClickListener(startItem,
- board));
-
- DAPopupMenuItem endItem = new DAPopupMenuItem(popupMenu);
- endItem.setText(TimelineChartLabels.RANGE_CONTEXT_SET_END);
- endItem.addListener(new PopupEndMenuItemClickListener(endItem, board));
-
- DAPopupMenuItem fromSelectionItem = new DAPopupMenuItem(popupMenu);
- fromSelectionItem
- .setText(TimelineChartLabels.RANGE_CONTEXT_SET_FROM_SELECTION);
- fromSelectionItem
- .addListener(new PopupFromSelectionMenuItemClickListener(
- fromSelectionItem, board));
-
- DAPopupMenuItem analysisItem = new DAPopupMenuItem(popupMenu);
- analysisItem.setText(TimelineChartLabels.RANGE_CONTEXT_ANALYSIS);
- analysisItem.addListener(new PopupAnalysisMenuItemClickListener());
-
- DAPopupMenuItem clearItem = new DAPopupMenuItem(popupMenu);
- clearItem.setText(TimelineChartLabels.RANGE_CONTEXT_CLEAR);
- clearItem.addListener(new PopupClearMenuItemClickListener());
-
- TimelineChartMouseEventListener timelineChartMouseEventListener = new TimelineChartMouseEventListener(
- popupMenu, board.getTimeline());
- chart.addMouseListener(timelineChartMouseEventListener);
- chart.addMouseMoveListener(timelineChartMouseEventListener);
- chart.addMouseTrackListener(new TimelineChartMouseTrackAdapter(board
- .getTimeline()));
- plot.setMarkers(board.getMarkers());
- }
-
- private boolean createSyncBoardItem(ThreadPageSyncData parent,
- ThreadPageSyncData sync) {
- DAChartBoardItem item;
- DAChart chart;
-
- if (null == parent) {
- item = new DAChartBoardItem(board, sync.getTypeString()
- + ThreadPageLabels.THREAD_CHART_NAME_PREFIX
- + ThreadPageLabels.THREAD_CHART_NAME_OBJ + AnalyzerUtil.toHexdecimal(sync.getKey())
- + ThreadPageLabels.THREAD_CHART_NAME_POSTFIX);
- item.useExpand(true);
- chart = item.getChart();
- initSyncChart(chart, true);
- } else {
- DAChartBoardItem parentItem = parent.getItem();
- item = new DAChartBoardItem(parentItem,
- ThreadPageLabels.THREAD_CHART_NAME_TID + sync.getTid());
- item.useExpand(true);
- chart = item.getChart();
- initSyncChart(chart, false);
- }
-
- sync.setItem(item);
- item.setData(sync);
- chart.setData(sync);
- chart.redraw();
- return true;
- }
- // for sorting of child item of sync chart
- private boolean createSyncBoardItem(ThreadPageSyncData parent,
- ThreadPageSyncData sync, Comparator<DAChartBoardItem> c) {
- DAChartBoardItem item;
- DAChart chart;
- Integer tid = Integer.valueOf(sync.getTid());
-
- if (null == parent) {
- item = new DAChartBoardItem(board, sync.getTypeString()
- + ThreadPageLabels.THREAD_CHART_NAME_PREFIX
- + ThreadPageLabels.THREAD_CHART_NAME_OBJ + sync.getKey()
- + ThreadPageLabels.THREAD_CHART_NAME_POSTFIX);
- item.useExpand(true);
- chart = item.getChart();
- initSyncChart(chart, true);
- } else {
- DAChartBoardItem parentItem = parent.getItem();
- item = new DAChartBoardItem(parentItem,
- ThreadPageLabels.THREAD_CHART_NAME_TID
- + sync.getTid(), tid, c);
- item.useExpand(true);
- chart = item.getChart();
- initSyncChart(chart, false);
- }
-
- sync.setItem(item);
- item.setData(sync);
- chart.setData(sync);
- chart.redraw();
- return true;
- }
-
- private void chartFilteringByPid() {
- if(null == board || null == board.getItemList()){
- return;
- }
- int selectedPid = ToolbarArea.getInstance().getSelectedPid();
- boolean isCheck = false;
-
- if (syncEventQueue.size() > 0) {
- isCheck = true;
- }
-
- if (preSelectionPid != -1 && preSelectionPid != selectedPid) {
- isCheck = true;
- }
-
- if (isCheck) {
- int parentSize = board.getItemList().getItemSize();
- for (int i = 0; i < parentSize; i++) {
- DAChartBoardItem parentItem = board.getItemList().get(i);
-/*
- int childSize = parentItem.getChildItemList().getItemSize();
- int hidedCount = 0;
- for (int j = 0; j < childSize; j++) {
- DAChartBoardItem childItem = parentItem.getChildItemList()
- .get(j);
- int itemPid = getItemPid(childItem);
- if (itemPid == selectedPid) {
- parentItem.getChildItemList().showItem(j);
- board.showItem(i);
- } else if (selectedPid == 0) {
- parentItem.getChildItemList().showItem(j);
- board.showItem(i);
- } else if (itemPid == -1) {
- board.showItem(i);
- } else {
- parentItem.getChildItemList().hideItem(j);
- hidedCount++;
- }
- }
- if (childSize == 0) {
- int itemPid = getItemPid(parentItem);
- if (itemPid == selectedPid) {
- board.showItem(i);
- } else if (selectedPid == 0) {
- board.showItem(i);
- } else if (itemPid == -1) {
- board.showItem(i);
- } else {
- board.hideItem(i);
- hidedCount++;
- }
- } else {
- if (childSize == hidedCount) {
- board.hideItem(i);
- }
- }
-*/
- int itemPid = getItemPid(parentItem);
- if (itemPid == selectedPid) {
- board.showItem(i);
-// for(int j = 0; j < parentItem.getChildItemList().getItemSize(); j++) {
-// parentItem.getChildItemList().showItem(j);
-// }
- } else if (selectedPid == 0) {
- board.showItem(i);
- } else if (itemPid == -1) {
- board.showItem(i);
- } else {
- board.hideItem(i);
- }
- }
- }
- preSelectionPid = selectedPid;
- }
-
- private int getItemPid(DAChartBoardItem item) {
- int pid = -1;
- if (item.getData() instanceof ThreadPageData) {
- ThreadPageData threadPageData = (ThreadPageData) item.getData();
- pid = Integer.parseInt(threadPageData.getPid());
- }
- return pid;
- }
-
- private int getSortObject(DAChartBoardItem item) {
- Object sortObj = item.getSortObject();
- if (sortObj instanceof Integer) {
- return (Integer) sortObj;
- } else { // should never go here
- return -1;
- }
- }
-
- public void checkUpdate() {
- chartFilteringByPid();
-
- /* load ThreadPgeSyncData when open trace */
- int size = rowsQueue.size();
- if (size > 0) {
- ThreadPageSyncData sync;
- ThreadPageSyncData parent;
- for (int i = 0; i < size; i++) {
- sync = rowsQueue.get(0);
- if (sync.getSyncDataType() == ThreadPageSyncData.SYNC_PARENT) {
- rows.add(sync);
- createSyncBoardItem(null, sync);
- } else if (sync.getSyncDataType() == ThreadPageSyncData.SYNC_CHILD) {
- parent = findParentData(sync.getKey());
- if (null != parent) {
- parent.pushSync(sync);
- createSyncBoardItem(parent, sync,
- new Comparator<DAChartBoardItem>() {
- public int compare(DAChartBoardItem item1,
- DAChartBoardItem item2) {
- return getSortObject(item1) - getSortObject(item2);
- }
- });
- } else {
- Logger.error("cannot find parent sync data");
- }
- } else {
- Logger.error("unknown sync data type");
- }
- rowsQueue.remove(0);
- }
- }
-
- size = syncEventQueue.size();
- if (size > 0) {
- ThreadPageSyncData parent;
- ThreadPageSyncData data;
- ThreadPageSyncDataEvent event;
- for (int i = 0; i < size; i++) {
- event = syncEventQueue.get(0);
- String syncVal = event.getSyncVal();
- String pid = Integer.toString(event.getContents().getPid());
- parent = findParentData(syncVal);
- // parent
- if (null == parent) {
- Integer syncAttrTypeInt = syncAttrMap.get(syncVal);
- String syncAttrType;
-
- if (null != syncAttrTypeInt) {
- syncAttrType = getAttrTypeByTypeInt(syncAttrTypeInt);
- } else {
- syncAttrType = getAttrTypeString(event);
- }
-
- parent = new ThreadPageSyncData(event.getType(), syncVal, pid,
- event.getTid(), syncAttrType, ThreadPageSyncData.SYNC_PARENT);
- // save to DB
- SyncDataInserter.pushSyncData(parent);
- SyncDataInserter.startThread();
- rows.add(parent);
- createSyncBoardItem(null, parent);
- }
- parent.pushEvent(event);
- event.setSyncDataID(parent.getSyncDataID());
- // save to DB
- SyncEventInserter.pushSyncEvent(event);
- SyncEventInserter.startThread();
- // child
- data = parent.findChildData(event.getTid());
-
- if (null == data) {
- String attrType = parent.getAttrType();
- data = new ThreadPageSyncData(event.getType(), syncVal, pid,
- event.getTid(), attrType, ThreadPageSyncData.SYNC_CHILD);
- data.setParentID(parent.getSyncDataID());
- // save to DB
- SyncDataInserter.pushSyncData(data);
- SyncDataInserter.startThread();
- parent.pushSync(data);
- createSyncBoardItem(parent, data,
- new Comparator<DAChartBoardItem>() {
- public int compare(DAChartBoardItem item1,
- DAChartBoardItem item2) {
- return getSortObject(item1) - getSortObject(item2);
- }
- });
- }
- data.pushEvent(event);
- try {
- ThreadPageSyncDataEvent cloneEvent = (ThreadPageSyncDataEvent) event.clone();
- cloneEvent.setSyncDataID(data.getSyncDataID());
- // save to DB
- SyncEventInserter.pushSyncEvent(cloneEvent);
- } catch (CloneNotSupportedException e) {
- e.printStackTrace();
- continue;
- } finally {
- syncEventQueue.remove(0);
- }
- }
- }
- size = rows.size();
- if (size > 0) {
- ThreadPageSyncData data;
- for (int i = 0; i < size; i++) {
- data = rows.get(i);
- data.checkUpdate();
- }
- }
- }
-
- public void clear() {
- rows.clear(); // FIXME : clear chart
- syncEventQueue.clear();
- syncAttrMap.clear();
- ThreadPageSyncData.clear(); // reset internal seq number
- }
-}
\ No newline at end of file
+++ /dev/null
-/*
- * Dynamic Analyzer
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * WooJin Jung <woojin2.jung@samsung.com>
- * yeongtaik byeon <yeongtaik.byeon@samsung.com>
- * Juyoung Kim <j0.kim@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-package org.tizen.dynamicanalyzer.ui.thread.thread;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.tizen.dynamicanalyzer.common.AnalyzerManager;
-import org.tizen.dynamicanalyzer.constant.CommonConstants;
-import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
-import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;
-import org.tizen.dynamicanalyzer.common.Global;
-import org.tizen.dynamicanalyzer.ui.thread.ThreadChartManager;
-import org.tizen.dynamicanalyzer.ui.thread.ThreadPageData;
-import org.tizen.dynamicanalyzer.ui.thread.ThreadPageDataEvent;
-import org.tizen.dynamicanalyzer.ui.thread.sync.ThreadPageSyncData;
-import org.tizen.dynamicanalyzer.util.Logger;
-import org.tizen.dynamicanalyzer.utils.Formatter;
-import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeries;
-import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeriesItem;
-import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoardItem;
-
-public class ThreadPageThreadData extends ThreadPageData {
- private List<ThreadPageSyncData> syncs = new ArrayList<ThreadPageSyncData>();
- private long StartTime = -1;
- private long EndTime = -1;
- private int threadFuncID;
- private String threadClassName = CommonConstants.EMPTY;
- private DAChartSeries loadSeries;
- private DAChartSeries eventSeries;
- private DAChartSeries apiSeries;
-
- public static final byte TYPE_MAIN = 0;
- public static final byte TYPE_PTHREAD = 1;
- public static final byte TYPE_TIZEN = 2;
-
- private static int internalSeq = 0;
- private int threadDataID = -1;
-
- public ThreadPageThreadData(int type, String pid, String tid,
- String attrType, int funcID) {
- super(type, String.valueOf(tid), pid, tid, attrType);
- this.threadFuncID = funcID;
- threadDataID = internalSeq++;
- }
-
- // using open trace
- public ThreadPageThreadData(int id, int pid, int tid, int threadType,
- String attrType, long startTime, long endTime, int functionID,
- String className) {
- super(threadType, String.valueOf(tid), String.valueOf(pid), String
- .valueOf(tid), attrType);
- this.threadDataID = id;
- this.threadFuncID = functionID;
- this.StartTime = startTime;
- this.EndTime = endTime;
- this.threadClassName = className;
- }
-
- public void addDataEvent(ThreadPageThreadDataEvent dataEvent) {
- contentsQueue.add(dataEvent);
- }
-
- public int getThreadFuncID() {
- return threadFuncID;
- }
-
- public String getThreadFuncName() {
- if (threadFuncID == -1) {
- return CommonConstants.EMPTY;
- } else {
- return Global.getFunctionName(threadFuncID);
- }
- }
-
- public String getThreadClassName() {
- return threadClassName;
- }
-
- public void setThreadClassName(String className) {
- threadClassName = className;
- }
-
- public void setItem(DAChartBoardItem item) {
- this.item = item;
- chart = item.getChart();
- loadSeries = chart.getSeries(ThreadPageLabels.THREAD_CHART_SERIES_LOAD);
- eventSeries = chart
- .getSeries(ThreadPageLabels.THREAD_CHART_SERIES_EVENT);
- apiSeries = chart.getSeries(ThreadPageLabels.THREAD_CHART_SERIES_API);
- }
-
- protected int createChartItem(ThreadPageDataEvent event) {
- int ret = -1;
- if (!(event instanceof ThreadPageThreadDataEvent)) {
- Logger.error("createChartItem");
- return ret;
- }
-
- ThreadPageThreadDataEvent threadEvent = (ThreadPageThreadDataEvent) event;
- DAChartSeriesItem seriesItem;
-
- switch (threadEvent.getEventType()) {
- case ThreadPageThreadDataEvent.TYPE_LOAD:
- ret = ThreadPageThreadDataEvent.TYPE_LOAD;
- if (null == loadSeries) {
- return ret;
- }
-
- seriesItem = new DAChartSeriesItem(threadEvent.getDoubleTime(),
- (double) (threadEvent.getThreadType() * 2.55),
- threadEvent.getTooltipContent());
-
- loadSeries.addSeriesItem(seriesItem);
- break;
- case ThreadPageThreadDataEvent.TYPE_EVENT:
- ret = ThreadPageThreadDataEvent.TYPE_EVENT;
- if (null == eventSeries) {
- return ret;
- }
-
- int eventApiType = threadEvent.getApiType();
- if (eventApiType == LogCenterConstants.THREAD_API_TYPE_INTERNAL_START) {
- seriesItem = new DAChartSeriesItem(threadEvent.getDoubleTime(),
- DAChartSeriesItem.SERIES_ARROW_LEFT,
- threadEvent.getTooltipContent());
- seriesItem.setBarWidth(Double.parseDouble(threadEvent
- .getCallerTid()));
- setStartTime(threadEvent.getTime());
- } else if (eventApiType == LogCenterConstants.THREAD_API_TYPE_WAIT_END) {
- if (threadEvent.isJoinAPI()) {
- seriesItem = new DAChartSeriesItem(
- threadEvent.getDoubleTime(),
- DAChartSeriesItem.SERIES_ARROW_LEFT,
- ThreadPageLabels.THREAD_CHART_ITEM_JOINED);
- seriesItem.setBarWidth(Double.parseDouble(threadEvent
- .getCallerTid()));
- } else {
- seriesItem = new DAChartSeriesItem(
- threadEvent.getDoubleTime(),
- DAChartSeriesItem.SERIES_ARROW_NONE,
- threadEvent.getTooltipContent());
- }
- } else if (eventApiType == LogCenterConstants.THREAD_API_TYPE_INTERNAL_STOP) {
- if (null != threadEvent.getCallerTid()) {
- seriesItem = new DAChartSeriesItem(
- threadEvent.getDoubleTime(),
- DAChartSeriesItem.SERIES_ARROW_LEFT,
- threadEvent.getTooltipContent());
- seriesItem.setBarWidth(Double.parseDouble(threadEvent
- .getCallerTid()));
- } else {
- seriesItem = new DAChartSeriesItem(
- threadEvent.getDoubleTime(),
- DAChartSeriesItem.SERIES_ARROW_NONE,
- threadEvent.getTooltipContent());
- }
- setEndTime(threadEvent.getTime());
- // save ThreadData when endtime is set
- if (AnalyzerManager.isRunning()) {
- ThreadChartManager.getInstance().saveThreadPageThreadData(
- this);
- }
- } else {
- seriesItem = new DAChartSeriesItem(threadEvent.getDoubleTime(),
- DAChartSeriesItem.SERIES_ARROW_NONE,
- threadEvent.getTooltipContent());
- }
-
- eventSeries.addSeriesItem(seriesItem);
- break;
- case ThreadPageThreadDataEvent.TYPE_API:
- ret = ThreadPageThreadDataEvent.TYPE_API;
- if (null == apiSeries) {
- return ret;
- }
-
- long errorNum = threadEvent.getErrorNum();
- seriesItem = createApiItem(threadEvent, errorNum);
-
- apiSeries.addSeriesItem(seriesItem);
- break;
- default:
- return ret;
- }
- threadEvent.setChartItem(seriesItem);
- return ret;
- }
-
- protected void checkUpdate() {
- if (false == hasUpdate) {
- return;
- } else {
- hasUpdate = false;
- }
-
- int size = contentsQueue.size();
- if (size > 0) {
- ThreadPageDataEvent temp;
- ThreadPageThreadDataEvent event;
- for (int i = 0; i < size; i++) {
- temp = contentsQueue.get(0);
- if ((temp instanceof ThreadPageThreadDataEvent)) {
- event = (ThreadPageThreadDataEvent) temp;
- if (ThreadPageThreadDataEvent.TYPE_API == createChartItem(event)) {
- contents.add(event);
- }
- }
- contentsQueue.remove(0);
- }
- chart.redraw();
- }
-
- size = syncs.size();
- if (size > 0) {
- ThreadPageSyncData sync;
- for (int i = 0; i < size; i++) {
- sync = syncs.get(i);
- sync.checkUpdate();
- }
- }
- }
-
- public void pushSync(ThreadPageSyncData sync) {
- syncs.add(sync);
- hasUpdate = true;
- }
-
- protected ThreadPageSyncData findSyncData(String syncVal) {
- int size = syncs.size();
- ThreadPageSyncData sync;
- for (int i = 0; i < size; i++) {
- sync = syncs.get(i);
- if (sync.getKey().equals(syncVal)) {
- return sync;
- }
- }
- return null;
- }
-
- public String getTypeString() {
- switch (getType()) {
- case TYPE_MAIN:
- return ThreadPageLabels.THREAD_ITEM_TYPE_MAIN;
- case TYPE_PTHREAD:
- return ThreadPageLabels.THREAD_ITEM_TYPE_PTHREAD;
- case TYPE_TIZEN:
- return ThreadPageLabels.THREAD_ITEM_TYPE_TIZEN;
- default:
- Logger.error("unknown thread type!!");
- return CommonConstants.EMPTY;
- }
- }
-
- public long getStartTime() {
- return StartTime;
- }
-
- public void setStartTime(long startTime) {
- StartTime = startTime;
- }
-
- public String getStartTimeString() { // to show in details view
- if (StartTime == -1) {
- return null;
- } else {
- double startTime = Formatter.longTimeToDoubleTime(StartTime);
- return String.valueOf(startTime);
- }
- }
-
- public long getEndTime() {
- return EndTime;
- }
-
- public void setEndTime(long endTime) {
- EndTime = endTime;
- }
-
- public String getEndTimeString() { // to show in details view
- if (EndTime == -1) {
- return null;
- } else {
- double endTime = Formatter.longTimeToDoubleTime(EndTime);
- return String.valueOf(endTime);
- }
- }
-
- public int getThreadDataID() {
- return threadDataID;
- }
-
- public static void clear() {
- internalSeq = 0;
- }
-}
\ No newline at end of file
+++ /dev/null
-/*
- * Dynamic Analyzer
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * WooJin Jung <woojin2.jung@samsung.com>
- * yeongtaik byeon <yeongtaik.byeon@samsung.com>
- * Juyoung Kim <j0.kim@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-package org.tizen.dynamicanalyzer.ui.thread.thread;
-
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.List;
-
-import org.tizen.dynamicanalyzer.common.Global;
-import org.tizen.dynamicanalyzer.common.SymbolManager;
-import org.tizen.dynamicanalyzer.constant.CommonConstants;
-import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
-import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;
-import org.tizen.dynamicanalyzer.nl.TimelineChartLabels;
-import org.tizen.dynamicanalyzer.resources.ColorResources;
-import org.tizen.dynamicanalyzer.resources.FontResources;
-import org.tizen.dynamicanalyzer.resources.ImageResources;
-import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants;
-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.ProcessProfileData;
-import org.tizen.dynamicanalyzer.swap.model.data.SyncData;
-import org.tizen.dynamicanalyzer.swap.model.data.SystemData;
-import org.tizen.dynamicanalyzer.swap.model.data.ThreadData;
-import org.tizen.dynamicanalyzer.ui.common.PopupAnalysisMenuItemClickListener;
-import org.tizen.dynamicanalyzer.ui.common.PopupClearMenuItemClickListener;
-import org.tizen.dynamicanalyzer.ui.common.PopupEndMenuItemClickListener;
-import org.tizen.dynamicanalyzer.ui.common.PopupFromSelectionMenuItemClickListener;
-import org.tizen.dynamicanalyzer.ui.common.PopupStartMenuItemClickListener;
-import org.tizen.dynamicanalyzer.ui.common.TimelineChartMouseEventListener;
-import org.tizen.dynamicanalyzer.ui.common.TimelineChartMouseTrackAdapter;
-import org.tizen.dynamicanalyzer.ui.summary.SummaryDataManager;
-import org.tizen.dynamicanalyzer.ui.summary.warning.WarningCase;
-import org.tizen.dynamicanalyzer.ui.thread.ThreadPageData;
-import org.tizen.dynamicanalyzer.ui.thread.data.SyncAPIInserter;
-import org.tizen.dynamicanalyzer.ui.thread.data.SyncDataInserter;
-import org.tizen.dynamicanalyzer.ui.thread.data.SyncEventInserter;
-import org.tizen.dynamicanalyzer.ui.thread.data.ThreadEventInserter;
-import org.tizen.dynamicanalyzer.ui.thread.sync.ThreadPageSyncData;
-import org.tizen.dynamicanalyzer.ui.thread.sync.ThreadPageSyncDataEvent;
-import org.tizen.dynamicanalyzer.ui.thread.sync.ThreadPageSyncDataManager;
-import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
-import org.tizen.dynamicanalyzer.util.Logger;
-import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
-import org.tizen.dynamicanalyzer.widgets.chart.DAChart;
-import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlot;
-import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlot.AutoRangeType;
-import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlotTooltip;
-import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeries;
-import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeriesItem;
-import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoard;
-import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoardItem;
-import org.tizen.dynamicanalyzer.widgets.popupMenu.DAPopupMenu;
-import org.tizen.dynamicanalyzer.widgets.popupMenu.DAPopupMenuItem;
-
-public class ThreadPageThreadDataManager {
- private DAChartBoard board;
- // ThreadChartView view;
- private boolean hasUpdate = false;
- private List<ThreadPageThreadData> rows = new ArrayList<ThreadPageThreadData>();
- private List<ThreadPageThreadData> rowsQueue = new ArrayList<ThreadPageThreadData>();
- private List<ThreadPageThreadData> callRowsQueue = new ArrayList<ThreadPageThreadData>();
- private List<ThreadPageSyncDataEvent> syncEventQueue = new ArrayList<ThreadPageSyncDataEvent>();
- private List<ThreadPageThreadDataEvent> eventQueue = new ArrayList<ThreadPageThreadDataEvent>();
- private List<ThreadPageThreadDataEvent> callEventQueue = new ArrayList<ThreadPageThreadDataEvent>();
- // load from database
- private List<ThreadPageSyncData> syncQueue = new ArrayList<ThreadPageSyncData>();
-
- private HashMap<String, Integer> threadAttrMap = new HashMap<String, Integer>();
- private HashMap<String, Integer> syncAttrMap = new HashMap<String, Integer>();
- // threadFuncMap : (pthreadId, function address)
- private HashMap<String, Long> threadFuncMap = new HashMap<String, Long>();
- private int preSelectionPid = -1;
-
- public static final int PTHREAD_CREATE_JOINABLE = 0;
- public static final int PTHREAD_CREATE_DETACHED = 1;
-
- public ThreadPageThreadDataManager(DAChartBoard board) {
- this.setBoard(board);
- }
-
- public List<ThreadPageThreadData> getRows() {
- return rows;
- }
-
- public void pushRow(ThreadPageThreadData data) {
- rowsQueue.add(data);
- hasUpdate = true;
- }
-
- private void pushCallRow(ThreadPageThreadData data) { // FIXME
- callRowsQueue.add(data);
- }
-
- private void pushEvent(ThreadPageThreadDataEvent event) {
- eventQueue.add(event);
- hasUpdate = true;
- }
-
- private void pushCallEvent(ThreadPageThreadDataEvent event) {
- callEventQueue.add(event);
- }
-
- private void pushSyncEvent(ThreadPageSyncDataEvent syncEvent) {
- syncEventQueue.add(syncEvent);
- hasUpdate = true;
- }
-
- public void pushSyncData(ThreadPageSyncData syncData) {
- syncQueue.add(syncData);
- }
-
- private void createBoardItem(ThreadPageThreadData data) {
- // DACustomChartBoardItem item = new DACustomChartBoardItem(board,
- // data.getName());
-
- DAChartBoardItem item = new DAChartBoardItem(board, data.getTypeString()
- + ThreadPageLabels.THREAD_CHART_NAME_PREFIX
- + ThreadPageLabels.THREAD_CHART_NAME_PID + data.getPid()
- + ThreadPageLabels.THREAD_CHART_NAME_COMMA + ThreadPageLabels.THREAD_CHART_NAME_TID
- + data.getKey() + ThreadPageLabels.THREAD_CHART_NAME_POSTFIX);
-
- item.useExpand(true);
- DAChart chart = item.getChart();
- setChartSeries(chart);
-
- setChartStyle(chart);
-
- data.setItem(item);
- item.setData(data);
- chart.setData(data);
- chart.redraw();
- }
-
- // for sorting of thread chart item
- private void createBoardItem(ThreadPageThreadData data, Comparator<DAChartBoardItem> c) {
- // DACustomChartBoardItem item = new DACustomChartBoardItem(board,
- // data.getName());
- Integer tid = Integer.valueOf(data.getTid());
-
- DAChartBoardItem item = new DAChartBoardItem(board, data.getTypeString()
- + ThreadPageLabels.THREAD_CHART_NAME_PREFIX
- + ThreadPageLabels.THREAD_CHART_NAME_PID + data.getPid()
- + ThreadPageLabels.THREAD_CHART_NAME_COMMA + ThreadPageLabels.THREAD_CHART_NAME_TID
- + data.getKey() + ThreadPageLabels.THREAD_CHART_NAME_POSTFIX, tid, c);
-
- item.useExpand(true);
- DAChart chart = item.getChart();
- setChartSeries(chart);
-
- setChartStyle(chart);
-
- data.setItem(item);
- item.setData(data);
- chart.setData(data);
- chart.redraw();
- }
-
- private void initSyncChart(DAChart chart) {
- if (null == chart) {
- return;
- }
-
- DAChartSeries apiSeries = new DAChartSeries(ThreadPageLabels.THREAD_CHART_SERIES_API,
- DAChartSeries.SERIES_STYLE_STATE, ColorResources.YELLOW);
- DAChartSeries stateSeries = new DAChartSeries(
- ThreadPageLabels.THREAD_SYNC_CHART_SERIES_STATE, DAChartSeries.SERIES_STYLE_STATE,
- ColorResources.WHITE);
-
- chart.addSeries(stateSeries);
- chart.addSeries(apiSeries);
-
- DAChartPlot plot = chart.getPlot();
- if (null == plot) {
- return;
- }
- plot.setBackgroundImage(ImageResources.BG_CHILD_GRADIENT);
- plot.setAutoHeightRange(AutoRangeType.MANUAL);
- plot.setAxisFont(FontResources.CHART_AXIS_FONT);
- plot.setAxisRangeY(0, 101);
- plot.setAxisRangeX(board.getVisibleStartTime(), board.getVisibleEndTime());
- DAChartPlotTooltip tooltip = new DAChartPlotTooltip(-1);
- tooltip.setFont(FontResources.CHART_TOOLTIP_FONT);
- plot.setTooltip(tooltip);
-
- DAPopupMenu popupMenu = new DAPopupMenu(chart);
- popupMenu.setFont(FontResources.CONTEXT_MENU_ITEM_FONT);
- DAPopupMenuItem startItem = new DAPopupMenuItem(popupMenu);
- startItem.setText(TimelineChartLabels.RANGE_CONTEXT_SET_START);
- startItem.addListener(new PopupStartMenuItemClickListener(startItem, board));
-
- DAPopupMenuItem endItem = new DAPopupMenuItem(popupMenu);
- endItem.setText(TimelineChartLabels.RANGE_CONTEXT_SET_END);
- endItem.addListener(new PopupEndMenuItemClickListener(endItem, board));
-
- DAPopupMenuItem fromSelectionItem = new DAPopupMenuItem(popupMenu);
- fromSelectionItem.setText(TimelineChartLabels.RANGE_CONTEXT_SET_FROM_SELECTION);
- fromSelectionItem.addListener(new PopupFromSelectionMenuItemClickListener(
- fromSelectionItem, board));
-
- DAPopupMenuItem analysisItem = new DAPopupMenuItem(popupMenu);
- analysisItem.setText(TimelineChartLabels.RANGE_CONTEXT_ANALYSIS);
- analysisItem.addListener(new PopupAnalysisMenuItemClickListener());
-
- DAPopupMenuItem clearItem = new DAPopupMenuItem(popupMenu);
- clearItem.setText(TimelineChartLabels.RANGE_CONTEXT_CLEAR);
- clearItem.addListener(new PopupClearMenuItemClickListener());
-
- TimelineChartMouseEventListener timelineChartMouseEventListener = new TimelineChartMouseEventListener(
- popupMenu, board.getTimeline());
- chart.addMouseListener(timelineChartMouseEventListener);
- chart.addMouseMoveListener(timelineChartMouseEventListener);
- chart.addMouseTrackListener(new TimelineChartMouseTrackAdapter(board.getTimeline()));
-
- plot.setMarkers(board.getMarkers());
- }
-
- private boolean createSyncBoardItem(ThreadPageThreadData data, ThreadPageSyncData sync) {
- DAChartBoardItem parent = data.getItem();
- if (null == parent) {
- return false;
- }
-
- DAChartBoardItem item = new DAChartBoardItem(parent, sync.getTypeString()
- + ThreadPageLabels.THREAD_CHART_NAME_PREFIX
- + ThreadPageLabels.THREAD_CHART_NAME_OBJ + AnalyzerUtil.toHexdecimal(sync.getKey())
- + ThreadPageLabels.THREAD_CHART_NAME_POSTFIX);
-
- item.useExpand(true);
- DAChart chart = item.getChart();
- initSyncChart(chart);
-
- sync.setItem(item);
- item.setData(sync);
- chart.setData(sync);
- chart.redraw();
- return true;
- }
-
- protected void setChartStyle(DAChart chart) {
- if (null == chart) {
- return;
- }
-
- DAChartPlot plot = chart.getPlot();
- if (null == plot) {
- return;
- }
- plot.setBackgroundImage(ImageResources.BG_GRADIENT);
- plot.setAutoHeightRange(AutoRangeType.MANUAL);
- DAChartPlotTooltip tooltip = new DAChartPlotTooltip(-1);
- tooltip.setFont(FontResources.CHART_TOOLTIP_FONT);
- plot.setTooltip(tooltip);
- plot.setAxisFont(FontResources.CHART_AXIS_FONT);
- plot.setAxisRangeY(0, 101);
- plot.setAxisRangeX(board.getVisibleStartTime(), board.getVisibleEndTime());
-
- DAPopupMenu popupMenu = new DAPopupMenu(chart);
-
- popupMenu.setFont(FontResources.CONTEXT_MENU_ITEM_FONT);
- DAPopupMenuItem startItem = new DAPopupMenuItem(popupMenu);
- startItem.setText(TimelineChartLabels.RANGE_CONTEXT_SET_START);
- startItem.addListener(new PopupStartMenuItemClickListener(startItem, board));
-
- DAPopupMenuItem endItem = new DAPopupMenuItem(popupMenu);
- endItem.setText(TimelineChartLabels.RANGE_CONTEXT_SET_END);
- endItem.addListener(new PopupEndMenuItemClickListener(endItem, board));
-
- DAPopupMenuItem fromSelectionItem = new DAPopupMenuItem(popupMenu);
- fromSelectionItem.setText(TimelineChartLabels.RANGE_CONTEXT_SET_FROM_SELECTION);
- fromSelectionItem.addListener(new PopupFromSelectionMenuItemClickListener(
- fromSelectionItem, board));
-
- DAPopupMenuItem analysisItem = new DAPopupMenuItem(popupMenu);
- analysisItem.setText(TimelineChartLabels.RANGE_CONTEXT_ANALYSIS);
- analysisItem.addListener(new PopupAnalysisMenuItemClickListener());
-
- DAPopupMenuItem clearItem = new DAPopupMenuItem(popupMenu);
- clearItem.setText(TimelineChartLabels.RANGE_CONTEXT_CLEAR);
- clearItem.addListener(new PopupClearMenuItemClickListener());
-
- TimelineChartMouseEventListener timelineChartMouseEventListener = new TimelineChartMouseEventListener(
- popupMenu, board.getTimeline());
- chart.addMouseListener(timelineChartMouseEventListener);
- chart.addMouseMoveListener(timelineChartMouseEventListener);
- chart.addMouseTrackListener(new TimelineChartMouseTrackAdapter(board.getTimeline()));
- plot.setMarkers(board.getMarkers());
- }
-
- private void setChartSeries(DAChart chart) {
- DAChartSeries loadSeries = new DAChartSeries(ThreadPageLabels.THREAD_CHART_SERIES_LOAD,
- DAChartSeries.SERIES_STYLE_LOAD, ColorResources.THREAD_GRAPH_MIN_CPU_LOAD_COLOR,
- ColorResources.THREAD_GRAPH_MAX_CPU_LOAD_COLOR);
- loadSeries.setBarWidth(1);
-
- DAChartSeries apiSeries = new DAChartSeries(ThreadPageLabels.THREAD_CHART_SERIES_API,
- DAChartSeries.SERIES_STYLE_EVENT, ColorResources.YELLOW);
-
- DAChartSeries eventSeries = new DAChartSeries(ThreadPageLabels.THREAD_CHART_SERIES_EVENT,
- DAChartSeries.SERIES_STYLE_ARROW, ColorResources.THREAD_GRAPH_CALLEE_COLOR);
-
- apiSeries.setSummarizeTooltipText(ThreadPageLabels.THREAD_TOOLTIP_APIS);
- eventSeries.setFont(FontResources.CHART_ARROW_TID_FONT);
-
- chart.addSeries(loadSeries);
- chart.addSeries(apiSeries);
- chart.addSeries(eventSeries);
-
- chart.redraw();
- }
-
- public void createMainThreadItem(int tid) {
- int funcID = Global.getFunctionID("main");
- ThreadPageThreadData mainData = new ThreadPageThreadData(ThreadPageThreadData.TYPE_MAIN,
- String.valueOf(tid), String.valueOf(tid), CommonConstants.EMPTY, funcID);
- pushRow(mainData);
- }
-
- public static String getAttrTypeByTypeInt(int typeInt) {
- if (typeInt == PTHREAD_CREATE_JOINABLE) {
- return ThreadPageLabels.THREAD_ATTR_TYPE_JOINABLE;
- } else if (typeInt == PTHREAD_CREATE_DETACHED) {
- return ThreadPageLabels.THREAD_ATTR_TYPE_DETACHED;
- } else {
- return CommonConstants.EMPTY;
- }
- }
-
- public List<LogData> getLogsFromLogPackage(LogPackage logPack, int logCenterConstants) {
- Logs logs = logPack.getLogs(logCenterConstants);
- if (null == logs || logs.getRawLogs().size() == 0) {
- return null;
- }
- List<LogData> ret = logs.getRawLogs();
- return ret;
- }
-
- public void parseLoad(LogData input) {
- if (null == input) {
- return;
- }
-
- if (!(input instanceof SystemData)) {
- return;
- }
- SystemData sysLog = (SystemData) input;
-
- String loads;
- String tid;
- int load;
-
- ProcessProfileData[] processDataList = sysLog.getProcessProfileDataList();
-
- for (int i = 0; i < processDataList.length; i++) {
- loads = processDataList[i].getThreadLoad();
- String[] temp = loads.split(",");
- int tempSize = temp.length;
- long time;
- for (int j = 0; j + 1 < tempSize; j += 2) {
- try {
- tid = temp[j];
- } catch (NumberFormatException nfe) {
- Logger.error("parseLoad - tid parsing");
- break;
- }
- // if (null == findParentData(tid)) {
- // continue;
- // }
- load = (int) (Double.parseDouble(temp[j + 1]));
- time = input.getTime();
- ThreadPageThreadDataEvent event = new ThreadPageThreadDataEvent(
- ThreadPageThreadDataEvent.TYPE_LOAD, load, -1, time, tid,
- String.valueOf(load) + ThreadPageLabels.THREAD_CHART_ITEM_PERCENT, -1, null);
- pushEvent(event);
-
- }
- }
- hasUpdate = true;
- // loads = sysLog.getThreadLoad(); // TODO SystemData interface changed.
- // // loads = input.get(LogCenterConstants.DEVICE_THREAD_LOAD_INDEX);
- // String[] temp = loads.split(",");
- // int tempSize = temp.length;
- // double time;
- // for (int j = 0; j + 1 < tempSize; j += 2) {
- // try {
- // tid = temp[j];
- // } catch (NumberFormatException nfe) {
- // Logger.error("parseLoad - tid parsing");
- // break;
- // }
- // // if (null == findParentData(tid)) {
- // // continue;
- // // }
- // load = (int) (Double.parseDouble(temp[j + 1]));
- // time = Double.parseDouble(Long.toString(input.getTime()))
- // / TimelineConstants.MEGA_DOUBLE;
- // ThreadPageThreadDataEvent event = new ThreadPageThreadDataEvent(
- // ThreadPageThreadDataEvent.TYPE_LOAD, load, -1, time, tid,
- // String.valueOf(load)
- // + ThreadPageLabels.THREAD_CHART_ITEM_PERCENT, -1,
- // null);
- // pushEvent(event);
- //
- // }
- // hasUpdate = true;
- }
-
- private void parseLoad(LogPackage logPack) {
- List<LogData> inputs = getLogsFromLogPackage(logPack, DataChannelConstants.MSG_DATA_SYSTEM);
- int size;
- if (null == inputs || 0 == (size = inputs.size())) {
- return;
- }
- SystemData input;
-
- String loads;
- String tid;
- int load;
- for (int i = 0; i < size; i++) {
- input = (SystemData) inputs.get(i);
- ProcessProfileData[] processDataList = input.getProcessProfileDataList();
-
- for (int j = 0; j < processDataList.length; j++) {
- loads = processDataList[j].getThreadLoad();
- String[] temp = loads.split(",");
- int tempSize = temp.length;
- long time;
- for (int k = 0; k + 1 < tempSize; k += 2) {
- try {
- tid = temp[k];
- } catch (NumberFormatException nfe) {
- Logger.error("parseLoad - tid parsing");
- break;
- }
- // if (null == findParentData(tid)) {
- // continue;
- // }
- load = (int) (Double.parseDouble(temp[k + 1]));
- time = input.getTime();
- ThreadPageThreadDataEvent event = new ThreadPageThreadDataEvent(
- ThreadPageThreadDataEvent.TYPE_LOAD, load, -1, time, tid,
- String.valueOf(load) + ThreadPageLabels.THREAD_CHART_ITEM_PERCENT, -1,
- null);
- pushEvent(event);
-
- }
- }
- // loads = input.getThreadLoad(); // TODO SystemData interface
- // changed.
- // String[] temp = loads.split(",");
- // int tempSize = temp.length;
- // double time;
- // for (int j = 0; j + 1 < tempSize; j += 2) {
- // try {
- // tid = temp[j];
- // } catch (NumberFormatException nfe) {
- // Logger.error("parseLoad - tid parsing");
- // break;
- // }
- // // if (null == findParentData(tid)) {
- // // continue;
- // // }
- //
- // load = (int) (Double.parseDouble(temp[j + 1]));
- // time = Double.parseDouble(Long.toString(input.getTime()))
- // / TimelineConstants.MEGA_DOUBLE;
- // ThreadPageThreadDataEvent event = new ThreadPageThreadDataEvent(
- // ThreadPageThreadDataEvent.TYPE_LOAD, load, -1, time,
- // tid, String.valueOf(load)
- // + ThreadPageLabels.THREAD_CHART_ITEM_PERCENT,
- // -1, null);
- // pushEvent(event);
- // }
- }
- }
-
- private void parsePthread(ThreadData input) {
- long time = input.getTime();
- String pid = Integer.toString(input.getPid());
- String tid = Integer.toString(input.getTid());
- int apiType = input.getApiType();
- String apiName = input.getApiName();
- long errorNum = input.getErrno();
- ThreadPageThreadDataEvent event;
- String pthreadId = Long.toString(input.getPThreadId());
-
- if (errorNum != 0) {
- SummaryDataManager.getInstance().getFailedApiDataMaker().makeData(input);
- }
-
- switch (apiType) {
- case LogCenterConstants.THREAD_API_TYPE_NEW:
- case LogCenterConstants.THREAD_API_TYPE_STOP:
- case LogCenterConstants.THREAD_API_TYPE_EXIT:
- case LogCenterConstants.THREAD_API_TYPE_WAIT_START:
- case LogCenterConstants.THREAD_API_TYPE_OTHER:
- if (apiName.equals(ThreadPageLabels.THREAD_API_PTHREAD_ATTR_INIT)) {
- threadAttrMap.put(input.getArgs(), PTHREAD_CREATE_JOINABLE);
- } else if (apiName.equals(ThreadPageLabels.THREAD_API_PTHREAD_ATTR_SETDETACHSTATE)) {
- checkThreadAttrType(input.getArgs());
- }
-
- event = new ThreadPageThreadDataEvent(ThreadPageThreadDataEvent.TYPE_API,
- LogCenterConstants.THREAD_TYPE_PTHREAD, apiType, time, tid, apiName, errorNum,
- input);
- pushEvent(event);
- break;
- case LogCenterConstants.THREAD_API_TYPE_START:
- if (apiName.equals(ThreadPageLabels.THREAD_API_PTHREAD_CREATE)) {
- checkThreadType(input.getArgs(), pthreadId);
- checkThreadFunc(input.getArgs(), pthreadId);
- }
- event = new ThreadPageThreadDataEvent(ThreadPageThreadDataEvent.TYPE_API,
- LogCenterConstants.THREAD_TYPE_PTHREAD, apiType, time, tid, apiName, errorNum,
- input);
- event.setCallID(pthreadId);
-
- pushEvent(event);
- pushCallEvent(event);
- break;
- case LogCenterConstants.THREAD_API_TYPE_WAIT_END:
- event = new ThreadPageThreadDataEvent(ThreadPageThreadDataEvent.TYPE_EVENT,
- LogCenterConstants.THREAD_TYPE_PTHREAD, apiType, time, tid, apiName, errorNum,
- input);
- pushEvent(event);
- if (input.getApiName().equals(ThreadPageLabels.THREAD_API_PTHREAD_JOIN)) {
- // join, delete warning
- SummaryDataManager.getInstance().getWarningDataMaker()
- .removeData(event.getContents(),
- ThreadPageLabels.THREAD_CHART_NAME_TID + findCallerTid(pthreadId),
- WarningCase.JOINABLE_LEAK.getType());
- // AnalyzerManager.getWarningChecker().removeData(
- // ThreadPageLabels.THREAD_CHART_NAME_TID
- // + (Long.toString(input
- // .getOspThreadId())),
- // WarningCase.JOINABLE_LEAK.getType());
- }
- break;
- case LogCenterConstants.THREAD_API_TYPE_INTERNAL_STOP:
- event = new ThreadPageThreadDataEvent(ThreadPageThreadDataEvent.TYPE_EVENT,
- LogCenterConstants.THREAD_TYPE_PTHREAD, apiType, time, tid,
- ThreadPageLabels.THREAD_CHART_ITEM_EXITED, errorNum, input);
- event.setCallID(pthreadId);
- pushEvent(event);
- pushCallEvent(event);
-
- if (true == isJoinableThread(tid)) {
- // warningData
- // WarningData wData = new WarningData(
- // WarningCase.JOINABLE_LEAK.getType(), input,
- // ThreadPageLabels.THREAD_CHART_NAME_TID + tid);
- // AnalyzerManager.getWarningChecker().getWarningData().add(wData);
- SummaryDataManager
- .getInstance()
- .getWarningDataMaker()
- .add(input, ThreadPageLabels.THREAD_CHART_NAME_TID + tid,
- WarningCase.JOINABLE_LEAK.getType());
- }
- // FIXME add code for remove waning case
- break;
- case LogCenterConstants.THREAD_API_TYPE_INTERNAL_START:
- Integer threadAttrTypeInt = threadAttrMap.get(pthreadId);
- String threadAttrType;
- int funcID;
-
- if (null != threadAttrTypeInt) {
- threadAttrType = getAttrTypeByTypeInt(threadAttrTypeInt);
- } else {
- threadAttrType = ThreadPageLabels.THREAD_ATTR_TYPE_JOINABLE;
- }
- // get thread function id for this pthread
- funcID = SymbolManager.getFuncId(null, threadFuncMap.get(pthreadId), input.getPid(),
- input.getTime());
-
- ThreadPageThreadData data = new ThreadPageThreadData(ThreadPageThreadData.TYPE_PTHREAD,
- pid, tid, threadAttrType, funcID);
- pushRow(data);
- event = new ThreadPageThreadDataEvent(ThreadPageThreadDataEvent.TYPE_EVENT,
- LogCenterConstants.THREAD_TYPE_PTHREAD, apiType, time, tid,
- ThreadPageLabels.THREAD_CHART_ITEM_CREATED, errorNum, input);
- pushEvent(event);
- break;
- default:
- Logger.error("thread page err: unknown thread api type");
- }
- }
-
- private void parseTIZEN(ThreadData input) {
- long time = input.getTime();
- String pid = Integer.toString(input.getPid());
- String tid = Integer.toString(input.getTid());
- int apiType = input.getApiType();
- String apiName = input.getApiName();
- String callID = Long.toString(input.getOspThreadId());
- String className = null;
- ThreadPageThreadData data;
- ThreadPageThreadDataEvent event;
- long errorNum = input.getErrno();
-
- if (errorNum != 0) {
- SummaryDataManager.getInstance().getFailedApiDataMaker().makeData(input);
- }
-
- switch (apiType) {
- case LogCenterConstants.THREAD_API_TYPE_NEW:
- case LogCenterConstants.THREAD_API_TYPE_STOP:
- case LogCenterConstants.THREAD_API_TYPE_EXIT:
- case LogCenterConstants.THREAD_API_TYPE_WAIT_START:
- case LogCenterConstants.THREAD_API_TYPE_OTHER:
- event = new ThreadPageThreadDataEvent(ThreadPageThreadDataEvent.TYPE_API,
- LogCenterConstants.THREAD_TYPE_TIZEN, apiType, time, tid, apiName, errorNum,
- input);
- pushEvent(event);
- break;
- case LogCenterConstants.THREAD_API_TYPE_START:
- event = new ThreadPageThreadDataEvent(ThreadPageThreadDataEvent.TYPE_API,
- LogCenterConstants.THREAD_TYPE_TIZEN, apiType, time, tid, apiName, errorNum,
- input);
-
- event.setCallID(callID);
- data = findCallQueue(callID);
- if (null != data) {
- data.setThreadClassName(input.getClassName());
- pushRow(data);
- }
- pushEvent(event);
- pushCallEvent(event);
- break;
- case LogCenterConstants.THREAD_API_TYPE_WAIT_END:
- if (input.getApiName().equals(ThreadPageLabels.THREAD_API_TIZEN_JOIN)) {
- event = new ThreadPageThreadDataEvent(ThreadPageThreadDataEvent.TYPE_EVENT,
- LogCenterConstants.THREAD_TYPE_TIZEN, apiType, time, tid, apiName,
- errorNum, input);
- pushEvent(event);
- // join, delete warning
- // AnalyzerManager.getWarningChecker().removeData(
- // ThreadPageLabels.THREAD_CHART_NAME_TID
- // + findCallerTid(Long.toString(input
- // .getOspThreadId())),
- // WarningCase.JOINABLE_LEAK.getType());
- SummaryDataManager
- .getInstance()
- .getWarningDataMaker()
- .removeData(event.getContents(),
- ThreadPageLabels.THREAD_CHART_NAME_TID + findCallerTid(callID),
- WarningCase.JOINABLE_LEAK.getType());
- } // FIXME : do not shows sleep's wait end
-
- break;
- case LogCenterConstants.THREAD_API_TYPE_INTERNAL_STOP:
- event = new ThreadPageThreadDataEvent(ThreadPageThreadDataEvent.TYPE_EVENT,
- LogCenterConstants.THREAD_TYPE_TIZEN, apiType, time, tid,
- ThreadPageLabels.THREAD_CHART_ITEM_EXITED, errorNum, input);
- event.setCallID(Long.toString(input.getOspThreadId()));
- pushEvent(event);
- pushCallEvent(event);
- if (true == isJoinableThread(tid)) {
- // warningData
- // WarningData wData = new WarningData(
- // WarningCase.JOINABLE_LEAK.getType(),
- // event.getContents(),
- // ThreadPageLabels.THREAD_CHART_NAME_TID + tid);
- // AnalyzerManager.getWarningChecker().getWarningData().add(wData);
- SummaryDataManager
- .getInstance()
- .getWarningDataMaker()
- .add(event.getContents(), ThreadPageLabels.THREAD_CHART_NAME_TID + tid,
- WarningCase.JOINABLE_LEAK.getType());
- }
- break;
- case LogCenterConstants.THREAD_API_TYPE_INTERNAL_START:
- data = new ThreadPageThreadData(ThreadPageThreadData.TYPE_TIZEN, pid, tid,
- ThreadPageLabels.THREAD_ATTR_TYPE_JOINABLE, -1);
- // TIZEN thread includes the internal thread
- if ((className = checkCalledThread(callID)) != null) {
- data.setThreadClassName(className);
- pushRow(data);
- } else {
- pushCallRow(data);
- }
- event = new ThreadPageThreadDataEvent(ThreadPageThreadDataEvent.TYPE_EVENT,
- LogCenterConstants.THREAD_TYPE_TIZEN, apiType, time, tid,
- ThreadPageLabels.THREAD_CHART_ITEM_CREATED, errorNum, input);
- pushEvent(event);
- break;
- default:
- Logger.error("thread page err: unknown thread api type");
- }
- }
-
- public void parseAPI(LogData input) {
- if (null == input) {
- return;
- }
-
- if (!(input instanceof ThreadData)) {
- return;
- }
- ThreadData log = (ThreadData) input;
- // System.out.println("input : " + input);
- int threadType = log.getThreadType();
-
- switch (threadType) {
- case LogCenterConstants.THREAD_TYPE_PTHREAD:
- parsePthread(log);
- break;
- case LogCenterConstants.THREAD_TYPE_TIZEN:
- parseTIZEN(log);
- break;
- default:
- Logger.error("thread page err: unknown thread type");
-
- }
- hasUpdate = true;
- }
-
- private void parseAPI(LogPackage logPack) {
- List<LogData> inputs = getLogsFromLogPackage(logPack, DataChannelConstants.MSG_PROBE_THREAD);
- int size;
- if (null == inputs || 0 == (size = inputs.size())) {
- return;
- }
- ThreadData input;
- for (int i = 0; i < size; i++) {
- input = (ThreadData) inputs.get(i);
- // System.out.println("input : " + input);
- int threadType = input.getThreadType();
-
- switch (threadType) {
- case LogCenterConstants.THREAD_TYPE_PTHREAD:
- parsePthread(input);
- break;
- case LogCenterConstants.THREAD_TYPE_TIZEN:
- parseTIZEN(input);
- break;
- default:
- Logger.error("thread page err: unknown thread type");
- }
- }
- }
-
- public void parseSync(LogData input) {
- if (null == input || !(input instanceof SyncData)) {
- return;
- }
- SyncData syncData = (SyncData) input;
- long time = input.getTime();
- String tid = Integer.toString(syncData.getTid());
-
- // FIXME
- int type = syncData.getSyncType();
- int apiType = syncData.getApiType();
- String apiName = syncData.getApiName();
-
- String name = Long.toString(syncData.getSyncValue());
- long errorNum = syncData.getErrno();
- ThreadPageSyncDataEvent event;
- switch (type) {
- case LogCenterConstants.SYNC_TYPE_TIZEN_MUTEX:
- case LogCenterConstants.SYNC_TYPE_TIZEN_MONITOR:
- case LogCenterConstants.SYNC_TYPE_TIZEN_SEMAPHORE:
- event = new ThreadPageSyncDataEvent(name, type, apiType, time, tid, apiName, errorNum,
- input);
- pushSyncEvent(event);
- // parseTIZENSync(input, type);
- break;
- case LogCenterConstants.SYNC_TYPE_PTHREAD_MUTEX:
- case LogCenterConstants.SYNC_TYPE_PTHREAD_COND_VARIABLE:
- if (apiName.equals(ThreadPageLabels.SYNC_API_PTHREAD_MUTEXATTR_INIT)) {
- syncAttrMap.put(syncData.getArgs(), ThreadPageSyncDataManager.PTHREAD_MUTEX_NORMAL);
- } else if (apiName.equals(ThreadPageLabels.SYNC_API_PTHREAD_MUTEXATTR_SETTYPE)) {
- checkMutexAttrType(syncData.getArgs());
- } else {
- if (apiName.equals(ThreadPageLabels.SYNC_API_PTHREAD_MUTEX_INIT)) {
- checkMutexType(syncData.getArgs());
- }
- event = new ThreadPageSyncDataEvent(name, type, apiType, time, tid, apiName,
- errorNum, input);
- pushSyncEvent(event);
- }
- break;
- case LogCenterConstants.SYNC_TYPE_PTHREAD_RWLOCK:
- case LogCenterConstants.SYNC_TYPE_PTHREAD_SPINLOCK:
- case LogCenterConstants.SYNC_TYPE_PTHREAD_BARRIER:
- event = new ThreadPageSyncDataEvent(name, type, apiType, time, tid, apiName, errorNum,
- input);
- pushSyncEvent(event);
- Logger.error("error : sync parse - type = " + type);
- break;
- default:
- Logger.error("error : sync parse unknown - type = " + type);
- }
- hasUpdate = true;
- }
-
- private void parseSync(LogPackage logPack) {
- List<LogData> inputs = getLogsFromLogPackage(logPack, DataChannelConstants.MSG_PROBE_SYNC);
- int size;
- if (null == inputs || 0 == (size = inputs.size())) {
- return;
- }
- SyncData input;
- for (int i = 0; i < size; i++) {
- input = (SyncData) inputs.get(i);
- long time = input.getTime();
- String tid = Integer.toString(input.getTid());
-
- // FIXME
- int type = input.getSyncType();
- int apiType = input.getApiType();
- String apiName = input.getApiName();
-
- String name = Long.toString(input.getSyncValue());
- long errorNum = input.getErrno();
- ThreadPageSyncDataEvent event;
- switch (type) {
- case LogCenterConstants.SYNC_TYPE_TIZEN_MUTEX:
- case LogCenterConstants.SYNC_TYPE_TIZEN_MONITOR:
- case LogCenterConstants.SYNC_TYPE_TIZEN_SEMAPHORE:
- event = new ThreadPageSyncDataEvent(name, type, apiType, time, tid, apiName,
- errorNum, input);
- pushSyncEvent(event);
- // parseTIZENSync(input, type);
- break;
- case LogCenterConstants.SYNC_TYPE_PTHREAD_MUTEX:
- case LogCenterConstants.SYNC_TYPE_PTHREAD_COND_VARIABLE:
- if (apiName.equals(ThreadPageLabels.SYNC_API_PTHREAD_MUTEXATTR_INIT)) {
- syncAttrMap
- .put(input.getArgs(), ThreadPageSyncDataManager.PTHREAD_MUTEX_NORMAL);
- } else if (apiName.equals(ThreadPageLabels.SYNC_API_PTHREAD_MUTEXATTR_SETTYPE)) {
- checkMutexAttrType(input.getArgs());
- } else {
- if (apiName.equals(ThreadPageLabels.SYNC_API_PTHREAD_MUTEX_INIT)) {
- checkMutexType(input.getArgs());
- }
- event = new ThreadPageSyncDataEvent(name, type, apiType, time, tid, apiName,
- errorNum, input);
- pushSyncEvent(event);
- }
- break;
- case LogCenterConstants.SYNC_TYPE_PTHREAD_RWLOCK:
- case LogCenterConstants.SYNC_TYPE_PTHREAD_SPINLOCK:
- case LogCenterConstants.SYNC_TYPE_PTHREAD_BARRIER:
- event = new ThreadPageSyncDataEvent(name, type, apiType, time, tid, apiName,
- errorNum, input);
- pushSyncEvent(event);
- Logger.debug("sync parse - type = " + type);
- break;
- default:
- Logger.error("sync parse unknown - type = " + type);
- }
- }
- }
-
- public void parsePageData(LogPackage logPack) {
- parseLoad(logPack);
- parseAPI(logPack);
- parseSync(logPack);
- hasUpdate = true;
- }
-
- // when INTERNAL_START log comes after START log,
- // this method finds matching START log (for TIZEN thread only)
- // return class name from the START log
- private String checkCalledThread(String callId) {
- if (null == callId) {
- return null;
- }
- int callEventQueueSize = callEventQueue.size();
- ThreadPageThreadDataEvent callEvent;
- for (int i = 0; i < callEventQueueSize; i++) {
- callEvent = callEventQueue.get(i);
- if (callEvent.getApiType() != LogCenterConstants.THREAD_API_TYPE_START) {
- continue;
- }
- if (callId.equals(callEvent.getCallID())) {
- ThreadData threadData = (ThreadData) callEvent.getContents();
- return threadData.getClassName();
- }
- }
- return null;
- }
-
- private String getCallEventID(String callID) {
- if (null == callID) {
- return null;
- }
- int eventQueueSize = eventQueue.size();
- ThreadPageThreadDataEvent event;
- for (int i = 0; i < eventQueueSize; i++) {
- event = eventQueue.get(i);
- if (event.getApiType() != LogCenterConstants.THREAD_API_TYPE_INTERNAL_START) {
- continue;
- }
- if (callID.equals(event.getCallID())) {
- return event.getTid();
- }
- }
- return null;
- }
-
- private ThreadPageThreadData findCallQueue(String callID) {
- String tid = getCallEventID(callID);
-
- int size;
- size = callRowsQueue.size();
- ThreadPageThreadData ret;
- for (int i = 0; i < size; i++) {
- ret = callRowsQueue.get(i);
-
- if (ret.getTid().equals(tid)) {
- callRowsQueue.remove(i);
- return ret;
- }
- }
- return null;
- }
-
- private boolean isJoinableThreadFromQueue(List<ThreadPageThreadData> queue, String tid) {
- int size;
- size = queue.size();
- for (int i = 0; i < size; i++) {
- if (true == queue.get(i).getTid().equals(tid)) {
- if (true == queue.get(i).getAttrType()
- .equals(ThreadPageLabels.THREAD_ATTR_TYPE_JOINABLE)) {
- return true;
- }
- }
- }
- return false;
- }
-
- private boolean isJoinableThread(String tid) {
- boolean ret;
-
- ret = isJoinableThreadFromQueue(rows, tid);
- if (ret == false) {
- ret = isJoinableThreadFromQueue(rowsQueue, tid);
- }
- return ret;
- }
-
- private void checkThreadAttrType(String input) {
- String[] temp = input.split(",");
- if (temp.length != 2) {
- return;
- }
- String obj = temp[0];
- String type = temp[1].trim();
-
- if (null != threadAttrMap.get(obj)) {
- threadAttrMap.put(obj, Integer.valueOf(type));
- }
- }
-
- private void checkThreadType(String args, String pthreadId) {
- String[] temp = args.split(",");
- if (temp.length != 4) {
- return;
- }
- String attrObj = temp[1].trim();
-
- Integer attrType = threadAttrMap.get(attrObj);
- if (attrType != null) {
- threadAttrMap.put(pthreadId, attrType);
- }
- }
-
- // extract function address from arguments of thread create function,
- // (e.g. int pthread_create(pthread_t *, const pthread_attr_t *, void
- // *(*)(void *), void *); )
- // put (pthreadId, function address) in the map
- private void checkThreadFunc(String args, String pthreadId) {
- String[] temp = args.split(",");
- if (temp.length != 4) {
- return;
- }
- // 3rd argument is function address
- String strFuncAddr = temp[2].trim();
- Long funcAddr = Long.decode(strFuncAddr);
-
- threadFuncMap.put(pthreadId, funcAddr);
- }
-
- private void checkMutexAttrType(String input) {
- String[] temp = input.split(",");
- if (temp.length != 2) {
- return;
- }
- String obj = temp[0];
- String type = temp[1].trim();
-
- if (null != syncAttrMap.get(obj)) {
- syncAttrMap.put(obj, Integer.valueOf(type));
- }
- }
-
- private void checkMutexType(String input) {
- String[] temp = input.split(",");
- if (temp.length != 2) {
- return;
- }
- String obj = temp[0];
- String attrObj = temp[1].trim();
-
- Integer attrType = syncAttrMap.get(attrObj);
- if (attrType != null) {
- syncAttrMap.put(obj, attrType);
- }
- }
-
- protected DAChartBoard getBoard() {
- return board;
- }
-
- public void setBoard(DAChartBoard board) {
- this.board = board;
- }
-
- private String findCallerTid(String id) {
- int callEventQueueSize = callEventQueue.size();
- ThreadPageThreadDataEvent callEvent;
- for (int i = 0; i < callEventQueueSize; i++) {
- callEvent = callEventQueue.get(i);
- if (callEvent.getApiType() != LogCenterConstants.THREAD_API_TYPE_INTERNAL_STOP) {
- continue;
- }
- String callerTID = callEvent.getCallID();
-
- if (callerTID != null && callerTID.equals(id)) {
- return callEvent.getTid();
- }
- }
- return null;
- }
-
- private boolean checkPairEvent(ThreadPageThreadDataEvent event) {
- if (event.getEventType() != ThreadPageThreadDataEvent.TYPE_EVENT) {
- return true;
- }
- int apiType = event.getApiType();
- int threadType = event.getThreadType();
- ThreadData tData = (ThreadData) event.getContents();
- if (LogCenterConstants.THREAD_API_TYPE_INTERNAL_START == apiType) {
- int callEventQueueSize = callEventQueue.size();
- ThreadPageThreadDataEvent callEvent;
- for (int i = 0; i < callEventQueueSize; i++) {
- callEvent = callEventQueue.get(i);
- if (callEvent.getApiType() != LogCenterConstants.THREAD_API_TYPE_START) {
- continue;
- } else if (callEvent.getThreadType() != threadType) {
- continue;
- } else {
- if (threadType == LogCenterConstants.THREAD_TYPE_TIZEN) {
- String callerTizenID = callEvent.getCallID();
- String eventTizenID = Long.toString(tData.getOspThreadId());
- if (eventTizenID.equals(callerTizenID)) {
- event.setCallerTid(callEvent.getTid());
- callEventQueue.remove(i);
- return true;
- }
- } else {
- String callerPthreadID = callEvent.getCallID();
- String eventPthreadID = Long.toString(tData.getPThreadId());
- if (eventPthreadID.equals(callerPthreadID)) {
- event.setCallerTid(callEvent.getTid());
- callEventQueue.remove(i);
- return true;
- }
- }
- }
- }
- return false;
- } else if (LogCenterConstants.THREAD_API_TYPE_WAIT_END == apiType) {
- if (!event.isJoinAPI()) {
- return true;
- }
-
- int callEventQueueSize = callEventQueue.size();
- ThreadPageThreadDataEvent callEvent;
- for (int i = 0; i < callEventQueueSize; i++) {
- callEvent = callEventQueue.get(i);
- if (callEvent.getApiType() != LogCenterConstants.THREAD_API_TYPE_INTERNAL_STOP) {
- continue;
- } else if (callEvent.getThreadType() != threadType) {
- continue;
- } else {
- if (threadType == LogCenterConstants.THREAD_TYPE_TIZEN) {
- String callerTizenID = callEvent.getCallID();
- String eventTizenID = Long.toString(tData.getOspThreadId());
- if (eventTizenID.equals(callerTizenID)) {
- event.setCallerTid(callEvent.getTid());
- if (null == callEvent.getChartItem()) {
- callEvent.setCallerTid(event.getTid());
- } else {
- // join, delete warning
- SummaryDataManager
- .getInstance()
- .getWarningDataMaker()
- .removeData(
- event.getContents(),
- ThreadPageLabels.THREAD_CHART_NAME_TID
- + callEvent.getTid(),
- WarningCase.JOINABLE_LEAK.getType());
- // AnalyzerManager.getWarningChecker().removeData(
- // ThreadPageLabels.THREAD_CHART_NAME_TID
- // + callEvent.getTid(),
- // WarningCase.JOINABLE_LEAK.getType());
- callEvent.getChartItem().setY(DAChartSeriesItem.SERIES_ARROW_RIGHT);
- callEvent.getChartItem().setBarWidth(
- Double.parseDouble(event.getTid()));
- }
- callEventQueue.remove(i);
- return true;
- }
- } else {
- String callerPthreadID = callEvent.getCallID();
- String eventPthreadID = Long.toString(tData.getPThreadId());
- if (eventPthreadID.equals(callerPthreadID)) {
- event.setCallerTid(callEvent.getTid());
- if (null == callEvent.getChartItem()) {
- callEvent.setCallerTid(event.getTid());
- } else {
- callEvent.getChartItem().setY(DAChartSeriesItem.SERIES_ARROW_RIGHT);
- callEvent.getChartItem().setBarWidth(
- Double.parseDouble(event.getTid()));
- }
- callEventQueue.remove(i);
- return true;
- }
- }
- }
- }
- return false;
- } else {
- return true;
- }
- }
-
- private ThreadPageThreadData findParentData(String tid) {
- int size = rows.size();
- ThreadPageThreadData ret;
- for (int i = 0; i < size; i++) {
- ret = rows.get(i);
- if (ret.getTid().equals(tid)) {
- return ret;
- }
- }
- return null;
- }
-
- private void chartFilteringByPid() {
- if (null == board || null == board.getItemList()) {
- return;
- }
- int selectedPid = ToolbarArea.getInstance().getSelectedPid();
- boolean isCheck = false;
-
- if (eventQueue.size() > 0) {
- isCheck = true;
- }
-
- if (preSelectionPid != -1 && preSelectionPid != selectedPid) {
- isCheck = true;
- }
-
- if (isCheck) {
- int parentSize = board.getItemList().getItemSize();
- for (int i = 0; i < parentSize; i++) {
- DAChartBoardItem parentItem = board.getItemList().get(i);
- /*
- * int childSize = parentItem.getChildItemList().getItemSize(); int hidedCount = 0;
- * for (int j = 0; j < childSize; j++) { DAChartBoardItem childItem =
- * parentItem.getChildItemList() .get(j); int itemPid = getItemPid(childItem); if
- * (itemPid == selectedPid) { parentItem.getChildItemList().showItem(j);
- * board.showItem(i); } else if (selectedPid == 0) {
- * parentItem.getChildItemList().showItem(j); board.showItem(i); } else if (itemPid
- * == -1) { board.showItem(i); } else { parentItem.getChildItemList().hideItem(j);
- * hidedCount++; } } if (childSize == 0) { int itemPid = getItemPid(parentItem); if
- * (itemPid == selectedPid) { board.showItem(i); } else if (selectedPid == 0) {
- * board.showItem(i); } else if (itemPid == -1) { board.showItem(i); } else {
- * board.hideItem(i); hidedCount++; } } else { if (childSize == hidedCount) {
- * board.hideItem(i); } }
- */
- int itemPid = getItemPid(parentItem);
- if (itemPid == selectedPid) {
- board.showItem(i);
- } else if (selectedPid == 0) {
- board.showItem(i);
- } else if (itemPid == -1) {
- board.showItem(i);
- } else {
- board.hideItem(i);
- }
- }
- }
- preSelectionPid = selectedPid;
- }
-
- private int getItemPid(DAChartBoardItem item) {
- int pid = -1;
- if (item.getData() instanceof ThreadPageData) {
- ThreadPageData threadPageData = (ThreadPageData) item.getData();
- pid = Integer.parseInt(threadPageData.getPid());
- }
- return pid;
- }
-
- // TODO: syncDataManager has same method : move this method to proper class
- private int getSortObject(DAChartBoardItem item) {
- Object sortObj = item.getSortObject();
- if (sortObj instanceof Integer) {
- return (Integer) sortObj;
- } else { // should never go here
- return -1;
- }
- }
-
- public void checkUpdate() {
- if (false == hasUpdate && preSelectionPid == ToolbarArea.getInstance().getSelectedPid()) {
- return;
- } else {
- hasUpdate = false;
- }
-
- int size = rowsQueue.size();
- if (size > 0) {
- ThreadPageThreadData data;
- for (int i = 0; i < size; i++) {
- data = rowsQueue.get(0);
- // sort chart items at each insertion
- createBoardItem(data, new Comparator<DAChartBoardItem>() {
- public int compare(DAChartBoardItem item1, DAChartBoardItem item2) {
- return getSortObject(item1) - getSortObject(item2);
- }
- });
- rows.add(data);
- rowsQueue.remove(0);
- }
- }
-
- chartFilteringByPid();
-
- size = eventQueue.size();
- if (size > 0) {
- ThreadPageThreadData data;
- ThreadPageThreadDataEvent event;
- int remainCalleeEventCount = 0;
- for (int i = 0; i < size; i++) {
- event = eventQueue.get(remainCalleeEventCount);
- if (false == checkPairEvent(event)) {
- remainCalleeEventCount++;
- } else {
- data = findParentData(event.getTid());
- if (null != data) {
- data.pushEvent(event);
- event.setThreadDataID(data.getThreadDataID());
- // save to DB
- ThreadEventInserter.pushThreadEvent(event);
- ThreadEventInserter.startThread();
- eventQueue.remove(remainCalleeEventCount);
- } else {
- remainCalleeEventCount++;
- }
- }
- }
- }
-
- /* load ThreadPageSyncData when open trace */
- size = syncQueue.size();
- if (size > 0) {
- ThreadPageThreadData data;
- ThreadPageSyncData sync;
- for (int i = 0; i < size; i++) {
- sync = syncQueue.get(0);
- data = findParentData(sync.getTid());
- if (null != data) {
- createSyncBoardItem(data, sync);
- data.pushSync(sync);
- data.setHasUpdate();
- }
- syncQueue.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);
- String pid = Integer.toString(event.getContents().getPid());
- data = findParentData(event.getTid());
- if (null != data) {
- String syncVal = event.getSyncVal();
- sync = data.findSyncData(syncVal);
- if (null == sync) {
- Integer syncAttrTypeInt = syncAttrMap.get(syncVal);
- String syncAttrType;
- if (null != syncAttrTypeInt) {
- syncAttrType = ThreadPageSyncDataManager
- .getAttrTypeByTypeInt(syncAttrTypeInt);
- } else {
- syncAttrType = ThreadPageSyncDataManager.getAttrTypeString(event);
- }
-
- sync = new ThreadPageSyncData(event.getType(), syncVal, pid,
- event.getTid(), syncAttrType, ThreadPageSyncData.THREAD_CHILD);
- sync.setParentID(data.getThreadDataID());
- // save to DB
- SyncDataInserter.pushSyncData(sync);
- SyncDataInserter.startThread();
- createSyncBoardItem(data, sync);
- data.pushSync(sync);
- }
- sync.pushEvent(event);
- event.setSyncDataID(sync.getSyncDataID());
- // save to DB
- SyncEventInserter.pushSyncEvent(event);
- SyncEventInserter.startThread();
- // save syncAPI to DB
- if (ThreadPageSyncData.isSyncApi(event.getApiType())) {
- SyncAPIInserter.pushSyncEvent((SyncData) event.getContents());
- SyncAPIInserter.startThread();
- }
- data.setHasUpdate();
- }
- syncEventQueue.remove(0);
- }
- }
-
- size = rows.size();
- if (size > 0) {
- ThreadPageThreadData data;
- for (int i = 0; i < size; i++) {
- data = rows.get(i);
- data.checkUpdate();
- }
- }
- }
-
- public int getItemIndexByTid(String tid) {
- int itemSize = rows.size();
- for (int i = 0; i < itemSize; i++) {
- if (rows.get(i).getTid().equals(tid)) {
- return i;
- }
- }
- return -1;
- }
-
- public void clear() {
- rows.clear(); // FIXME : clear chart
- rowsQueue.clear();
- eventQueue.clear();
- callEventQueue.clear();
- threadAttrMap.clear();
- syncAttrMap.clear();
- callRowsQueue.clear();
- syncEventQueue.clear();
- threadFuncMap.clear();
- hasUpdate = false;
- ThreadPageThreadData.clear(); // reset internal seq number
- }
-}
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * yeongtaik byeon <yeongtaik.byeon@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+package org.tizen.dynamicanalyzer.ui.thread.type;
+
+public abstract class ThreadPageData {
+ private String pid;
+ private int tid;
+ private int type;
+ private String key;
+ private String attrType;
+
+ public ThreadPageData(int type, String name, String pid, int tid, String attrType) {
+ setType(type);
+ setKey(name);
+ setPid(pid);
+ setTid(tid);
+ setAttrType(attrType);
+ }
+
+ public int getTid() {
+ return tid;
+ }
+
+ public void setTid(int tid) {
+ this.tid = tid;
+ }
+
+ public String getPid() {
+ return pid;
+ }
+
+ public void setPid(String pid) {
+ this.pid = pid;
+ }
+
+ public int getType() {
+ return type;
+ }
+
+ public void setType(int type) {
+ this.type = type;
+ }
+
+ public String getKey() {
+ return key;
+ }
+
+ public void setKey(String name) {
+ this.key = name;
+ }
+
+ public String getAttrType() {
+ return attrType;
+ }
+
+ public void setAttrType(String attrType) {
+ this.attrType = attrType;
+ }
+
+}
\ No newline at end of file
* - S-Core Co., Ltd
*
*/
-package org.tizen.dynamicanalyzer.ui.thread;
+package org.tizen.dynamicanalyzer.ui.thread.type;
import org.tizen.dynamicanalyzer.swap.model.data.LogData;
import org.tizen.dynamicanalyzer.utils.Formatter;
public abstract class ThreadPageDataEvent implements Cloneable {
private LogData contents;
private long time = -1;
- private String tid = null;
+ private int tid = -1;
private int apiType = -1;
private String tooltip = null;
private long errorNum = -1;
- public ThreadPageDataEvent(long time, String tid, int apiType,
- String tooltip, long errorNum, LogData contents) {
+ public ThreadPageDataEvent(long time, int tid, int apiType, String tooltip, long errorNum,
+ LogData contents) {
setTime(time);
setTid(tid);
setApiType(apiType);
setErrorNum(errorNum);
setContents(contents);
}
-
+
public ThreadPageDataEvent clone() throws CloneNotSupportedException {
ThreadPageDataEvent dataEvent = (ThreadPageDataEvent) super.clone();
dataEvent.setContents(contents);
dataEvent.setApiType(apiType);
dataEvent.setTooltipContent(tooltip);
dataEvent.setErrorNum(errorNum);
-
+
return dataEvent;
}
public long getTime() {
return time;
- }
+ }
public void setTime(long time) {
this.time = time;
}
-
+
public double getDoubleTime() {
double dTime = Formatter.longTimeToDoubleTime(time);
return dTime;
}
- public String getTid() {
+ public int getTid() {
return tid;
}
- public void setTid(String tid) {
+ public void setTid(int tid) {
this.tid = tid;
}
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Hyunjong Park <phjwithyou.park@samsung.com>
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * yeongtaik byeon <yeongtaik.byeon@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+package org.tizen.dynamicanalyzer.ui.thread.type;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.tizen.dynamicanalyzer.constant.CommonConstants;
+import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
+import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;
+import org.tizen.dynamicanalyzer.util.Logger;
+
+public class ThreadPageSyncData extends ThreadPageData {
+ private List<ThreadPageSyncData> children = new ArrayList<ThreadPageSyncData>();
+
+ public static final byte SYNC_PARENT = 0;
+ public static final byte SYNC_CHILD = 1;
+ public static final byte THREAD_CHILD = 2;
+
+ private static int internalSeq = 0;
+ private int syncDataID = -1;
+ private byte syncDataType = -1;
+ private int parentID = -1;
+
+ public ThreadPageSyncData(int type, String name, String pid, int tid, String attrType,
+ byte syncDataType) {
+ super(type, name, pid, tid, attrType);
+ this.syncDataType = syncDataType;
+ syncDataID = internalSeq++;
+ }
+
+ public ThreadPageSyncData(int id, int pid, int tid, int type, long syncValue, String attrType,
+ byte syncDataType, int parentID) {
+ super(type, String.valueOf(syncValue), String.valueOf(pid), tid, attrType);
+ this.syncDataID = id;
+ this.syncDataType = syncDataType;
+ this.parentID = parentID;
+ }
+
+ public void pushSync(ThreadPageSyncData sync) {
+ children.add(sync);
+ }
+
+ public ThreadPageSyncData findChildData(int tId) {
+ int size = children.size();
+ ThreadPageSyncData ret;
+ for (int i = 0; i < size; i++) {
+ ret = children.get(i);
+ if (ret.getTid() == tId) {
+ return ret;
+ }
+ }
+ return null;
+ }
+
+ public List<ThreadPageSyncData> getChildren() {
+ return children;
+ }
+
+ public static boolean isSyncApi(int apiType) {
+ if (apiType == LogCenterConstants.SYNC_API_TYPE_ACQUIRE_WAIT_START) {
+ return false;
+ }
+ if (apiType == LogCenterConstants.SYNC_API_TYPE_COND_WAIT_START) {
+ return false;
+ }
+ return true;
+ }
+
+ public String getTypeString() {
+ switch (getType()) {
+ case LogCenterConstants.SYNC_TYPE_TIZEN_MUTEX:
+ return ThreadPageLabels.SYNC_TYPE_TIZEN_MUTEX;
+ case LogCenterConstants.SYNC_TYPE_TIZEN_MONITOR:
+ return ThreadPageLabels.SYNC_TYPE_TIZEN_MONITOR;
+ case LogCenterConstants.SYNC_TYPE_TIZEN_SEMAPHORE:
+ return ThreadPageLabels.SYNC_TYPE_TIZEN_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:
+ Logger.error("unknown sync type!!");
+ return CommonConstants.EMPTY;
+ }
+ }
+
+ public int getSyncDataID() {
+ return syncDataID;
+ }
+
+ public byte getSyncDataType() {
+ return syncDataType;
+ }
+
+ public int getParentID() {
+ return parentID;
+ }
+
+ public void setParentID(int parentID) {
+ this.parentID = parentID;
+ }
+
+ public static void clear() {
+ internalSeq = 0;
+ }
+}
\ No newline at end of file
* Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
*
* Contact:
+ * Hyunjong Park <phjwithyou.park@samsung.com>
* WooJin Jung <woojin2.jung@samsung.com>
* yeongtaik byeon <yeongtaik.byeon@samsung.com>
* Juyoung Kim <j0.kim@samsung.com>
* - S-Core Co., Ltd
*
*/
-package org.tizen.dynamicanalyzer.ui.thread.sync;
+package org.tizen.dynamicanalyzer.ui.thread.type;
import org.tizen.dynamicanalyzer.swap.model.data.LogData;
-import org.tizen.dynamicanalyzer.ui.thread.ThreadPageDataEvent;
public class ThreadPageSyncDataEvent extends ThreadPageDataEvent {
private String syncVal;
private int type = -1;
private int syncDataID = -1;
+ private long blockEndTime = -1;
- public ThreadPageSyncDataEvent(String syncVal, int type, int apiType,
- long time, String tid, String tooltip, long errorNum,
- LogData contents) {
+ public ThreadPageSyncDataEvent(String syncVal, int type, int apiType, long time, int tid,
+ String tooltip, long errorNum, LogData contents) {
super(time, tid, apiType, tooltip, errorNum, contents);
this.syncVal = syncVal;
this.type = type;
}
-
- // using open trace
- public ThreadPageSyncDataEvent(long time, int apiType, String tooltip,
- long errorNum, String syncVal) {
- super(time, null, apiType, tooltip, errorNum, null);
+
+ public ThreadPageSyncDataEvent(long time, int apiType, String tooltip, long errorNum,
+ String syncVal) {
+ super(time, -1, apiType, tooltip, errorNum, null);
this.syncVal = syncVal;
}
-
+
public ThreadPageSyncDataEvent clone() throws CloneNotSupportedException {
ThreadPageSyncDataEvent syncDataEvent = (ThreadPageSyncDataEvent) super.clone();
syncDataEvent.setSyncVal(syncVal);
syncDataEvent.setType(type);
syncDataEvent.setSyncDataID(syncDataID);
-
return syncDataEvent;
}
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;
}
-
+
public int getSyncDataID() {
return syncDataID;
}
-
+
public void setSyncDataID(int syncDataID) {
this.syncDataID = syncDataID;
}
+
+ public long getBlockEndTime() {
+ return blockEndTime;
+ }
+
+ public void setBlockEndTime(long blockEndTime) {
+ this.blockEndTime = blockEndTime;
+ }
}
\ No newline at end of file
--- /dev/null
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Hyunjong Park <phjwithyou.park@samsung.com>
+ * WooJin Jung <woojin2.jung@samsung.com>
+ * yeongtaik byeon <yeongtaik.byeon@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+package org.tizen.dynamicanalyzer.ui.thread.type;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.tizen.dynamicanalyzer.common.Global;
+import org.tizen.dynamicanalyzer.constant.CommonConstants;
+import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;
+import org.tizen.dynamicanalyzer.util.Logger;
+import org.tizen.dynamicanalyzer.utils.Formatter;
+
+public class ThreadPageThreadData extends ThreadPageData {
+ private List<ThreadPageSyncData> syncs = new ArrayList<ThreadPageSyncData>();
+ private long StartTime = -1;
+ private long EndTime = -1;
+ private int threadFuncID;
+ private String threadClassName = CommonConstants.EMPTY;
+
+ public static final byte TYPE_MAIN = 0;
+ public static final byte TYPE_PTHREAD = 1;
+ public static final byte TYPE_TIZEN = 2;
+
+ private static int internalSeq = 0;
+ private int threadDataID = -1;
+
+ public ThreadPageThreadData(int type, String pid, int tid, String attrType, int funcID) {
+ super(type, String.valueOf(tid), pid, tid, attrType);
+ this.threadFuncID = funcID;
+ threadDataID = internalSeq++;
+ }
+
+ public ThreadPageThreadData(int id, int pid, int tid, int threadType, String attrType,
+ long startTime, long endTime, int functionID, String className) {
+ super(threadType, String.valueOf(tid), String.valueOf(pid), tid, attrType);
+ this.threadDataID = id;
+ this.threadFuncID = functionID;
+ this.StartTime = startTime;
+ this.EndTime = endTime;
+ this.threadClassName = className;
+ }
+
+ public int getThreadFuncID() {
+ return threadFuncID;
+ }
+
+ public String getThreadFuncName() {
+ if (threadFuncID == -1) {
+ return CommonConstants.EMPTY;
+ } else {
+ return Global.getFunctionName(threadFuncID);
+ }
+ }
+
+ public String getThreadClassName() {
+ return threadClassName;
+ }
+
+ public void setThreadClassName(String className) {
+ threadClassName = className;
+ }
+
+ public void pushSync(ThreadPageSyncData sync) {
+ syncs.add(sync);
+ }
+
+ public ThreadPageSyncData findSyncData(String syncVal) {
+ int size = syncs.size();
+ ThreadPageSyncData sync;
+ for (int i = 0; i < size; i++) {
+ sync = syncs.get(i);
+ if (sync.getKey().equals(syncVal)) {
+ return sync;
+ }
+ }
+ return null;
+ }
+
+ public String getTypeString() {
+ switch (getType()) {
+ case TYPE_MAIN:
+ return ThreadPageLabels.THREAD_ITEM_TYPE_MAIN;
+ case TYPE_PTHREAD:
+ return ThreadPageLabels.THREAD_ITEM_TYPE_PTHREAD;
+ case TYPE_TIZEN:
+ return ThreadPageLabels.THREAD_ITEM_TYPE_TIZEN;
+ default:
+ Logger.error("unknown thread type!!");
+ return CommonConstants.EMPTY;
+ }
+ }
+
+ public long getStartTime() {
+ return StartTime;
+ }
+
+ public void setStartTime(long startTime) {
+ StartTime = startTime;
+ }
+
+ public String getStartTimeString() {
+ if (StartTime == -1) {
+ return null;
+ } else {
+ double startTime = Formatter.longTimeToDoubleTime(StartTime);
+ return String.valueOf(startTime);
+ }
+ }
+
+ public long getEndTime() {
+ return EndTime;
+ }
+
+ public void setEndTime(long endTime) {
+ EndTime = endTime;
+ }
+
+ public String getEndTimeString() {
+ if (EndTime == -1) {
+ return null;
+ } else {
+ double endTime = Formatter.longTimeToDoubleTime(EndTime);
+ return String.valueOf(endTime);
+ }
+ }
+
+ public int getThreadDataID() {
+ return threadDataID;
+ }
+
+ public static void clear() {
+ internalSeq = 0;
+ }
+}
\ No newline at end of file
* Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
*
* Contact:
+ * Hyunjong Park <phjwithyou.park@samsung.com>
* WooJin Jung <woojin2.jung@samsung.com>
* yeongtaik byeon <yeongtaik.byeon@samsung.com>
* Juyoung Kim <j0.kim@samsung.com>
* - S-Core Co., Ltd
*
*/
-package org.tizen.dynamicanalyzer.ui.thread.thread;
+package org.tizen.dynamicanalyzer.ui.thread.type;
import java.util.ArrayList;
import java.util.Arrays;
import org.tizen.dynamicanalyzer.nl.ThreadPageLabels;
import org.tizen.dynamicanalyzer.swap.model.data.LogData;
-import org.tizen.dynamicanalyzer.ui.thread.ThreadPageDataEvent;
-import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeriesItem;
public class ThreadPageThreadDataEvent extends ThreadPageDataEvent {
public static final int TYPE_API = 0;
public static final int TYPE_LOAD = 2;
private int eventType = -1;
private int threadType = -1;
- private DAChartSeriesItem chartItem;
private String callID = null;
- private String callerTid = null;
+ private int callerTid = -1;
private int threadDataID = -1;
ArrayList<String> joinAPIs = new ArrayList<String>(Arrays.asList(
ThreadPageLabels.THREAD_API_TIZEN_JOIN));
public ThreadPageThreadDataEvent(int eventType, int threadType,
- int apiType, long time, String tid, String tooltip, long errorNum,
+ int apiType, long time, int tid, String tooltip, long errorNum,
LogData contents) {
super(time, tid, apiType, tooltip, errorNum, contents);
setEventType(eventType);
this.eventType = eventType;
}
- public DAChartSeriesItem getChartItem() {
- return chartItem;
- }
-
- public void setChartItem(DAChartSeriesItem chartItem) {
- this.chartItem = chartItem;
- }
-
public int getThreadType() {
return threadType;
}
this.callID = callID;
}
- public String getCallerTid() {
+ public int getCallerTid() {
return callerTid;
}
- public void setCallerTid(String callerTid) {
+ public void setCallerTid(int callerTid) {
this.callerTid = callerTid;
}
public static final String SELECT_QUERY =
"select " + SELECT_COLUMN + " from " + TABLENAME +
" where " + COLUMN.STARTTIME.name + " >= %s and " + COLUMN.STARTTIME.name + " <= %s";
+ // to make callstack for sample, probe
+ public static final String USERCALLSTACK_QUERY =
+ "select " + COLUMN.SEQ.name + " from " + TABLENAME +
+ " where " + COLUMN.STARTTIME.name + " = (select max( " + COLUMN.STARTTIME.name +
+ ") from " + TABLENAME + " where " + COLUMN.STARTTIME.name + " <= %s )";
public enum COLUMN {
SEQ(0, "SEQNUMBER"),
CommonConstants.COMMA + FunctionEntryDBTable.TABLENAME + " where " +
COLUMN.ENTRYSEQ.name + CommonConstants.EQUAL + FunctionEntryDBTable.COLUMN.SEQ.name +
" and " + COLUMN.ENDTIME.name + " >= %s and " + COLUMN.ENDTIME.name + " <= %s";
+ // to make callstack for sample, probe
+ public static final String USERCALLSTACK_QUERY =
+ "select " + COLUMN.EXITSEQ.name + " from " + TABLENAME +
+ " where " + COLUMN.ENDTIME.name + " = (select max( " + COLUMN.ENDTIME.name +
+ ") from " + TABLENAME + " where " + COLUMN.ENDTIME.name + " <= %s )";
public enum COLUMN {
ENTRYSEQ(0, "EntrySEQNUMBER"),
import java.io.File;
import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
import org.eclipse.swt.SWTException;
import org.eclipse.swt.graphics.Image;
public static ScreenshotChart instance = null;
private DAChartSeries screenshotSeries;
-
+ private Map<String, Image> imageMap = new ConcurrentHashMap<String, Image>();
+
public static ScreenshotChart getInstance() {
if (instance == null) {
instance = new ScreenshotChart();
public DAChart getChart() {
return chart;
}
-
+
@Override
public void inputChartSeries(List<Object> dataList) {
screenshotSeries.clear();
/ TimelineConstants.MEGA_DOUBLE;
String fileName = (String)row.get(ScreenShotDBTable.COLUMN.IMAGE_FILE_PATH.ordinal());
int orientation = (Integer)row.get(ScreenShotDBTable.COLUMN.IMAGE_ORIENTATION.ordinal());
- if (Global.getProject() == null) {
- return;
- }
- String imagePath = Global.getProject().getSavePath()
- + File.separator + AnalyzerConstants.IMAGE_FOLDER_NAME
- + File.separator
- + AnalyzerConstants.SMALL_IMAGE_FOLDER_NAME
- + File.separator
- + fileName;
- int yPostion;
- if (orientation == 0 || orientation == 180) { //$NON-NLS-1$ //$NON-NLS-2$
- yPostion = 10;
- } else {
- yPostion = 23;
- }
-
- Thread createImageThread = new Thread(null, new CreateImageThread(
- imagePath, time, yPostion), "small image getter thread");
- createImageThread.start();
+ if (Global.getProject() == null) {
+ return;
+ }
+ String imagePath = Global.getProject().getSavePath()
+ + File.separator + AnalyzerConstants.IMAGE_FOLDER_NAME
+ + File.separator
+ + AnalyzerConstants.SMALL_IMAGE_FOLDER_NAME
+ + File.separator
+ + fileName;
+ int yPosition;
+ if (orientation == 0 || orientation == 180) { //$NON-NLS-1$ //$NON-NLS-2$
+ yPosition = 10;
+ } else {
+ yPosition = 23;
+ }
+
+ /*
+ * 1 image need 1 thread.
+ */
+ if (imageMap.containsKey(imagePath)) {
+ Image image = imageMap.get(imagePath);
+ screenshotSeries.addSeriesItem(new DAChartSeriesItem(time,
+ yPosition, image));
+ } else {
+ Thread createImageThread = new Thread(null, new CreateImageThread(
+ imagePath, time, yPosition), "small image getter thread");
+ createImageThread.start();
+ }
}
} catch (NumberFormatException ne) {
- ne.printStackTrace();
- }
+ ne.printStackTrace();
+ }
+ }
+
+ @Override
+ public void clear() {
+ super.clear();
+ imageMap.clear();
}
private class CreateImageThread extends Thread {
public void run() {
Image image = null;
int count = 0;
-
while (true && count < 5) {
try {
image = new Image(Display.getDefault(), imagePath);
+ imageMap.put(imagePath, image);
break;
} catch (SWTException se) {
count++;
screenshotSeries.addSeriesItem(new DAChartSeriesItem(time,
yPosition, image));
} else {
+ imageMap.put(imagePath, ImageResources.NO_IMAGE_SMALL);
screenshotSeries.addSeriesItem(new DAChartSeriesItem(time,
yPosition, ImageResources.NO_IMAGE_SMALL));
}
private static UIEventChart instance = null;
private DAChartSeries touchEventSeries;
- private DAChartSeries gestureEventSeries;
+ /*
+ * TODO code about Gesture is commented. it will be reopen when it implemented.
+ */
+// private DAChartSeries gestureEventSeries;
private DAChartSeries orientationEventSeries;
private static final int TYPE_TOUCH = 2;
TimelineChartLabels.UI_EVENT_CHART_SERIES_NAME_TOUCH,
DAChartSeries.SERIES_STYLE_MULTI_CHECK_BAR,
ColorResources.SERIES_COLOR_UI_EVENT_TOUCH);
- gestureEventSeries = new DAChartSeries(
- TimelineChartLabels.UI_EVENT_CHART_SERIES_NAME_GESTURE,
- DAChartSeries.SERIES_STYLE_MULTI_CHECK_BAR,
- ColorResources.SERIES_COLOR_UI_EVENT_GESTURE);
+// gestureEventSeries = new DAChartSeries(
+// TimelineChartLabels.UI_EVENT_CHART_SERIES_NAME_GESTURE,
+// DAChartSeries.SERIES_STYLE_MULTI_CHECK_BAR,
+// ColorResources.SERIES_COLOR_UI_EVENT_GESTURE);
orientationEventSeries = new DAChartSeries(
TimelineChartLabels.UI_EVENT_CHART_SERIES_NAME_ORIENTATION,
DAChartSeries.SERIES_STYLE_MULTI_CHECK_BAR,
ColorResources.SERIES_COLOR_UI_EVENT_ORIENTATION);
touchEventSeries.setFont(FontResources.TIMELINE_UIEVENT_FONT);
- gestureEventSeries.setFont(FontResources.TIMELINE_UIEVENT_FONT);
+// gestureEventSeries.setFont(FontResources.TIMELINE_UIEVENT_FONT);
orientationEventSeries.setFont(FontResources.TIMELINE_UIEVENT_FONT);
}
item.useExpand(false);
chart.addSeries(touchEventSeries);
- chart.addSeries(gestureEventSeries);
+// chart.addSeries(gestureEventSeries);
chart.addSeries(orientationEventSeries);
setChartStyle();
@Override
public void inputChartSeries(List<Object> dataList) {
touchEventSeries.clear();
- gestureEventSeries.clear();
+// gestureEventSeries.clear();
orientationEventSeries.clear();
@SuppressWarnings("unchecked")
touchEventSeries.addSeriesItem(new DAChartSeriesItem(time, 0,
info));
break;
- case TYPE_GESTURE:
- gestureEventSeries.addSeriesItem(new DAChartSeriesItem(time, 0,
- getGestureInfo(detailType, pointX, pointY, info1, info2)));
- break;
+// case TYPE_GESTURE:
+// gestureEventSeries.addSeriesItem(new DAChartSeriesItem(time, 0,
+// getGestureInfo(detailType, pointX, pointY, info1, info2)));
+// break;
case TYPE_ORIENTATION:
orientationEventSeries.addSeriesItem(new DAChartSeriesItem(
time, 0, TimelineChartLabels.UIEVENT_ORIENTATION
import org.tizen.dynamicanalyzer.resources.FontResources;
import org.tizen.dynamicanalyzer.resources.ImageResources;
import org.tizen.dynamicanalyzer.shortcut.ShortCutManager;
+import org.tizen.dynamicanalyzer.ui.common.explorer.DeviceExplorerDialog;
import org.tizen.dynamicanalyzer.ui.page.BaseView;
import org.tizen.dynamicanalyzer.ui.timeline.TimelinePage;
import org.tizen.dynamicanalyzer.ui.toolbar.opentrace.OpenTraceDialog;
import org.tizen.dynamicanalyzer.widgets.da.base.DADialog;
import org.tizen.dynamicanalyzer.widgets.timer.TimerClock;
import org.tizen.sdblib.IDevice;
+import org.tizen.sdblib.service.FileEntry;
public class ToolbarArea {
public static final int START_BUTTON = 0;
private static final int TIMER_WIDTH = 122;
- public static boolean bThreadPageWork = false; // FIXME
- public static boolean bUIPageWork = false; // FIXME
-
public static final int TOOLBAR_STATE_RECORDING = 0;
public static final int TOOLBAR_STATE_READY = 1;
@Override
public void selectionEvent(DACustomCombo combo) {
- String appName = combo.getText();
+ final String appName = combo.getText();
if (null != appName && !appName.isEmpty()) {
boolean enablestart = true;
enablestart = false;
}
} else if (appName.equals(AnalyzerConstants.COMMON_EXECUTABLE_LABEL)) {
- // TODO : implement to select common executable
+ Shell shell = WorkbenchUtil.getWorkbenchWindow().getShell();
+ DeviceExplorerDialog dialog = new DeviceExplorerDialog(shell, false);
+ dialog.setPermissionFilter("111");
+ Object result = dialog.open();
+ if (result != null) {
+ @SuppressWarnings("unchecked")
+ List<FileEntry> files = (List<FileEntry>) result;
+ if (files.size() > 0) {
+ String execpath = files.get(0).getFullPath();
+ selectedPkg.getMainApp().setInfo(AppInfo.PROPERTY.EXEC.index,
+ execpath);
+ } else {
+ enablestart = false;
+ }
+ } else {
+ enablestart = false;
+ }
}
Global.setCurrentApplication(selectedPkg);
}
if (enablestart && null != Global.getCurrentDeviceInfo()) {
- // AnalyzerUtil
- // .setRecordState(RecordStateSourceProvider.RECORD_READY);
AnalyzerManager.setRunningState(false);
- // startButton.setButtonEnabled(true);
setStartButtonState(true);
setRepalyButtonEnable(true);
}
import org.tizen.dynamicanalyzer.swap.platform.ui.InputRow;
import org.tizen.dynamicanalyzer.swap.platform.ui.LoadSettingDialog;
import org.tizen.dynamicanalyzer.swap.platform.ui.SaveSettingDialog;
-import org.tizen.dynamicanalyzer.swap.platform.ui.DeviceExplorer.DeviceExplorerDilaog;
-import org.tizen.dynamicanalyzer.swap.platform.ui.FileExplorer.FileExplorerDialog;
+import org.tizen.dynamicanalyzer.ui.common.explorer.DeviceExplorerDialog;
+import org.tizen.dynamicanalyzer.ui.common.explorer.FileExplorerDialog;
import org.tizen.dynamicanalyzer.ui.toolbar.ConfigureManager;
import org.tizen.dynamicanalyzer.util.CommonUtil;
import org.tizen.dynamicanalyzer.util.Logger;
@Override
public void handleClickEvent(DACustomButton button) {
- DeviceExplorerDilaog dialog = new DeviceExplorerDilaog(getShell());
+ DeviceExplorerDialog dialog = new DeviceExplorerDialog(getShell(), true);
// dialog.setFilter(".so");
Object result = dialog.open();
if (result != null) {
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Shell;
+import org.tizen.dynamicanalyzer.common.Global;
import org.tizen.dynamicanalyzer.communicator.DACommunicator;
import org.tizen.dynamicanalyzer.nl.AnalyzerLabels;
import org.tizen.dynamicanalyzer.nl.ConfigureLabels;
shell.open();
return true;
}
+
+ private void createBinarySettingPage() {
+ DABaseComposite binarySettings = new SettingDialogBinarySettingsPage(
+ tabView.getContentComposite(), SWT.NONE);
+ tabView.addView(binarySettings, false);
+
+
+ // binarySettings tab is selected, the close button will be shown.
+ // ok and cancel button is hidden
+ binarySettings.addListener(SWT.Show, new Listener() {
+
+ @Override
+ public void handleEvent(Event event) {
+ Logger.debug("binary settings show");
+ cancelButton.setText(WidgetLabels.CLOSE);
+ FormData data = (FormData) okButton.getLayoutData();
+ data.width = 0;
+
+ buttonContentsComp.layout();
+ }
+ });
+
+ binarySettings.addListener(SWT.Hide, new Listener() {
+
+ @Override
+ public void handleEvent(Event event) {
+ Logger.debug("binary settings hide");
+ cancelButton.setText(WidgetLabels.CANCEL);
+ FormData data = (FormData) okButton.getLayoutData();
+ data.width = 100;
+
+ buttonContentsComp.layout();
+ }
+ });
+ }
private ShellListener shellListener = new ShellListener() {
import org.tizen.dynamicanalyzer.swap.platform.ui.InputRow;
import org.tizen.dynamicanalyzer.swap.platform.ui.LoadSettingDialog;
import org.tizen.dynamicanalyzer.swap.platform.ui.SaveSettingDialog;
-import org.tizen.dynamicanalyzer.swap.platform.ui.DeviceExplorer.DeviceExplorerDilaog;
-import org.tizen.dynamicanalyzer.swap.platform.ui.FileExplorer.FileExplorerDialog;
+import org.tizen.dynamicanalyzer.ui.common.explorer.DeviceExplorerDialog;
+import org.tizen.dynamicanalyzer.ui.common.explorer.FileExplorerDialog;
import org.tizen.dynamicanalyzer.util.CommonUtil;
import org.tizen.dynamicanalyzer.util.Logger;
import org.tizen.dynamicanalyzer.widgets.button.DACustomButton;
@Override
public void handleClickEvent(DACustomButton button) {
- DeviceExplorerDilaog dialog = new DeviceExplorerDilaog(getShell());
+ DeviceExplorerDialog dialog = new DeviceExplorerDialog(getShell(), true);
// dialog.setFilter(".so");
Object result = dialog.open();
if (result != null) {
return num;
}
- public static void printHexdecimal(long value) {
- String output = String.format("%x", value);
- System.out.print(output);
- }
-
public static String toHexdecimal(Object value) {
String retStr = null;
if (value instanceof Long) {
* 2.1.58
+- Optimize the thread analysis
+- Optimize the function profiling
+- Optimize the file analysis
+- Update the UX of setting dialog
+- Fix Bug : Some apps are not launched
+== JuYoung Kim <j0.kim@samsung.com> 2014-11-03
+* 2.1.58
- Fix Bug : screenshot periodically in Setting Dialog
== Heeyoung Hwang <heeyoung1008.hwang@samsung.com> 2014-10-28
* 2.1.57
Source:dynamic-analyzer
-Version:2.1.58
+Version:2.1.59
Maintainer:Jaewon Lim <jaewon81.lim@samsung.com>, Juyoung Kim <j0.kim@samsung.com>
Package:dynamic-analyzer-product
projects / sdk / tools / dynamic-analyzer.git / commitdiff