public static final String SAVE_DATA_VERSION = "0.86"; //$NON-NLS-1$\r
public static final boolean CHECK_INTERNAL = true;\r
\r
+ public static final String DA_VERSION_SWAP = "3.0";\r
+ public static final String DA_VERSION_OLD = "2.2";\r
+\r
/* folder names */\r
public static final String TOOLS_FOLDER_NAME = "tools"; //$NON-NLS-1$\r
public static final String TARGET_FOLDER_NAME = "target"; //$NON-NLS-1$\r
public static final String TIZEN_FOLDER_USR = "usr"; //$NON-NLS-1$\r
public static final String TIZEN_FOLDER_INCLUDE = "include"; //$NON-NLS-1$\r
public static final String TIZEN_FOLDER_OSP = "osp"; //$NON-NLS-1$\r
+ \r
+ public static final String API_NAME_FILE_NAME = "apis"; //$NON-NLS-1$\r
\r
public static final String DA_DAEMON_NAME = "da_manager"; //$NON-NLS-1$\r
public static final String TOOL_RECORDER_NAME = "da_event"; //$NON-NLS-1$\r
public final static int MSG_SWAP_INST_ACK = 0x1006;\r
public final static int MSG_TARGET_INFO_ACK = 0x1007;\r
public final static int MSG_WAIT_ACK = 0x1010;\r
- \r
- \r
+\r
/*** data channel messages */\r
public final static int MSG_DATA_PROCESS_INFO = 0x2002;\r
public final static int MSG_DATA_TERMINATE = 0x2004;\r
public final static int MSG_DATA_SAMPLE = 0x2006;\r
public final static int MSG_DATA_SYSTEM = 0x2007;\r
public final static int MSG_DATA_RECORD = 0x2009;\r
- public final static int MSG_DATA_FUNCTION_ENTRY = 0x2010;\r
- public final static int MSG_DATA_FUNCTION_EXIT = 0x2011;\r
- public final static int MSG_DATA_CONTEXT_SWITCH_ENTRY = 0x2012;\r
- public final static int MSG_DATA_CONTEXT_SWITCH_EXIT = 0x2013;\r
- \r
+ public final static int MSG_FUNCTION_ENTRY = 0x2010;\r
+ public final static int MSG_FUNCTION_EXIT = 0x2011;\r
+ public final static int MSG_CONTEXT_SWITCH_ENTRY = 0x2012;\r
+ public final static int MSG_CONTEXT_SWITCH_EXIT = 0x2013;\r
+\r
public final static int MSG_PROBE_MEMORY = 0x3001;\r
public final static int MSG_PROBE_UICONTROL = 0x3002;\r
public final static int MSG_PROBE_UIEVENT = 0x3003;\r
public final static int MSG_PROBE_THREAD = 0x3008;\r
public final static int MSG_PROBE_CUSTOM = 0x3009;\r
public final static int MSG_PROBE_SYNC = 0x3010;\r
- \r
- \r
+\r
}\r
public static final String APPLICATION_LIST_PATH = "/opt/share/applications/"; //$NON-NLS-1$
public static final String DA_DAEMON_LOG_PATH = "/tmp/daemonlog.da"; //$NON-NLS-1$
+ public static final String DA_API_MAP_PATH = "/tmp/api_map"; //$NON-NLS-1$
}
public static final String DACOMMAND_RUN_EVENT = "da runevent";
public static final String DACOMMAND_FIND_UNITTEST = "da findunittest";
public static final String DACOMMAND_FIND_IME = "/usr/bin/pkginfo --arg-flt 10 http://tizen.org/category/ime";
- public static final String DACOMMAND_CHECK_VERSION = "/usr/bin/da_command checkversion";
-
+ public static final String DACOMMAND_CHECK_VERSION = "da checkversion";
+
public static final String CMD_IS_ARM_ARCH = "uname -m"; //$NON-NLS-1$
public static final String CMD_CAT_PORT_FILE = "cat /tmp/port.da"; //$NON-NLS-1$
}
package org.tizen.dynamicanalyzer.common;
public enum ErrorCode {
+ SUCCESS(0, "Success"),
+
ERR_LOCKFILE_CREATE_FAILED(-101, "Lock file create failed"),
ERR_ALREADY_RUNNING(-102, "Already running"),
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) {
errNo = num;
message = msg;
private String method;
private final String errMsg;
private final int errNo;
+ private byte[] ret = null;
public static final int ERROR_MSG_INDEX = 0;
public static final int ERROR_LENGTH_INDEX = 1;
System.out.println(result.getMethod());
return result;
}
+
+ public byte[] getRet() {
+ return ret;
+ }
+
+ public void setRet(byte[] ret) {
+ this.ret = ret;
+ }
}
public HostResult sendKeepAliveMessage(DeviceInfo device) {
return HostResult.SUCCESS;
}
-
+
public abstract Socket getDataSocket();
+
+ public abstract void closeSock();
}
public Socket getDataSocket() {
return dataSock;
}
+
+ @Override
+ public void closeSock() {
+ closeSocket();
+ CommunicatorUtils.unfoward(CommunicatorUtils.LOCAL_PORT, remotePort);
+ }
}
import static org.tizen.sdblib.service.SyncServiceConstants.RESULT_OK;
import static org.tizen.sdblib.util.DeviceUtil.isOnline;
+import static org.tizen.sdblib.util.IOUtil.tryClose;
import java.io.File;
+import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import org.tizen.sdblib.exception.TimeoutException;
import org.tizen.sdblib.receiver.MultiLineReceiver;
import org.tizen.sdblib.receiver.NullOutputReceiver;
-import org.tizen.sdblib.service.FileEntry;
import org.tizen.sdblib.service.ISyncProgressMonitor;
import org.tizen.sdblib.service.NullSyncProgressMonitor;
import org.tizen.sdblib.service.SyncResult;
SyncResult result = null;
DeviceInfo currentDevice = DACommunicator.getSelectedDevice();
if (null != currentDevice && isOnline(currentDevice.getIDevice())) {
+ FileOutputStream fileOut = null;
try {
+ fileOut = new FileOutputStream(local);
SyncService service = currentDevice.getIDevice()
.getSyncService();
if (null != service) {
- result = service.pull(new FileEntry[] { currentDevice
- .getIDevice().getFileEntry(remote) }, local,
- monitor);
+ result = service.doPull(currentDevice.getIDevice()
+ .getFileEntry(remote), fileOut, monitor, -1);
}
} catch (TimeoutException e) {
e.printStackTrace();
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
+ } finally {
+ tryClose(fileOut);
}
}
-
return result;
}
- public static Process execCommand(IDevice device, String command) {
+ public static SyncResult pull(IDevice device, String local, String remote) {
+ return pull(device, local, remote,
+ NullSyncProgressMonitor.getInstance());
+ }
+
+ public static SyncResult pull(IDevice device, String remote, String local,
+ ISyncProgressMonitor monitor) {
+ SyncResult result = null;
if (null != device && isOnline(device)) {
+ FileOutputStream fileOut = null;
try {
- return device.executeShellCommand(command, false);
+ fileOut = new FileOutputStream(local);
+ SyncService service = device.getSyncService();
+ if (null != service) {
+ result = service.doPull(device.getFileEntry(remote),
+ fileOut, monitor, -1);
+ }
+ } catch (TimeoutException e) {
+ e.printStackTrace();
+ } catch (SdbCommandRejectedException e) {
+ e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
+ } finally {
+ tryClose(fileOut);
}
}
- return null;
+ return result;
}
public static int getRemotePort(IDevice device) {
}
}
}
-
+
public static void execHostCommand(String command,
IShellOutputReceiver receiver) {
DeviceInfo currentDevice = DACommunicator.getSelectedDevice();
public static Process execCommand(String command) {
DeviceInfo currentDevice = DACommunicator.getSelectedDevice();
+ return execCommand(currentDevice.getIDevice(), command);
+ }
+
+ public static Process execCommand(IDevice device, String command) {
SdbCommand sdbCmd;
- if (null != currentDevice && isOnline(currentDevice.getIDevice())) {
+ if (null != device && isOnline(device)) {
try {
- sdbCmd = new SdbCommand(currentDevice.getIDevice());
+ sdbCmd = new SdbCommand(device);
return sdbCmd.runHostCommand(command, false);
} catch (IOException e) {
e.printStackTrace();
}
}
-
return null;
}
}
package org.tizen.dynamicanalyzer.communicator;
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.DAEMONLOG_COUNT;
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.DAEMONLOG_PREFIX;
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.DA_VERSION_OLD;
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.DA_VERSION_SWAP;
import static org.tizen.sdblib.service.SyncServiceConstants.RESULT_OK;
import static org.tizen.sdblib.util.DeviceUtil.isOnline;
import java.util.List;
import org.eclipse.swt.widgets.Display;
-import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.AnalyzerPaths;
import org.tizen.dynamicanalyzer.common.AnalyzerShellCommands;
import org.tizen.sdblib.SmartDevelopmentBridge;
import org.tizen.sdblib.receiver.MultiLineReceiver;
import org.tizen.sdblib.service.SyncResult;
-import org.tizen.common.sdb.command.SdbCommand;
public class DACommunicator {
public static int MSG_TYPE_CONFIG = 0;
}
String version = currentDevice.getTargetVersion();
- if (version.contains("3.0")) {
+ if (version.contains(DA_VERSION_SWAP)) {
communicator = communicator_30;
- } else if (version.contains("2.1.1")) {
+ } else if (version.contains(DA_VERSION_OLD)) {
communicator = communicator_211;
} else {
result = HostResult.ERR_INVALID_VERSION;
}
private static HostResult readVersion(DeviceInfo info) {
- // checkVersionResult.clear();
- // CommunicatorUtils.execShellCommand(
- // AnalyzerShellCommands.DACOMMAND_CHECK_VERSION,
- // new MultiLineReceiver() {
- // @Override
- // public void processNewLines(String[] appLines) {
- // for (int i = 0; i < appLines.length; i++) {
- // checkVersionResult.add(appLines[i]);
- // }
- // }
- // });
- // if (checkVersionResult.isEmpty()) {
- // return HostResult.ERR_INVALID_VERSION;
- // }
-
- // String version = checkVersionResult.get(0);
- String version = "2.1.1";
HostResult result = null;
- // if (version.contains("3.0") || version.contains("2.1.1")) {
- info.setTargetVersion(version);
- // result = HostResult.SUCCESS;
- // } else {
- // result = HostResult.ERR_INVALID_VERSION;
- // }
+ String version = null;
+ checkVersionResult.clear();
+ CommunicatorUtils.execShellCommand(
+ AnalyzerShellCommands.DACOMMAND_CHECK_VERSION,
+ new MultiLineReceiver() {
+ @Override
+ public void processNewLines(String[] appLines) {
+ for (int i = 0; i < appLines.length; i++) {
+ checkVersionResult.add(appLines[i]);
+ }
+ }
+ });
+ if (checkVersionResult.isEmpty()) {
+// info.setTargetVersion(DA_VERSION_OLD);
+ // return HostResult.ERR_INVALID_VERSION;
+ info.setTargetVersion(DA_VERSION_SWAP);
+ } else {
+ version = checkVersionResult.get(0);
+ if (version.contains(DA_VERSION_SWAP)) {
+ info.setTargetVersion(version);
+ result = HostResult.SUCCESS;
+ } else {
+ info.setTargetVersion(DA_VERSION_OLD);
+ result = HostResult.SUCCESS;
+ // result = HostResult.ERR_INVALID_VERSION;
+ }
+ }
// TODO : fix temp code
result = HostResult.SUCCESS;
- result.setMessage(version);
+ result.setMessage(info.getTargetVersion());
return result;
}
public static void pullDaemonLog() {
final String from = AnalyzerPaths.DA_DAEMON_LOG_PATH;
final String to = PathManager.getLogPath() + File.separator
- + AnalyzerConstants.DAEMONLOG_PREFIX
- + PathManager.getLogPostFix();//$NON-NLS-1$
+ + DAEMONLOG_PREFIX + PathManager.getLogPostFix();//$NON-NLS-1$
SyncResult res = CommunicatorUtils.pull(from, to);
if (null != res && RESULT_OK == res.getCode()) {
System.out.println("daemon log copying success!!");//$NON-NLS-1$
System.out.println("Failed to get " + from); //$NON-NLS-1$
}
- AnalyzerUtil.checkLogs(PathManager.getLogPath(),
- AnalyzerConstants.DAEMONLOG_PREFIX,
- AnalyzerConstants.DAEMONLOG_COUNT);
+ AnalyzerUtil.checkLogs(PathManager.getLogPath(), DAEMONLOG_PREFIX,
+ DAEMONLOG_COUNT);
}
// public static String getLocalhost() {
communicator.clear();
}
+ public static void closeSock()
+ {
+ communicator.closeSock();
+ }
public static HostResult handleControlMessage(String msg) {
return communicator.handleControlMessage(msg);
}
List<String> info = dbInfo.get(0);\r
ProcessInfo process = new ProcessInfo();\r
process.setPid(Integer.parseInt(info.get(0)));\r
- process.setTime(Long.parseLong(info.get(1)));\r
+ process.setStartTime(Long.parseLong(info.get(1)));\r
process.setLowestAddress(Long.parseLong(info.get(2)));\r
process.setHighestAddress(Long.parseLong(info.get(3)));\r
process.setAppType(Integer.parseInt(info.get(4)));\r
DACommunicator.init();
} else {
System.out.println("invalid version");
+ //TODO: error popup and exit
}
}
package org.tizen.dynamicanalyzer.logparser;
+import java.util.ArrayList;
import java.util.List;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.sql.SqlManager;
import org.tizen.dynamicanalyzer.swap.logparser.LogPackage;
import org.tizen.dynamicanalyzer.swap.logparser.Logs;
+import org.tizen.dynamicanalyzer.swap.model.data.BasicDataMessage;
import org.tizen.dynamicanalyzer.swap.model.probe2.LogDataFactory;
/** log insert into database **/
}
for (int i = 0; i < size; i++) {
int logId = logIds.get(i);
- Logs logs = logPack.getLogs(logId);
- if (null != logs) {
- Logs newLogs = new Logs(logId);
- newLogs.getLogs().addAll(logs.getCloneLogs());
- getLogPackage().putLogs(logs);
+ List<BasicDataMessage> msgs = logPack.getMessages(logId);
+ if (null != msgs) {
+ List<BasicDataMessage> newMsgs = new ArrayList<BasicDataMessage>();
+ newMsgs.addAll(msgs);
+ getLogPackage().putMessages(logId, msgs);
}
} // for
for (int i = 0; i < size; i++) {
int logId = logIds.get(i);
- Logs logs = getLogPackage().getLogs(logId);
- if (null != logs) {
- SqlManager.getInstance().insert(logId, logs.getLogs());
+ List<BasicDataMessage> msgs = getLogPackage().getMessages(logId);
+ if (null != msgs) {
+ SqlManager.getInstance().insert(logId, msgs);
}
}
initLogPackage();
import org.tizen.dynamicanalyzer.common.CommonConstants;
import org.tizen.dynamicanalyzer.common.SymbolManager;
import org.tizen.dynamicanalyzer.communicator.CommunicatorUtils;
-import org.tizen.dynamicanalyzer.communicator.DACommunicator;
import org.tizen.dynamicanalyzer.model.ImageInfo;
import org.tizen.dynamicanalyzer.nl.InformationViewLabels;
import org.tizen.dynamicanalyzer.project.Project;
iVal = log.getSeq();
lVal = log.getTime();
iVal = log.getEnergy();
- iVal = log.getWiFiStatus();
- iVal = log.getBlutToothStatus();
- iVal = log.getGPSStatus();
- iVal = log.getBrightnessStatus();
- iVal = log.getCameraStatus();
- iVal = log.getSoundStatus();
- iVal = log.getAudioStatus();
- iVal = log.getVibrationStatus();
- iVal = log.getVoltageStatus();
- iVal = log.getRSSIStatus();
- iVal = log.getVideoStatus();
- iVal = log.getCallStatus();
- iVal = log.getDNetStatus();
+ iVal = log.getWifi();
+ iVal = log.getBtStatus();
+ iVal = log.getGpsStatus();
+ iVal = log.getBrightness();
+ iVal = log.getCamera();
+ iVal = log.getSound();
+ iVal = log.getAudio();
+ iVal = log.getVibration();
+ iVal = log.getVoltage();
+ iVal = log.getRssi();
+ iVal = log.getVideo();
+ iVal = log.getCall();
+ iVal = log.getDnet();
sVal = log.getCpuFrequency();
fVal = log.getAppCpuUsage();
sVal = log.getCpuLoad();
iVal = log.getVirtualMemory();
iVal = log.getResidentMemory();
iVal = log.getSharedMemory();
- iVal = log.getPSSMemory();
+ iVal = log.getPssMemory();
iVal = log.getTotalAllocSize();
- lVal = log.getTotalSystemMemory();
- lVal = log.getUsedSystemMemory();
+ lVal = log.getSystemMemoryTotal();
+ lVal = log.getSystemMemoryUsed();
iVal = log.getTotalUsedDrive();
iVal = log.getThreadCount();
sVal = log.getThreadLoad();
iVal = log.getProcessCount();
sVal = log.getProcessLoad();
- iVal = log.getDISKReadSize();
- iVal = log.getDISKWriteSize();
+ iVal = log.getDiskReadSize();
+ iVal = log.getDiskWriteSize();
iVal = log.getNetworkSendSize();
iVal = log.getNetworkReceiveSize();
}
ufData)) {
continue;
}
- pushLog(log, logPack);
+ pushLog(log, message, logPack);
/* user callstack create by entry and exit */
AnalyzerManager.getCallstackManager().makeUserCallstack(
ufData,
UIRecorderTool.getInstance().getPlayThead().interrupt();
}
}
- pushLog(log, logPack);
+ pushLog(log, message, logPack);
} else if (log instanceof ProfileData) {
- pushLog(log, logPack);
+ pushLog(log, message, logPack);
} else {
if (log instanceof ScreenShotData) {
String remoteImgPath = ((ScreenShotData) log)
String rotate = Integer.toString(((ScreenShotData) log)
.getOrientation());
// TODO : fix
- // processImage(remoteImgPath, rotate);
+ processImage(remoteImgPath, rotate);
}
- pushLog(log, logPack);
+ pushLog(log, message, logPack);
AnalyzerManager.getCallstackManager()
.makeCallstackWithoutBacktrace(log);
if (id == AnalyzerConstants.MSG_PROBE_FILE
while (true && count < 5) {
SyncResult res = CommunicatorUtils.pull(from, to);
if (null != res && RESULT_OK == res.getCode()) {
- DACommunicator.removeCommand(from);
/* image resizing */
String smallImagePath = AnalyzerManager.getProject()
.getSavePath()
String baseAddr = Long.toString(AnalyzerManager.getProject()
.getBaseAddress());
String path = AnalyzerManager.getProject().getBinaryPath();
- String pcAddr = Long.toString(input.getPCAddress());
+ String pcAddr = Long.toString(input.getPcAddr());
String functionName = SymbolManager.addr2func(path, pcAddr, isPieBuild,
baseAddr);
if (null == functionName || functionName.isEmpty()
input.setApiName(functionName);
}
- private void pushLog(LogData log, LogPackage logPack) {
+ private void pushLog(LogData log, BasicDataMessage msg, LogPackage logPack) {
if (log instanceof ScreenShotData) {
ImageInfo imgInfo = new ImageInfo();
imgInfo.setSeq(Integer.toString(log.getSeq()));
imgInfo.setTime(Long.toString(log.getTime()));
+ String[] path = ((ScreenShotData) log).getImageFilePath().split(
+ CommonConstants.SLASH);
+ imgInfo.setFileName(new String(path[path.length - 1]));
AnalyzerManager.getImageSet().put(imgInfo.getSeq(), imgInfo);
}
logPack.setLogs(log.getId(), log);
+ logPack.setMessages(msg.getId(), msg);
}
}
*/
package org.tizen.dynamicanalyzer.logparser;
-import static org.tizen.sdblib.service.SyncServiceConstants.RESULT_OK;
-
import java.io.BufferedReader;
-import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
import org.tizen.dynamicanalyzer.common.CommonConstants;
-import org.tizen.dynamicanalyzer.communicator.CommunicatorUtils;
import org.tizen.dynamicanalyzer.communicator.DACommunicator;
import org.tizen.dynamicanalyzer.handlers.StopHandler;
import org.tizen.dynamicanalyzer.nl.AnalyzerLabels;
import org.tizen.dynamicanalyzer.uirecorder.RecordingQueue;
import org.tizen.dynamicanalyzer.uirecorder.UIRecorderRecordThread;
import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
-import org.tizen.sdblib.service.SyncResult;
public class MessageProcess {
buffer.add(messages[MSG_PAYLOAD_INDEX]);
messageCount += 1;
break;
- case AnalyzerConstants.MSG_IMAGE: /* screenshot : 6 */
- processImage(messages[MSG_PAYLOAD_INDEX]);
- break;
case AnalyzerConstants.MSG_TERMINATE: /* terminate : 7 */
processTerminate();
break;
case AnalyzerConstants.MSG_RECORD: /* terminate : 7 */
processRecordLog(messages[MSG_PAYLOAD_INDEX]);
break;
- case AnalyzerConstants.MSG_DEBUG: /* debug message : 9 */
default:
- // System.out.println("DA_LOG : " + message); //$NON-NLS-1$
break;
}
.parseInt(data[AnalyzerConstants.APP_INFO_MAX_BRIGHTNESS]));
pInfo.setPid(Integer.parseInt(data[AnalyzerConstants.APP_INFO_PID]));
-// pInfo.setTime(Integer
-// .parseInt(data[AnalyzerConstants.APP_INFO_START_TIME]) * 100);
+ // pInfo.setTime(Integer
+ // .parseInt(data[AnalyzerConstants.APP_INFO_START_TIME]) * 100);
pInfo.setBinaryType(Integer
.parseInt(data[AnalyzerConstants.APP_INFO_PIE_BUILD]));
pInfo.setLowestAddress(Long
}
}
- private String getImageName(String fullPath) {
- String name = null;
- name = fullPath
- .substring(fullPath.lastIndexOf(CommonConstants.SLASH) + 1);
- return name;
- }
+ // private String getImageName(String fullPath) {
+ // String name = null;
+ // name = fullPath
+ // .substring(fullPath.lastIndexOf(CommonConstants.SLASH) + 1);
+ // return name;
+ // }
private void processRecordLog(final String record) {
RecordingQueue rq = UIRecorderRecordThread.getRecordingQueue();
rq.putLog(record);
}
- private void processImage(final String from) {
- final String fileName = getImageName(from);
- final String to = AnalyzerManager.getProject().getSavePath()
- + File.separator + AnalyzerConstants.IMAGE_FOLDER_NAME
- + File.separator + fileName;
-
- new Thread(null, new Runnable() {
- @Override
- public void run() {
- SyncResult res = CommunicatorUtils.pull(from, to);
- if (null != res && RESULT_OK == res.getCode()) {
- DACommunicator.removeCommand(from);
- } else {
- System.out.println("Failed to get '" + from + "' file"); //$NON-NLS-1$ //$NON-NLS-2$
- }
- }
- }, AnalyzerConstants.MESSAGE_INTERNAL_IMAGE_THREAD).start();
-
- }
+ // private void processImage(final String from) {
+ // final String fileName = getImageName(from);
+ // final String to = AnalyzerManager.getProject().getSavePath()
+ // + File.separator + AnalyzerConstants.IMAGE_FOLDER_NAME
+ // + File.separator + fileName;
+ //
+ // new Thread(null, new Runnable() {
+ // @Override
+ // public void run() {
+ // SyncResult res = CommunicatorUtils.pull(from, to);
+ // if (null != res && RESULT_OK == res.getCode()) {
+ // DACommunicator.removeCommand(from);
+ // } else {
+ // System.out.println("Failed to get '" + from + "' file"); //$NON-NLS-1$ //$NON-NLS-2$
+ // }
+ // }
+ // }, AnalyzerConstants.MESSAGE_INTERNAL_IMAGE_THREAD).start();
+ //
+ // }
private void processTerminate() {
if (!AnalyzerManager.isExit()) {
addBufferToList();
System.out.println("stop log process start");//$NON-NLS-1$
StopLogProcessor.runStopLogProcessThread();
- // DACommunicator.closeSocket();
- // DACommunicator.unfoward(DACommunicator.LOCAL_PORT,
- // DACommunicator.getRemotePort());
DACommunicator.closeAll();
AnalyzerUtil.executeCommand(StopHandler.ID);
}
package org.tizen.dynamicanalyzer.model;
-import java.io.BufferedInputStream;
-import java.io.BufferedOutputStream;
-import java.io.BufferedReader;
-import java.io.BufferedWriter;
-import java.io.DataInputStream;
-import java.io.DataOutputStream;
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.io.OutputStreamWriter;
+import static org.tizen.sdblib.service.SyncServiceConstants.RESULT_OK;
+
+import java.io.File;
import java.net.Socket;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
+import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
+import org.tizen.dynamicanalyzer.common.AnalyzerPaths;
+import org.tizen.dynamicanalyzer.common.CommonConstants;
+import org.tizen.dynamicanalyzer.communicator.CommunicatorUtils;
+import org.tizen.dynamicanalyzer.communicator.DACommunicator;
import org.tizen.dynamicanalyzer.project.AppInfo;
import org.tizen.dynamicanalyzer.swap.model.control.TargetInfo;
+import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
import org.tizen.sdblib.IDevice;
+import org.tizen.sdblib.service.SyncResult;
public class DeviceInfo {
private IDevice device;
private List<AppInfo> appInfoList = null;
private HashMap<String, AppInfo> appInfoHash = null;
+ private List<String> apiList = null;
- TargetInfo targetInfo = null;
+ private TargetInfo targetInfo = null;
/*** for version 3.0 */
private int remotePort = -1;
private Socket controlSock = null;
- private BufferedWriter controlWriter = null;
- private BufferedReader controlReader = null;
-
private Socket dataSock = null;
- private BufferedWriter dataWriter = null;
- private BufferedReader dataReader = null;
public DeviceInfo(IDevice device) {
this.device = device;
appInfoList = new ArrayList<AppInfo>();
appInfoHash = new HashMap<String, AppInfo>();
targetInfo = new TargetInfo();
+ apiList = AnalyzerUtil.getApiMap(device);
}
public void setSelectedAppName(String name) {
public void setDataSock(Socket dataSock) {
this.dataSock = dataSock;
- this.dataSock = dataSock;
- try {
- dataReader = new BufferedReader(new InputStreamReader(
- dataSock.getInputStream()));
- dataWriter = new BufferedWriter(new OutputStreamWriter(
- dataSock.getOutputStream()));
- } catch (IOException e) {
- e.printStackTrace();
- }
- }
-
- public BufferedWriter getDataWriter() {
- return dataWriter;
- }
-
- public BufferedReader getDataReader() {
- return dataReader;
}
public Socket getControlSock() {
public void setControlSock(Socket controlSock) {
this.controlSock = controlSock;
- try {
-
- BufferedInputStream bis = new BufferedInputStream(
- controlSock.getInputStream());
- byte[] buffer = new byte[bis.available()];
- bis.read(buffer);
- DataInputStream di = new DataInputStream(bis);
- di.readInt();
- BufferedOutputStream bos = new BufferedOutputStream(
- controlSock.getOutputStream());
- DataOutputStream dout = new DataOutputStream(bos);
- // dout.write(b)
-
- controlReader = new BufferedReader(new InputStreamReader(
- controlSock.getInputStream()));
- controlWriter = new BufferedWriter(new OutputStreamWriter(
- controlSock.getOutputStream()));
- } catch (IOException e) {
- e.printStackTrace();
- }
- }
-
- public BufferedWriter getControlWriter() {
- return controlWriter;
- }
-
- public BufferedReader getControlReader() {
- return controlReader;
}
public boolean equals(DeviceInfo target) {
public TargetInfo getTargetInfo() {
return targetInfo;
}
+
+ public void closeAllSocket() {
+ AnalyzerUtil.tryClose(controlSock, dataSock);
+ CommunicatorUtils.unfoward(CommunicatorUtils.LOCAL_PORT, remotePort);
+ }
+
+ public void releaseDataSock() {
+ AnalyzerUtil.tryClose(dataSock);
+ }
+
+ public List<String> getApiList() {
+ if (null == apiList) {
+ apiList = new ArrayList<String>();
+ }
+ return apiList;
+ }
+
+ public void setApiList(List<String> apiList) {
+ this.apiList = apiList;
+ }
}
public class ImageInfo {
private String seq;
private String time;
+ private String fileName;
public String getTime() {
return time;
}
+ public String getFileName() {
+ return fileName;
+ }
+
+ public void setFileName(String fileName) {
+ this.fileName = fileName;
+ }
+
public void setTime(String time) {
this.time = time;
}
this.seq = seq;
}
- public String getSeq()
- {
+ public String getSeq() {
return seq;
}
import org.tizen.dynamicanalyzer.common.AnalyzerPaths;
import org.tizen.dynamicanalyzer.common.CommonConstants;
import org.tizen.dynamicanalyzer.communicator.DACommunicator;
-import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
import org.tizen.dynamicanalyzer.model.DeviceInfo;
import org.tizen.dynamicanalyzer.sql.SqlManager;
import org.tizen.dynamicanalyzer.swap.model.control.TargetInfo;
private long lastTime = 0;
private long stopTime = -1;
- private TargetInfo targetInfo = new TargetInfo();
+ // private TargetInfo targetInfo = new TargetInfo();
private ProcessInfo processInfo = new ProcessInfo();
public TargetInfo getTargetInfo() {
+ TargetInfo targetInfo = DACommunicator.getSelectedDevice()
+ .getTargetInfo();
return targetInfo;
}
public void setTargetInfo(TargetInfo targetInfo) {
- this.targetInfo = targetInfo;
+ DACommunicator.getSelectedDevice().setTargetInfo(targetInfo);
}
public ProcessInfo getProcessInfo() {
}
public void setCoreCount(int count) {
- targetInfo.setCpuCount(count);
+ getTargetInfo().setCpuCount(count);
}
public int getCoreCount() {
- return targetInfo.getCpuCount();
+ return getTargetInfo().getCpuCount();
}
public int getMaxBrightness() {
- return targetInfo.getMaxBrightness();
+ return getTargetInfo().getMaxBrightness();
}
public long getStartTime() {
- return processInfo.getTime();
+ return processInfo.getStartTime();
}
public void setStartTime(long time) {
- processInfo.setTime(time);
+ processInfo.setStartTime(time);
}
public long getSystemMemorySize() {
- return targetInfo.getSystemMemorySize();
+ return getTargetInfo().getSystemMemorySize();
}
public int getPID() {
this.pkgId = pkgId;
}
- // public boolean initLogCenters(List<String> names) {
- // if (null != logCenters) {
- // logCenters = null;
- // }
- //
- // logCenters = new ArrayList<LogCenter>();
- // List<LogCenter> baseLogcs = AnalyzerManager.getInnerLogCenters();
- // if (null == baseLogcs || baseLogcs.isEmpty()) {
- // System.out
- // .println("DynamicAnalyzer folder or logc file is missing! "); //$NON-NLS-1$
- // return false;
- // }
- // if (null == names || names.isEmpty()) {
- // int size = baseLogcs.size();
- // for (int i = 0; i < size; i++) {
- // logCenters.add(copyLogCenter(baseLogcs.get(i)));
- // }
- // return true;
- // }
- //
- // int size = names.size();
- // int baseSize = baseLogcs.size();
- // for (int i = 0; i < size; i++) {
- // for (int a = 0; a < baseSize; a++) {
- // if (names.get(i).equals(baseLogcs.get(a).getName())) {
- // logCenters.add(copyLogCenter(baseLogcs.get(a)));
- // }
- // }
- // }
- // return true;
- // }
-
- // private LogCenter copyLogCenter(BaseLogCenter from) {
- // LogCenter to = new LogCenter();
- // to.setId(from.getId());
- // to.setName(from.getName());
- // to.setTotalColumnCount(from.getTotalColumnCount());
- // to.setCustomColumn(from.isCustomColumn());
- //
- // to.getColumnName().addAll(from.getColumnName());
- // to.getType().addAll(from.getType());
- // to.getColumnSizes().addAll(from.getColumnSize());
- // to.getColumnOrder().addAll(from.getColumnOrder());
- // to.getColumnVisibility().addAll(from.getColumnVisibility());
- // to.getTableColumnName().addAll(from.getTableColumnName());
- // return to;
- // }
-
public boolean isValid() {
if (null == version || null == appName || null == pkgId
|| null == device) {
package org.tizen.dynamicanalyzer.shortcut;
import org.eclipse.swt.SWT;
+import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Shell;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
public void setEnabled(boolean enabled) {
this.enabled = enabled;
+ if (enabled) {
+ Display.getDefault().syncExec(new Runnable() {
+ @Override
+ public void run() {
+ AnalyzerUtil.getWorkbenchWindow().getShell().setFocus();
+ }
+ });
+ }
}
}
* insert data
* @return success/failed
*/
- public boolean insertLogQuery(String query, List<LogData> input) {
+ public boolean insertLogQuery(int id, String query,
+ List<BasicDataMessage> input) {
PreparedStatement prep = null;
try {
Connection conn = getConnection();
prep = conn.prepareStatement(query);
int dataRowSize = input.size();
for (int i = 0; i < dataRowSize; i++) {
- LogData log = input.get(i);
- prep.setInt(1, log.getLogNum());
- prep.setInt(2, log.getId());
- prep.setInt(3, log.getSeq());
- prep.setLong(4, log.getTime());
- prep.setBytes(5, log.getPayload());
+ BasicDataMessage msg = input.get(i);
+ int logNum = LogDataFactory.getLogCountById(id);
+ prep.setInt(1, logNum);
+ prep.setInt(2, msg.getId());
+ prep.setInt(3, msg.getSeq());
+ prep.setLong(4, msg.getTime());
+ prep.setBytes(5, msg.getPayload());
prep.addBatch();
}
conn.setAutoCommit(false);
List<String> insetRowData = new ArrayList<String>();
insetRowData.add(Integer.toString(pInfo.getPid()));
- insetRowData.add(Long.toString(pInfo.getTime()));
+ insetRowData.add(Long.toString(pInfo.getStartTime()));
insetRowData.add(Long.toString(pInfo.getLowestAddress()));
insetRowData.add(Long.toString(pInfo.getHighestAddress()));
insetRowData.add(Integer.toString(pInfo.getAppType()));
return true;
}
- public void insert(int logId, List<LogData> input)
+ public void insert(int logId, List<BasicDataMessage> input)
throws InterruptedException {
String tableName = LogDataFactory.getTableNamebyId(logId);
// String insertQuery = logc.getInsertQuery();
// insetData.add(insetRowData);
// logc.addIndex();
// }
- insertLogQuery(insertQuery, input);
+ insertLogQuery(logId, insertQuery, input);
}
.getTableInfo(DBTableManager.TABLE_INDEX_LIB_OBJ)
.getTableName(), null);
}
-
+
public List<List<String>> loadApiNames() {
return selectQuery(
null,
package org.tizen.dynamicanalyzer.swap.communicator;
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_CONFIG_ACK;
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_KEEP_ALIVE_ACK;
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_START_ACK;
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_STOP_ACK;
+import static org.tizen.dynamicanalyzer.common.CommonConstants.INT_SIZE;
+import static org.tizen.dynamicanalyzer.common.CommonConstants.LONG_SIZE;
+
import java.io.BufferedReader;
-import java.io.BufferedWriter;
import java.io.IOException;
import java.net.Socket;
import java.net.SocketException;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerShellCommands;
import org.tizen.dynamicanalyzer.common.CommonConstants;
+import org.tizen.dynamicanalyzer.common.ErrorCode;
import org.tizen.dynamicanalyzer.common.HostResult;
import org.tizen.dynamicanalyzer.communicator.BaseCommunicator;
import org.tizen.dynamicanalyzer.communicator.CommunicatorUtils;
import org.tizen.dynamicanalyzer.communicator.DACommunicator;
import org.tizen.dynamicanalyzer.model.DeviceInfo;
+import org.tizen.dynamicanalyzer.project.AppInfo;
+import org.tizen.dynamicanalyzer.swap.logparser.SWAPLogParser;
import org.tizen.dynamicanalyzer.swap.model.ByteUtils;
import org.tizen.dynamicanalyzer.swap.model.control.ApplicationInfo;
import org.tizen.dynamicanalyzer.swap.model.control.RunTimeConfiguration;
import org.tizen.dynamicanalyzer.swap.model.control.TargetInfo;
+import org.tizen.dynamicanalyzer.ui.file.FileChartManager;
+import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler;
+import org.tizen.dynamicanalyzer.ui.thread.ThreadChartManager;
import org.tizen.dynamicanalyzer.ui.toolbar.ConfigureManager;
+import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
+import org.tizen.dynamicanalyzer.ui.userinterface.UIDataManager;
+import org.tizen.dynamicanalyzer.uirecorder.UIRecorderTool;
+import org.tizen.dynamicanalyzer.utils.UpdateViewTimer;
public class Communicator30 extends BaseCommunicator {
+ private boolean isInit = false;
@Override
public HostResult init() {
+ if (isInit) {
+ return null;
+ } else {
+ isInit = true;
+ }
// daemon start
List<DeviceInfo> devices = DACommunicator.getDevices();
- // DeviceInfo selDevice = DACommunicator.getSelectedDevice();
for (DeviceInfo devInfo : devices) {
- CommunicatorUtils.execCommand(devInfo.getIDevice(),
+ Process ps = CommunicatorUtils.execCommand(devInfo.getIDevice(),
AnalyzerShellCommands.DACOMMAND_RUN_MANAGER);
+ System.out.println(ps.toString());
}
// get port
@Override
public HostResult startTrace() {
// binary info message send
- byte[] ret = ByteUtils.toBytes(AnalyzerConstants.MSG_START_SWAP);
- ApplicationInfo testAppInfo = new ApplicationInfo();
- testAppInfo.setAppId("test");
- testAppInfo.setExecPath("/apps/bin/testApp");
-
+ ApplicationInfo appInfo = new ApplicationInfo();
+ AppInfo selectedApp = DACommunicator.getSelectedApp();
+ appInfo.setAppType(Integer.parseInt(selectedApp
+ .getInfo(AppInfo.APPTYPE_INDEX))); // tizen native app
+ appInfo.setAppId(selectedApp.getInfo(AppInfo.APPID_INDEX));
+ appInfo.setExecPath(selectedApp.getInfo(AppInfo.EXEC_INDEX));
+
RunTimeConfiguration rt = new RunTimeConfiguration();
rt.setFeatures(ConfigureManager.getInstance().getConfiguration());
-
- ret = ByteUtils.concatByteArray(ret, testAppInfo.getByteValue(), rt.getByteValue());
+
+ byte[] rear = ByteUtils.getByte(appInfo.getByteValue(),
+ rt.getByteValue());
+ int length = rear.length;
+
+ byte[] ret = ByteUtils.getByte(AnalyzerConstants.MSG_START_SWAP,
+ length, rear);
// data receive thread create and start
+ new Thread(null, new DataChannelThread(),
+ AnalyzerConstants.COMMUNICATOR_RECEIVE_THREAD).start();
// start message send
- return HostResult.SUCCESS;
+ HostResult result = handleControlMessage(
+ DACommunicator.getSelectedDevice(), ret);
+
+ if (result.isSuccess()) {
+ if (!isCorrectAck(MSG_START_ACK, result)) {
+ return HostResult.ERR_MSG_START_FAIL;
+ }
+ } else {
+ DACommunicator.setRunning(false);
+ return result;
+ }
+
+ UIRecorderTool.getInstance().startRecorder();
+ ToolbarArea.getInstance().startTimer();
+ SWAPLogParser.startLogParser();
+ FileChartManager.getInstance().startUpdateLogThread();
+ ThreadChartManager.getInstance().startUpdateLogThread();
+ UIDataManager.getInstance().startUpdateLogThread();
+ FunctionUsageProfiler.startProfiler();
+
+ /* Timeline */
+ UpdateViewTimer.start();
+ System.out
+ .println("Start recorder, timer, log parser, file, thread, ui, profile , update timer");
+ return result;
}
@Override
public HostResult sendRuntimeMessage(int type, String message) {
// send config message
- byte[] ret = ByteUtils.toBytes(AnalyzerConstants.MSG_CONFIG);
+ byte[] config = ByteUtils.toBytes(AnalyzerConstants.MSG_CONFIG);
RunTimeConfiguration rt = new RunTimeConfiguration();
rt.setFeatures(ConfigureManager.getInstance().getConfiguration());
- ret = ByteUtils.concatByteArray(ret, rt.getByteValue());
- // send swap inst message
- return HostResult.SUCCESS;
+ int length = rt.getByteValue().length;
+ byte[] msg = ByteUtils.concatByteArray(config, length,
+ rt.getByteValue());
+ // TODO : send swap inst message
+ HostResult result = handleControlMessage(
+ DACommunicator.getSelectedDevice(), msg);
+
+ if (result.isSuccess()) {
+ if (isCorrectAck(MSG_CONFIG_ACK, result)) {
+ return result;
+ }
+ }
+
+ return HostResult.ERR_MSG_RUNTIME_FAIL;
}
@Override
public HostResult stopTrace() {
- // TODO Auto-generated method stub
- byte[] ret = ByteUtils.toBytes(AnalyzerConstants.MSG_STOP_SWAP);
- return HostResult.SUCCESS;
+ byte[] stop = ByteUtils.toBytes(AnalyzerConstants.MSG_STOP_SWAP);
+ int length = 0;
+ byte[] stopMsg = ByteUtils.getByte(stop, length);
+ HostResult result = handleControlMessage(
+ DACommunicator.getSelectedDevice(), stopMsg);
+
+ if (result.isSuccess()) {
+ if (isCorrectAck(MSG_STOP_ACK, result)) {
+ return result;
+ }
+ }
+
+ return HostResult.ERR_MSG_STOP_FAIL;
}
@Override
@Override
public void clear() {
- // TODO Auto-generated method stub
-
+ List<DeviceInfo> devs = DACommunicator.getDevices();
+ for (DeviceInfo dev : devs) {
+ dev.closeAllSocket();
+ }
}
@Override
return HostResult.SUCCESS;
}
- public HostResult handleControlMessage(DeviceInfo device, String message) {
+ public HostResult handleControlMessage(DeviceInfo device, byte[] message) {
HostResult result = null;
- String str = null;
Socket controlSock = device.getControlSock();
- BufferedWriter controlWriter = device.getControlWriter();
- BufferedReader controlReader = device.getControlReader();
try {
if (null != controlSock && !controlSock.isClosed()) {
- controlWriter.write(message);
- controlWriter.flush();
+ controlSock.getOutputStream().write(message);
}
System.out.println("wait for ack... [send message : " + message
+ " ]");
while (DACommunicator.isRunning()) {
- char cbuf[] = new char[64];
+ byte[] cbuf = new byte[64];
blocked = true;
- int readsize = controlReader.read(cbuf);
+ int readsize = controlSock.getInputStream().read(cbuf);
blocked = false;
if (readsize > 0) {
- str = String.copyValueOf(cbuf, 0, readsize);
- if (null != str && !str.isEmpty()) {
- result = HostResult.SUCCESS;
- result.setMessage(str);
- break;
- }
+ result = HostResult.SUCCESS;
+ result.setRet(cbuf);
}
}
} catch (SocketException e) {
}
public HostResult getTargetInfo(DeviceInfo device) {
- String message = CommonConstants.EMPTY
- + AnalyzerConstants.MSG_TARGET_INFO;
- System.out.println("Send message :" + message); //$NON-NLS-1$
-
- HostResult result = handleControlMessage(device, message);
+ System.out.println("Send target info : "
+ + ByteUtils.getByte(AnalyzerConstants.MSG_TARGET_INFO));
+ HostResult result = handleControlMessage(device,
+ ByteUtils.getByte(AnalyzerConstants.MSG_TARGET_INFO));
if (result.isSuccess()) {
- System.out.println("target info message ack :"
- + result.getMessage());
+ System.out.println("target info message ack :" + result.getRet());
// FIXME : log parsing
- String[] splitResult = result.getMessage().split(
- CommonConstants.CMD_SPLIT_READ);
- if (AnalyzerConstants.MSG_TARGET_INFO_ACK == Integer
- .parseInt(splitResult[0])) {
- // TODO : setting target info
- device.setTargetInfo(new TargetInfo());
+ byte[] data = result.getRet();
+ int index = INT_SIZE * 2;
+
+ if (isCorrectAck(MSG_KEEP_ALIVE_ACK, result)) {
+ TargetInfo info = processTargetInfo(data, index);
+ device.setTargetInfo(info);
return result;
- } else {
- result = HostResult.ERR_TARGET_INFO_GET_FAIL;
- result.setMessage(new String(splitResult[0]));
}
}
- return result;
+ return HostResult.ERR_TARGET_INFO_GET_FAIL;
}
@Override
public HostResult sendKeepAliveMessage(DeviceInfo device) {
- String message = CommonConstants.EMPTY
- + AnalyzerConstants.MSG_KEEP_ALIVE;
- HostResult result = handleControlMessage(device, message);
+ System.out.println("Send keep alive message : "
+ + ByteUtils.getByte(AnalyzerConstants.MSG_KEEP_ALIVE));
+ HostResult result = handleControlMessage(device,
+ ByteUtils.getByte(AnalyzerConstants.MSG_KEEP_ALIVE, 0));
if (result.isSuccess()) {
System.out
.println("keep alive message ack :" + result.getMessage());
- // FIXME : log parsing
- String[] splitResult = result.getMessage().split(
- CommonConstants.CMD_SPLIT_READ);
- if (AnalyzerConstants.MSG_KEEP_ALIVE_ACK == Integer
- .parseInt(splitResult[0])) {
+
+ if (isCorrectAck(MSG_KEEP_ALIVE_ACK, result)) {
return result;
- } else {
- result = HostResult.ERR_TARGET_INFO_GET_FAIL;
- result.setMessage(new String(splitResult[0]));
}
}
+ return HostResult.ERR_KEEP_ALIVE;
+ }
- return result;
+ private boolean isCorrectAck(int ackType, HostResult result) {
+ byte[] data = result.getRet();
+ int index = 0;
+ int msgId = ByteUtils.toInt(data, index);
+ index += INT_SIZE;
+ int retId = ByteUtils.toInt(data, index);
+ index += INT_SIZE;
+
+ if (ackType == msgId) {
+ if (retId == ErrorCode.SUCCESS.getErrorNumber()) {
+ return true;
+ }
+ }
+ return false;
}
@Override
public Socket getDataSocket() {
return DACommunicator.getSelectedDevice().getDataSock();
}
+
+ private TargetInfo processTargetInfo(byte[] payload, int index) {
+ TargetInfo tInfo = new TargetInfo();
+
+ long systemMemorySize = 0;
+ long storageSize = 0;
+ int bluetoothSupport = 0;
+ int gpsSupport = 0;
+ int wifiSupport = 0;
+ int cameraCount = 0;
+ String networkType = null;
+ int maxBrightness = 0;
+ int numberOfCPU = 0;
+
+ systemMemorySize = ByteUtils.toLong(payload, index);
+ index += LONG_SIZE;
+ storageSize = ByteUtils.toLong(payload, index);
+ index += LONG_SIZE;
+ bluetoothSupport = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ gpsSupport = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ wifiSupport = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ cameraCount = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ networkType = ByteUtils.getString(payload, index);
+ index += ByteUtils.getStringLength(payload, index);
+ maxBrightness = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ numberOfCPU = ByteUtils.toInt(payload, index);
+
+ tInfo.setSystemMemorySize(systemMemorySize);
+ tInfo.setStorageSize(storageSize);
+ tInfo.setBluetoothSupport(bluetoothSupport);
+ tInfo.setGpsSupport(gpsSupport);
+ tInfo.setWifiSupport(wifiSupport);
+ tInfo.setCameraCount(cameraCount);
+ tInfo.setNetworkType(networkType);
+ tInfo.setMaxBrightness(maxBrightness);
+ tInfo.setCpuCount(numberOfCPU);
+
+ return tInfo;
+ }
+
+ @Override
+ public void closeSock() {
+ DACommunicator.getSelectedDevice().releaseDataSock();
+ }
}
devices.clear();
devices = DACommunicator.getDevices();
for (DeviceInfo device : devices) {
+ System.out.println("Heart Beat!!");
HostResult result = DACommunicator.sendKeepAliveMessage(device);
if (!result.isSuccess()) {
System.out.println(result.toString());
package org.tizen.dynamicanalyzer.swap.logparser;
+import java.util.ArrayList;
import java.util.HashMap;
+import java.util.List;
+import org.tizen.dynamicanalyzer.swap.model.data.BasicDataMessage;
import org.tizen.dynamicanalyzer.swap.model.probe2.LogData;
-
public class LogPackage {
private HashMap<Integer, Logs> logMap;
+ private HashMap<Integer, List<BasicDataMessage>> messageMap;
- public void clear()
- {
+ public void clear() {
getLogMap().clear();
+ getMessageMap().clear();
}
public LogPackage() {
logMap = new HashMap<Integer, Logs>();
+ messageMap = new HashMap<Integer, List<BasicDataMessage>>();
}
- private HashMap<Integer, Logs> getLogMap()
- {
- if (null == logMap)
- {
+ private HashMap<Integer, Logs> getLogMap() {
+ if (null == logMap) {
logMap = new HashMap<Integer, Logs>();
}
return logMap;
}
- public boolean isEmpty()
- {
+
+ private HashMap<Integer, List<BasicDataMessage>> getMessageMap() {
+ if (null == messageMap) {
+ messageMap = new HashMap<Integer, List<BasicDataMessage>>();
+ }
+ return messageMap;
+ }
+
+ public boolean isEmpty() {
return getLogMap().isEmpty();
}
public void setLogs(int id, LogData input) {
Logs logs = getLogMap().get(id);
- if (null == logs)
- {
+ if (null == logs) {
logs = new Logs(id);
logMap.put(id, logs);
}
logs.getLogs().add(input);
}
- public void setLogs(int id, Logs logs)
- {
- if (null != getLogMap().get(id))
- {
+ public void setMessages(int id, BasicDataMessage msg) {
+ List<BasicDataMessage> msgs = getMessageMap().get(id);
+ if (null == msgs) {
+ msgs = new ArrayList<BasicDataMessage>();
+ getMessageMap().put(id, msgs);
+ }
+ msgs.add(msg);
+ }
+
+ public void setLogs(int id, Logs logs) {
+ if (null != getLogMap().get(id)) {
logMap.remove(id);
}
logMap.put(id, logs);
}
- public Logs getLogs(int id)
- {
+ public Logs getLogs(int id) {
return getLogMap().get(id);
}
- public void putLogs(Logs logs)
- {
- if (null != logs)
- {
+ public List<BasicDataMessage> getMessages(int id) {
+ return getMessageMap().get(id);
+ }
+
+ public void putLogs(Logs logs) {
+ if (null != logs) {
int id = logs.getId();
Logs base = getLogMap().get(id);
- if (null == base)
- {
+ if (null == base) {
logMap.put(id, logs);
- }
- else
- {
+ } else {
base.getLogs().addAll(logs.getLogs());
}
}
}
+
+ public void putMessages(int id, List<BasicDataMessage> msgs) {
+ if (null != msgs) {
+ List<BasicDataMessage> base = getMessageMap().get(id);
+ if (null == base) {
+ messageMap.put(id, msgs);
+ } else {
+ base.addAll(msgs);
+ }
+ }
+ }
}
List<LogData> newLogs = new ArrayList<LogData>();
int size = logs.size();
for (int i = 0; i < size; i++) {
- LogData newLog = logs.get(i).getClone();
+// LogData newLog = logs.get(i).getClone();
+ LogData newLog = logs.get(i);
newLogs.add(newLog);
}
return newLogs;
*/
package org.tizen.dynamicanalyzer.swap.logparser;
+import static org.tizen.dynamicanalyzer.common.CommonConstants.INT_SIZE;
+import static org.tizen.dynamicanalyzer.common.CommonConstants.LONG_SIZE;
import static org.tizen.sdblib.service.SyncServiceConstants.RESULT_OK;
import java.io.BufferedInputStream;
import org.tizen.dynamicanalyzer.communicator.CommunicatorUtils;
import org.tizen.dynamicanalyzer.communicator.DACommunicator;
import org.tizen.dynamicanalyzer.handlers.StopHandler;
-import org.tizen.dynamicanalyzer.swap.logparser.SWAPLogParser;
import org.tizen.dynamicanalyzer.nl.AnalyzerLabels;
import org.tizen.dynamicanalyzer.services.RecordStateSourceProvider;
import org.tizen.dynamicanalyzer.swap.model.ByteUtils;
import org.tizen.dynamicanalyzer.swap.model.data.BasicDataMessage;
import org.tizen.dynamicanalyzer.swap.model.data.DataChannelConstants;
+import org.tizen.dynamicanalyzer.swap.model.data.LibraryObject;
+import org.tizen.dynamicanalyzer.swap.model.data.ProcessInfo;
import org.tizen.dynamicanalyzer.swap.model.probe.LogFormat;
-import org.tizen.dynamicanalyzer.swap.model.probe2.BasicDataFactory;
import org.tizen.dynamicanalyzer.swap.model.probe2.LogData;
import org.tizen.dynamicanalyzer.swap.model.probe2.LogDataFactory;
import org.tizen.dynamicanalyzer.ui.toolbar.StopLogProcessor;
lock.unlock();
}
- private void processAppInfo(String message) {
-// String[] datas = message.split(AnalyzerConstants.DATA_PARSING_TOKEN);
-// List<String> appInfo = AnalyzerManager.getProject().getAppInfo();
-// int size = datas.length;
-// for (int i = 0; i < size; i++) {
-// appInfo.set(i, new String(datas[i]));
-// }
-//
-// if (size - 1 < AnalyzerConstants.APP_INFO_BINARY_PATH
-// || null == appInfo.get(AnalyzerConstants.APP_INFO_BINARY_PATH)
-// || appInfo.get(AnalyzerConstants.APP_INFO_BINARY_PATH)
-// .isEmpty()) {
-// ToolbarArea.getInstance().setSourceViewEnable(false);
-// ToolbarArea.getInstance().setSourceViewTooltip(
-// AnalyzerLabels.MESSAGE_PROCESS_PG_WARNING);
-// } else {
-// ToolbarArea.getInstance().setSourceViewEnable(true);
-// ToolbarArea.getInstance().setSourceViewTooltip(
-// AnalyzerLabels.MESSAGE_PROCESS_VIEW_SOURCE);
-// }
-//
-// // User Call Trace : App is Tizen C++ or Tizen native
-// int type = Integer.parseInt(appInfo
-// .get(AnalyzerConstants.APP_INFO_APP_TYPE));
-// if (type == AnalyzerConstants.APP_TYPE_OSP) {
-// SWAPLogParser.setDropCallTraceLog(true);
-// }
+ private void processProcessInfo(BasicDataMessage message) {
+ byte[] payload = message.getPayload();
+ ProcessInfo pInfo = AnalyzerManager.getProject().getProcessInfo();
+
+ int pid = 0;
+ long startTime = 0;
+ long lowAddr = 0;
+ long highAddr = 0;
+ int appType = 0;
+ int binaryType = 0;
+ String binaryPath = null;
+ int dependantLibCount = 0;
+
+ int index = 0;
+ pid = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ startTime = ByteUtils.toLong(payload, index);
+ index += LONG_SIZE;
+ lowAddr = ByteUtils.toLong(payload, index);
+ index += LONG_SIZE;
+ highAddr = ByteUtils.toLong(payload, index);
+ index += LONG_SIZE;
+ appType = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ binaryType = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ binaryPath = ByteUtils.getString(payload, index);
+ index += ByteUtils.getStringLength(payload, index);
+ dependantLibCount = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+
+ List<LibraryObject> libObjs = pInfo.getLibObjs();
+ for (int i = 0; i < dependantLibCount; i++) {
+ LibraryObject libObj = new LibraryObject();
+ long lowestAddr = ByteUtils.toLong(payload, index);
+ index += LONG_SIZE;
+ long highestAddr = ByteUtils.toLong(payload, index);
+ index += LONG_SIZE;
+ String libPath = ByteUtils.getString(payload, index);
+ index += ByteUtils.getStringLength(payload, index);
+ libObj.setLowestAddress(lowestAddr);
+ libObj.setHighestAddress(highestAddr);
+ libObj.setLibPath(libPath);
+ libObjs.add(libObj);
+ }
+
+ pInfo.setPid(pid);
+ pInfo.setStartTime(startTime);
+ pInfo.setLowestAddress(lowAddr);
+ pInfo.setHighestAddress(highAddr);
+ pInfo.setAppType(appType);
+ pInfo.setBinaryType(binaryType);
+ pInfo.setBinaryPath(binaryPath);
+ pInfo.setDepLibCount(dependantLibCount);
}
private String getImageName(String fullPath) {
DACommunicator.setRunning(false);
}
- private String message = null;
- private String[] messages = null;
-
- private int sentenceIndex = -1;
- private String sentence = null;
-
public void testParsing(byte[] input) {
- byte[] empty = new byte[1024];
byte[] buf = input;
BasicDataMessage dataMessage = null;
if (null == dataMessage) {
}
public void startMessageParsing(Socket dataSocket) {
- byte[] empty = new byte[1024];
+ // byte[] empty = new byte[1024];
byte[] buf = new byte[1024];
BufferedInputStream inputStream = null;
}
if (null == dataMessage) {
- dataMessage = (BasicDataMessage) BasicDataFactory
- .createBasicDataInstance();
+ dataMessage = new BasicDataMessage();
buf = dataMessage.makeData(buf);
} else {
buf = dataMessage.addData(buf);
while (dataMessage.isComplete() && DACommunicator.isRunning()) {
// dataMessage push to queue
processMessage(dataMessage);
- dataMessage = (BasicDataMessage) BasicDataFactory
- .createBasicDataInstance();
+ dataMessage = new BasicDataMessage();
buf = dataMessage.makeData(buf);
}
} // end while()
private void endingSteps() {
System.out.println("Ending steps!");
- message = null;
+ // message = null;
DACommunicator.setRunning(false);
AnalyzerUtil.setRecordState(RecordStateSourceProvider.RECORD_READY);
Display.getDefault().syncExec(new Runnable() {
addBufferToList();
System.out.println("stop log process start");//$NON-NLS-1$
StopLogProcessor.runStopLogProcessThread();
- // DACommunicator.closeSocket();
- // DACommunicator.unfoward(DACommunicator.LOCAL_PORT,
- // DACommunicator.getRemotePort());
- DACommunicator.closeAll();
+ DACommunicator.closeSock();
AnalyzerUtil.executeCommand(StopHandler.ID);
}
switch (messageId) {
case DataChannelConstants.MSG_PROCESS_INFO:
// setting process info
+ processProcessInfo(data);
break;
case DataChannelConstants.MSG_TERMINATE:
processTerminate();
// make log
log = LogDataFactory.createInstance(data);
if (null != log) {
- // push log
+ buffer.add(log);
+ messageCount += 1;
}
break;
default: // MSG_PROBE
if (messageId > 0x3000 && messageId < 0x4000) {
log = LogDataFactory.createInstance(data);
if (null != log) {
- // push log
+ buffer.add(log);
+ messageCount++;
}
}
+ break;
+ }
+
+ if (MSG_BUFFER_MAX < messageCount) {
+ addBufferToList();
+ messageCount = 0;
}
}
import org.tizen.dynamicanalyzer.common.SymbolManager;
import org.tizen.dynamicanalyzer.communicator.CommunicatorUtils;
import org.tizen.dynamicanalyzer.communicator.DACommunicator;
-import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
import org.tizen.dynamicanalyzer.logparser.LogInserter;
+import org.tizen.dynamicanalyzer.logparser.LogParser;
import org.tizen.dynamicanalyzer.model.ImageInfo;
import org.tizen.dynamicanalyzer.nl.InformationViewLabels;
import org.tizen.dynamicanalyzer.project.Project;
-import org.tizen.dynamicanalyzer.swap.model.probe2.FileData;
+import org.tizen.dynamicanalyzer.swap.model.data.ApiNameManager;
import org.tizen.dynamicanalyzer.swap.model.probe2.LogData;
-import org.tizen.dynamicanalyzer.swap.model.probe2.MemoryData;
import org.tizen.dynamicanalyzer.swap.model.probe2.ProbeCommonData;
import org.tizen.dynamicanalyzer.swap.model.probe2.ProfileData;
import org.tizen.dynamicanalyzer.swap.model.probe2.ScreenShotData;
import org.tizen.dynamicanalyzer.swap.model.probe2.SystemData;
+import org.tizen.dynamicanalyzer.swap.model.probe2.UserFunctionData;
import org.tizen.dynamicanalyzer.ui.page.BaseView;
+import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler;
import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea;
import org.tizen.dynamicanalyzer.uirecorder.UIRecorderPlayThread;
import org.tizen.dynamicanalyzer.uirecorder.UIRecorderTool;
if (null == logLumb.get(i)) {
continue;
}
- // String[] log = logLumb.get(i).split(CommonConstants.NEW_LINE);
- //
- // slicedLog = log[0].split(AnalyzerConstants.DATA_PARSING_TOKEN);
- //
- // BasicDataMessage22 bdi = (BasicDataMessage22)
- // BasicDataFactory.createBasicDataInstance();
- // bdi.makeData(slicedLog);
- // LogData basicData = LogDataFactory.createInstance(bdi);
- // logId = slicedLog[LogCenterConstants.ID_INDEX];
- // int id = Integer.parseInt(logId);
- // int id = commonData.getId();
-
LogData log = logLumb.get(i);
int id = log.getId();
}
}
- // set start time
+ // ADJUST TIME
long longTime = log.getTime();
long startTime = project.getStartTime();
project.setStartTime(startTime);
}
long lastTime = longTime - startTime;
- // String modifyedTime = Long.toString(lastTime) + TIME_POST_FIX;
+ lastTime *= 100;
log.setTime(lastTime);
// slicedLog[timeIndex] = modifyedTime;
// long seqNum = Long.parseLong(seq);
int seqNum = log.getSeq();
- if (log instanceof ProfileData) {
- // String apiName = slicedLog[LogCenterConstants.APINAME_INDEX];
- // if (apiName.isEmpty() || apiName.equals("_end")) { //$NON-NLS-1$
- // setFuncName(slicedLog);
- // }
- //
- // if (LogParser.isDrapCallTraceLog()) {
- // apiName = slicedLog[LogCenterConstants.APINAME_INDEX];
- // if (!apiName.equals(OSP_MAIN)) {
- // continue;
- // }
- // LogParser.setDropCallTraceLog(false);
- // }
-
- // String start =
- // slicedLog[LogCenterConstants.USER_FUNCTION_BINARY_RANGE_START_INDEX];
- // String end =
- // slicedLog[LogCenterConstants.USER_FUNCTION_BINARY_RANGE_END_INDEX];
- // if (!start.isEmpty() && !end.isEmpty()
- // && !AnalyzerManager.isBinStartEndSet()) {
- // AnalyzerManager.setBinaryStartEndAddr(start, end);
- // }
- //
- // if
- // (AnalyzerManager.getCallstackManager().isIrregularUserCall(
- // slicedLog)) {
- // continue;
- // }
+ if (log instanceof UserFunctionData) {
+ UserFunctionData ufData = (UserFunctionData) log;
+ String apiName = ufData.getApiName();
+ if (null == apiName || apiName.isEmpty()
+ || apiName.equals("_end")) { //$NON-NLS-1$
+ setFuncName(ufData);
+ }
+
+ if (LogParser.isDrapCallTraceLog()) {
+ apiName = ufData.getApiName();
+ if (!apiName.equals(OSP_MAIN)) {
+ continue;
+ }
+ LogParser.setDropCallTraceLog(false);
+ }
+ long binaryStartAddr = ufData.getLowPc();
+ long binaryEndAddr = ufData.getHighPc();
+
+ if (binaryStartAddr > 0 && binaryEndAddr > 0
+ && !AnalyzerManager.isBinStartEndSet()) {
+ AnalyzerManager.setBinaryStartEndAddr(binaryStartAddr,
+ binaryEndAddr);
+ }
+
+ if (AnalyzerManager.getCallstackManager().isIrregularUserCall(
+ ufData)) {
+ continue;
+ }
pushLog(log, logPack);
- /* TODO: user callstack create by entry and exit */
- // AnalyzerManager.getCallstackManager().makeUserCallstack(
- // slicedLog,
- // FunctionUsageProfiler.getInstance()
- // .getProfileDataMaker());
+ /* user callstack create by entry and exit */
+ AnalyzerManager.getCallstackManager().makeUserCallstack(
+ ufData,
+ FunctionUsageProfiler.getInstance()
+ .getProfileDataMaker());
} else if (log instanceof SystemData) {
if (seqNum == 1) {
UIRecorderPlayThread rp = UIRecorderTool.getInstance()
}
}
pushLog(log, logPack);
+ } else if (log instanceof ProfileData) {
+ pushLog(log, logPack);
} else {
if (log instanceof ScreenShotData) {
String remoteImgPath = ((ScreenShotData) log)
.getImageFilePath();
- int rotate = ((ScreenShotData) log).getOrientation();
- processImage(remoteImgPath, rotate);
+ String rotate = Integer.toString(((ScreenShotData) log)
+ .getOrientation());
+ // TODO : fix
+ // processImage(remoteImgPath, rotate);
}
pushLog(log, logPack);
- // TODO : callstack
- // AnalyzerManager.getCallstackManager()
- // .makeCallstackWithoutBacktrace(slicedLog);
- if (log instanceof FileData || log instanceof MemoryData) {
- // TODO: leak detect
- // AnalyzerManager.getLeakDetector().runLeakDectect(log);
+ AnalyzerManager.getCallstackManager()
+ .makeCallstackWithoutBacktrace(log);
+ if (id == AnalyzerConstants.MSG_PROBE_FILE
+ || id == AnalyzerConstants.MSG_PROBE_MEMORY) {
+ AnalyzerManager.getLeakDetector().runLeakDectect(log);
}
- // TODO: failed check
- // AnalyzerManager.getFailedChecker().check(slicedLog,
- // AnalyzerManager.getCallstackManager());
+ AnalyzerManager.getFailedChecker().check(log,
+ AnalyzerManager.getCallstackManager());
}
// set last log number
AnalyzerManager.getProject().setLastLogNum(seqNum, id);
}
+
updateLog(logPack);
}
}
/* 1. InsertLog extension */
- // TODO: push log
- // LogInserter.getInsertLogQueue().push(logPack);
+ LogInserter.getInsertLogQueue().push(logPack);
LogInserter.startInsertLogThread();
BaseView bv = (BaseView) AnalyzerUtil.getViewPart(BaseView.ID);
- // TODO: update log
- // bv.getMainTab().updateLog(logPack);
+ bv.getMainTab().updateLog(logPack);
}
- private void setFuncName(String[] input) {
+ private void setFuncName(UserFunctionData input) {
boolean isPieBuild = AnalyzerManager.getProject().isPieBuild();
String baseAddr = Long.toString(AnalyzerManager.getProject()
.getBaseAddress());
String path = AnalyzerManager.getProject().getBinaryPath();
- String pcAddr = input[LogCenterConstants.PCADDR_INDEX];
+ String pcAddr = Long.toString(input.getPcAddr());
String functionName = SymbolManager.addr2func(path, pcAddr, isPieBuild,
baseAddr);
if (null == functionName || functionName.isEmpty()
|| functionName.equals("_end")) { //$NON-NLS-1$
functionName = InformationViewLabels.CALLSTACK_TABLE_UNKNOWN_FUNCTION;
+ ApiNameManager.getApiId(functionName);
} else {
String prevFunctionName = functionName;
functionName = SymbolManager
.demanglingFunctionName(prevFunctionName);
+ ApiNameManager.getApiId(functionName);
}
- input[LogCenterConstants.APINAME_INDEX] = functionName;
+ input.setApiName(functionName);
}
private void pushLog(LogData logData, LogPackage logPack) {
float f = (Float) obj;
temp = ByteUtils.concatByteArray(temp,
ByteUtils.floatToBytes(f));
+ }else if (obj instanceof Double) {
+ double d = (Double) obj;
+ temp = ByteUtils.concatByteArray(temp,
+ ByteUtils.doubleToBytes(d));
} else if (obj instanceof String) {
String value = (String) obj;
temp = ByteUtils.concatByteArray(temp,
}
return temp;
}
+
+ public static String getString(byte[] data, int start)
+ {
+ int length = getStringLength(data, start);
+ byte[] temp = new byte[length];
+ System.arraycopy(data, start, temp, 0, length);
+ return new String(temp);
+ }
+
+ public static int getStringLength(byte[] data, int start) {
+ int length = 0;
+ for (int i = start; i < data.length; i++, length++) {
+ if (data[i] == 0) {
+ return length + 1;
+ }
+ }
+ return data.length;
+ }
}
import org.tizen.dynamicanalyzer.swap.model.ByteUtils;
import org.tizen.dynamicanalyzer.swap.model.SWAPModel;
-
-public class ApplicationInfo implements SWAPModel{
+public class ApplicationInfo implements SWAPModel {
+ /***
+ * target application type
+ * 01: tizen native application
+ * 02: already launched process
+ * 03: common executables
+ */
+ private int appType = 0;
+
+ /***
+ * target application ID
+ * depends on the target application type
+ * 01: AppID, pkg_id.app_name, the standard tizen native application ID
+ * 02: PID
+ * 03: "\0"
+ */
private String appId = null;
private String execPath = null;
+ public int getAppType() {
+ return appType;
+ }
+
+ public void setAppType(int appType) {
+ this.appType = appType;
+ }
+
public String getAppId() {
return appId;
}
@Override
public byte[] getByteValue() {
- return ByteUtils.concatByteArray(ByteUtils.stringToByte(appId),
- ByteUtils.stringToByte(execPath));
+ return ByteUtils.getByte(appType, appId, execPath);
}
@Override
public void setByteToValues(byte[] input) {
// TODO Auto-generated method stub
-
+
}
}
package org.tizen.dynamicanalyzer.swap.model.data;
-import java.util.ArrayList;
import java.util.List;
+import org.tizen.dynamicanalyzer.communicator.DACommunicator;
+
public class ApiNameManager {
- private static List<String> apiList = new ArrayList<String>();
+ private static List<String> apiList = null;
public static String getApiName(int apiId) {
- return apiList.get(apiId);
+ return getApiList().get(apiId);
}
public static int getApiId(String name) {
- if (apiList.indexOf(name) < 0) {
- apiList.add(name);
+ if (getApiList().indexOf(name) < 0) {
+ getApiList().add(name);
}
- return apiList.indexOf(name);
+ return getApiList().indexOf(name);
}
public static List<String> getApiList() {
- return apiList;
+ return DACommunicator.getSelectedDevice().getApiList();
+
}
public static void clear() {
- apiList.clear();
+ if (DACommunicator.isSWAPVersion()) {
+ apiList.clear();
+ }
}
}
import org.tizen.dynamicanalyzer.common.CommonConstants;
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
import org.tizen.dynamicanalyzer.swap.model.ByteUtils;
-import org.tizen.dynamicanalyzer.swap.model.probe2.BasicDataInterface;
import org.tizen.dynamicanalyzer.swap.model.probe2.LogDataFactory;
import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
-public class BasicDataMessage implements BasicDataInterface {
+public class BasicDataMessage {
public static final int INT_SIZE = CommonConstants.INT_SIZE;
public static final int ID_SIZE = INT_SIZE;
public static final int SEQ_SIZE = INT_SIZE;
private byte[] headerBuffer = new byte[HEADER_SIZE];
private byte[] emptyHeaderBuffer = new byte[HEADER_SIZE];
- private byte[] emptyBuffer = null;
+// private byte[] emptyBuffer = null;
private int bufferStart = 0;
public byte[] makeData(byte[] input) {
return complete;
}
- @Override
- public String[] getLog() {
- // Unused, for version 2.2
- return null;
- }
-
- @Override
- public BasicDataInterface getClone() {
+ public BasicDataMessage getClone() {
BasicDataMessage clone = new BasicDataMessage();
clone.id = this.id;
clone.seq = this.seq;
public class ProcessInfo {
private int pid = -1;
- private long time = 0;
+ private long startTime = 0;
private long lowestAddress = 0;
private long highestAddress = 0;
private int appType = -1; // 1. tizen 2. capi
this.pid = pid;
}
- public long getTime() {
- return time;
+ public long getStartTime() {
+ return startTime;
}
- public void setTime(long time) {
- this.time = time;
+ public void setStartTime(long time) {
+ this.startTime = time;
}
public long getLowestAddress() {
--- /dev/null
+package org.tizen.dynamicanalyzer.swap.model.probe2;
+
+public class ArgsInfo {
+ int lastIndex = 0;
+ String args = null;
+
+ public int getLastIndex() {
+ return lastIndex;
+ }
+
+ public void setLastIndex(int lastIndex) {
+ this.lastIndex = lastIndex;
+ }
+
+ public String getArgs() {
+ return args;
+ }
+
+ public void setArgs(String args) {
+ this.args = args;
+ }
+
+}
+++ /dev/null
-package org.tizen.dynamicanalyzer.swap.model.probe2;
-
-import org.tizen.dynamicanalyzer.communicator.DACommunicator;
-import org.tizen.dynamicanalyzer.swap.model.data.BasicDataMessage;
-
-public class BasicDataFactory {
- public static BasicDataInterface createBasicDataInstance() {
- BasicDataInterface instance = null;
-
- String version = DACommunicator.getTargetVersion();
- if (version.contains("3.0")) {
- instance = new BasicDataMessage();
- } else if (version.contains("2.1.1")) {
- instance = new BasicDataMessage22();
- }
- return instance;
- }
-}
+++ /dev/null
-package org.tizen.dynamicanalyzer.swap.model.probe2;
-
-public interface BasicDataInterface {
- public int getId();
- public int getSeq();
- public long getTime();
- public void setTime(long time);
-
- public String[] getLog();
- public byte[] getPayload();
- public BasicDataInterface getClone();
-}
+++ /dev/null
-package org.tizen.dynamicanalyzer.swap.model.probe2;
-
-import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
-
-public class BasicDataMessage22 implements BasicDataInterface {
-
- protected int id = -1;
- protected int seq = -1;
- protected long time = -1;
-
- protected String[] log;
-
- public void makeData(String[] splitLog) {
- log = splitLog;
- id = Integer.parseInt(log[LogCenterConstants.ID_INDEX]);
- seq = Integer.parseInt(log[LogCenterConstants.SEQUENCE_NUMBER_INDEX]);
- time = Long.parseLong(log[LogCenterConstants.TIME_INDEX]);
- }
-
- @Override
- public int getId() {
- return id;
- }
-
- @Override
- public int getSeq() {
- return seq;
- }
-
- @Override
- public long getTime() {
- return time;
- }
-
- @Override
- public String[] getLog() {
- return log;
- }
-
- @Override
- public byte[] getPayload() {
- // unused, for version 3.0
- return null;
- }
-
- @Override
- public BasicDataInterface getClone() {
- BasicDataMessage22 clone = new BasicDataMessage22();
- clone.id = this.id;
- clone.seq = this.seq;
- clone.time = this.time;
- clone.log = this.log.clone();
- return clone;
- }
-
- @Override
- public void setTime(long time) {
- String input = Long.toString(time);
- log[LogCenterConstants.TIME_INDEX] = input;
- }
-
-}
package org.tizen.dynamicanalyzer.swap.model.probe2;
-import org.tizen.dynamicanalyzer.common.CommonConstants;
-import org.tizen.dynamicanalyzer.swap.model.ByteUtils;
+import org.tizen.dynamicanalyzer.swap.model.data.BasicDataMessage;
public class ControlData extends ProbeCommonData {
- private int parentNameIndex = 0;
- private int parentClassNameIndex = 0;
- private int parentPointerIndex = 0;
- private int childNameIndex = 0;
- private int childClassNameIndex = 0;
- private int childPointerIndex = 0;
-
- public ControlData(BasicDataInterface data) {
+ private String parentName = null;
+ private String parentClassName = null;
+ private long parentPointer = 0;
+ private String childName = null;
+ private String childClassName = null;
+ private long childPointer = 0;
+
+ public ControlData(BasicDataMessage data) {
super(data);
- parentNameIndex = getCommonColumnsSize();
- parentClassNameIndex = parentNameIndex
- + getStringLength(parentNameIndex);
- parentPointerIndex = parentClassNameIndex
- + getStringLength(parentClassNameIndex);
- childNameIndex = parentPointerIndex + CommonConstants.LONG_SIZE;
- childClassNameIndex = childNameIndex + getStringLength(childNameIndex);
- childPointerIndex = childClassNameIndex
- + getStringLength(childClassNameIndex);
}
public String getParentName() {
- byte[] temp = new byte[parentClassNameIndex - parentNameIndex];
- System.arraycopy(payload, parentNameIndex, temp, 0, temp.length);
- return new String(temp);
+ return parentName;
+ }
+
+ public void setParentName(String parentName) {
+ this.parentName = parentName;
}
public String getParentClassName() {
- byte[] temp = new byte[parentPointerIndex - parentClassNameIndex];
- System.arraycopy(payload, parentClassNameIndex, temp, 0, temp.length);
- return new String(temp);
+ return parentClassName;
+ }
+
+ public void setParentClassName(String parentClassName) {
+ this.parentClassName = parentClassName;
}
public long getParentPointer() {
- return ByteUtils.toLong(payload, parentPointerIndex);
+ return parentPointer;
+ }
+
+ public void setParentPointer(long parentPointer) {
+ this.parentPointer = parentPointer;
}
public String getChildName() {
- byte[] temp = new byte[childClassNameIndex - childNameIndex];
- System.arraycopy(payload, childNameIndex, temp, 0, temp.length);
- return new String(temp);
+ return childName;
+ }
+
+ public void setChildName(String childName) {
+ this.childName = childName;
}
public String getChildClassName() {
- byte[] temp = new byte[childPointerIndex - childClassNameIndex];
- System.arraycopy(payload, childClassNameIndex, temp, 0, temp.length);
- return new String(temp);
+ return childClassName;
+ }
+
+ public void setChildClassName(String childClassName) {
+ this.childClassName = childClassName;
}
public long getChildPointer() {
- return ByteUtils.toLong(payload, childPointerIndex);
+ return childPointer;
}
+
+ public void setChildPointer(long childPointer) {
+ this.childPointer = childPointer;
+ }
+
}
package org.tizen.dynamicanalyzer.swap.model.probe2;
-import org.tizen.dynamicanalyzer.common.CommonConstants;
-import org.tizen.dynamicanalyzer.swap.model.ByteUtils;
+import org.tizen.dynamicanalyzer.swap.model.data.BasicDataMessage;
public class CustomData extends ProbeCommonData {
- private int handleIndex = 0;
- private int typeIndex = 0;
- private int nameIndex = 0;
- private int colorIndex = 0;
- private int valueIndex = 0;
+ int handle = 0;
+ int type = 0;
+ String name = null;
+ int color = 0;
+ double value = 0;
- public CustomData(BasicDataInterface data) {
+ public CustomData(BasicDataMessage data) {
super(data);
- handleIndex = getCommonColumnsSize();
- typeIndex = handleIndex + CommonConstants.INT_SIZE;
- nameIndex = typeIndex + CommonConstants.INT_SIZE;
- colorIndex = getStringLength(nameIndex);
- valueIndex = colorIndex + CommonConstants.INT_SIZE;
}
public int getHandle() {
- return ByteUtils.toInt(payload, handleIndex);
+ return handle;
+ }
+
+ public void setHandle(int handle) {
+ this.handle = handle;
}
public int getType() {
- return ByteUtils.toInt(payload, typeIndex);
+ return type;
}
- public String getName() {
+ public void setType(int type) {
+ this.type = type;
+ }
- byte[] temp = new byte[colorIndex - nameIndex];
- System.arraycopy(payload, nameIndex, temp, 0, temp.length);
- return new String(temp);
+ public String getName() {
+ return name;
+ }
+ public void setName(String name) {
+ this.name = name;
}
public int getColor() {
- return ByteUtils.toInt(payload, colorIndex);
+ return color;
+ }
+
+ public void setColor(int color) {
+ this.color = color;
}
public double getValue() {
- return ByteUtils.toDouble(payload, valueIndex);
+ return value;
+ }
+
+ public void setValue(double value) {
+ this.value = value;
}
}
--- /dev/null
+package org.tizen.dynamicanalyzer.swap.model.probe2;
+
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_CONTEXT_SWITCH_ENTRY;
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_CONTEXT_SWITCH_EXIT;
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_DATA_SAMPLE;
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_DATA_SYSTEM;
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_FUNCTION_ENTRY;
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_FUNCTION_EXIT;
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_PROBE_CUSTOM;
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_PROBE_FILE;
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_PROBE_LIFECYCLE;
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_PROBE_MEMORY;
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_PROBE_SCENE;
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_PROBE_SCREENSHOT;
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_PROBE_SYNC;
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_PROBE_THREAD;
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_PROBE_UICONTROL;
+import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_PROBE_UIEVENT;
+import static org.tizen.dynamicanalyzer.common.CommonConstants.FLOAT_SIZE;
+import static org.tizen.dynamicanalyzer.common.CommonConstants.INT_SIZE;
+import static org.tizen.dynamicanalyzer.common.CommonConstants.LONG_SIZE;
+
+import org.tizen.dynamicanalyzer.common.CommonConstants;
+import org.tizen.dynamicanalyzer.communicator.DACommunicator;
+import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
+import org.tizen.dynamicanalyzer.swap.model.ByteUtils;
+
+public class DataFactory {
+ private static int index = 0;
+
+ public static void createData(LogData data, byte[] paylaod) {
+ int id = data.getId();
+ index = 0;
+
+ switch (id) {
+ case MSG_PROBE_MEMORY:
+ createMemoryData(data, paylaod);
+ break;
+
+ case MSG_PROBE_UICONTROL:
+ createControlData(data, paylaod);
+ break;
+
+ case MSG_PROBE_UIEVENT:
+ createUIEventData(data, paylaod);
+ break;
+
+ case MSG_PROBE_FILE:
+ createFileData(data, paylaod);
+ break;
+
+ case MSG_PROBE_LIFECYCLE:
+ createLifecycleData(data, paylaod);
+ break;
+
+ case MSG_PROBE_SCREENSHOT:
+ createScreenshotData(data, paylaod);
+ break;
+
+ case MSG_PROBE_SCENE:
+ createSceneData(data, paylaod);
+ break;
+
+ case MSG_PROBE_THREAD:
+ createThreadData(data, paylaod);
+ break;
+
+ case MSG_PROBE_CUSTOM:
+ createCustomData(data, paylaod);
+ break;
+
+ case MSG_PROBE_SYNC:
+ createSyncData(data, paylaod);
+ break;
+ case MSG_DATA_SYSTEM:
+ createSystemData(data, paylaod);
+ break;
+ case MSG_DATA_SAMPLE:
+ case MSG_FUNCTION_ENTRY:
+ case MSG_FUNCTION_EXIT:
+ createProfileData(data, paylaod);
+ break;
+
+ case LogCenterConstants.LOG_USER_FUNCTION:
+ createUserFunctionData(data, paylaod);
+ break;
+ default:
+ break;
+ }
+ }
+
+ private static void createCommonData(LogData data, byte[] payload) {
+ ProbeCommonData probeData = ((ProbeCommonData) data);
+ int apiId = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ int pid = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ int tid = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ ArgsInfo argInfo = LogDataUtils.parseArgs(payload, index);
+ String args = argInfo.getArgs();
+ index = argInfo.getLastIndex();
+ long ret = ByteUtils.toLong(payload, index);
+ index += LONG_SIZE;
+ long errno = ByteUtils.toLong(payload, index);
+ index += LONG_SIZE;
+ int internalCall = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ long callerAddress = ByteUtils.toLong(payload, index);
+ index += LONG_SIZE;
+ int reserved1 = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ int reserved2 = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+
+ probeData.setApiId(apiId);
+ probeData.setPid(pid);
+ probeData.setTid(tid);
+ probeData.setArgs(args);
+ probeData.setReturn(ret);
+ probeData.setErrno(errno);
+ probeData.setInternalCall(internalCall);
+ probeData.setCallerAddress(callerAddress);
+ probeData.setReserved1(reserved1);
+ probeData.setReserved2(reserved2);
+ }
+
+ private static void createMemoryData(LogData log, byte[] payload) {
+ createCommonData(log, payload);
+ MemoryData data = (MemoryData) log;
+
+ int size = ByteUtils.toInt(payload, index);
+ index += LONG_SIZE;
+ int apiType = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ long address = ByteUtils.toLong(payload, index);
+
+ data.setSize(size);
+ data.setApitype(apiType);
+ data.setAddress(address);
+ }
+
+ private static void createControlData(LogData log, byte[] payload) {
+ createCommonData(log, payload);
+ ControlData data = (ControlData) log;
+
+ int length = LogDataUtils.getStringLength(index, payload);
+ byte[] temp = new byte[length];
+ System.arraycopy(payload, index, temp, 0, length);
+ String parentName = new String(temp);
+ index += length;
+
+ length = LogDataUtils.getStringLength(index, payload);
+ temp = new byte[length];
+ System.arraycopy(payload, index, temp, 0, length);
+ String parentClassName = new String(temp);
+ index += length;
+
+ long parentPointer = ByteUtils.toLong(payload, index);
+ index += LONG_SIZE;
+
+ length = LogDataUtils.getStringLength(index, payload);
+ temp = new byte[length];
+ System.arraycopy(payload, index, temp, 0, length);
+ String childName = new String(temp);
+ index += length;
+
+ length = LogDataUtils.getStringLength(index, payload);
+ temp = new byte[length];
+ System.arraycopy(payload, index, temp, 0, length);
+ String childClassName = new String(temp);
+ index += length;
+
+ long childPointer = ByteUtils.toLong(payload, index);
+
+ data.setParentName(parentName);
+ data.setParentClassName(parentClassName);
+ data.setParentPointer(parentPointer);
+ data.setChildName(childName);
+ data.setChildClassName(childClassName);
+ data.setChildPointer(childPointer);
+ }
+
+ private static void createUIEventData(LogData log, byte[] payload) {
+ createCommonData(log, payload);
+ UIEventData data = (UIEventData) log;
+
+ int eventType = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ int detailType = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ int x = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ int y = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ int info1 = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ int info2 = ByteUtils.toInt(payload, index);
+
+ data.setEventType(eventType);
+ data.setDetailType(detailType);
+ data.setX(x);
+ data.setY(y);
+ data.setInfo1(info1);
+ data.setInfo2(info2);
+ }
+
+ private static void createFileData(LogData log, byte[] payload) {
+ createCommonData(log, payload);
+ FileData data = (FileData) log;
+
+ long size = ByteUtils.toLong(payload, index);
+ index += LONG_SIZE;
+ int fdValue = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ int fdType = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ int fdApiType = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ long fileSize = ByteUtils.toLong(payload, index);
+ index += LONG_SIZE;
+ String filePath = LogDataUtils.getString(index, payload);
+
+ data.setSize(size);
+ data.setFdValue(fdValue);
+ data.setFdType(fdType);
+ data.setFdApiType(fdApiType);
+ data.setFileSize(fileSize);
+ data.setFilePath(filePath);
+ }
+
+ private static void createLifecycleData(LogData log, byte[] payload) {
+ createCommonData(log, payload);
+ }
+
+ private static void createScreenshotData(LogData log, byte[] payload) {
+ createCommonData(log, payload);
+ ScreenShotData data = (ScreenShotData) log;
+
+ int length = LogDataUtils.getStringLength(index, payload);
+ byte[] temp = new byte[length];
+ System.arraycopy(payload, index, temp, 0, length);
+ String imageFilePath = new String(temp);
+ index += length;
+
+ int orientation = ByteUtils.toInt(payload, index);
+
+ data.setImageFilePath(imageFilePath);
+ data.setOrientation(orientation);
+ }
+
+ private static void createSceneData(LogData log, byte[] payload) {
+ createCommonData(log, payload);
+ SceneData data = (SceneData) log;
+
+ int length = LogDataUtils.getStringLength(index, payload);
+ byte[] temp = new byte[length];
+ System.arraycopy(payload, index, temp, 0, length);
+ String sceneName = new String(temp);
+ index += length;
+
+ length = LogDataUtils.getStringLength(index, payload);
+ temp = new byte[length];
+ System.arraycopy(payload, index, temp, 0, length);
+ String formName = new String(temp);
+ index += length;
+
+ long formPointer = ByteUtils.toLong(payload, index);
+
+ length = LogDataUtils.getStringLength(index, payload);
+ temp = new byte[length];
+ System.arraycopy(payload, index, temp, 0, length);
+ String panelName = new String(temp);
+ index += length;
+
+ long panelPointer = ByteUtils.toLong(payload, index);
+ index += LONG_SIZE;
+ int transitionTime = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ int userTransitionTime = ByteUtils.toInt(payload, index);
+
+ data.setSceneName(sceneName);
+ data.setFormName(formName);
+ data.setFormPointer(formPointer);
+ data.setPanelName(panelName);
+ data.setPanelPointer(panelPointer);
+ data.setTransitionTime(transitionTime);
+ data.setUserTransitionTime(userTransitionTime);
+ }
+
+ private static void createThreadData(LogData log, byte[] payload) {
+ createCommonData(log, payload);
+ ThreadData data = (ThreadData) log;
+
+ long pThreadId = ByteUtils.toLong(payload, index);
+ index += LONG_SIZE;
+ long ospThreadId = ByteUtils.toLong(payload, index);
+ index += LONG_SIZE;
+ int threadType = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ int apiType = ByteUtils.toInt(payload, index);
+
+ data.setpThreadId(pThreadId);
+ data.setOspThreadId(ospThreadId);
+ data.setThreadType(threadType);
+ data.setApiType(apiType);
+ }
+
+ private static void createCustomData(LogData log, byte[] payload) {
+ createCommonData(log, payload);
+ CustomData data = (CustomData) log;
+
+ int handle = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ int type = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+
+ int length = LogDataUtils.getStringLength(index, payload);
+ byte[] temp = new byte[length];
+ System.arraycopy(payload, index, temp, 0, length);
+ String name = new String(temp);
+ index += length;
+
+ int color = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ double value = ByteUtils.toDouble(payload, index);
+
+ data.setHandle(handle);
+ data.setType(type);
+ data.setName(name);
+ data.setColor(color);
+ data.setValue(value);
+ }
+
+ private static void createSyncData(LogData log, byte[] payload) {
+ createCommonData(log, payload);
+ SyncData data = (SyncData) log;
+
+ long syncValue = ByteUtils.toLong(payload, index);
+ index += LONG_SIZE;
+ int syncType = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ int apiType = ByteUtils.toInt(payload, index);
+
+ data.setSyncValue(syncValue);
+ data.setSyncType(syncType);
+ data.setApiType(apiType);
+ }
+
+ private static void createSystemData(LogData log, byte[] payload) {
+ SystemData data = (SystemData) log;
+ int coreCount = DACommunicator.getSelectedDevice().getTargetInfo()
+ .getCpuCount();
+
+ int energy = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+
+ int wifi = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+
+ int btStatus = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+
+ int gpsStatus = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+
+ int brightness = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+
+ int camera = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+
+ int sound = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+
+ int audio = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+
+ int vibration = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+
+ int voltage = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+
+ int rssi = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+
+ int video = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+
+ int call = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+
+ int dnet = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+
+ String cpuFrequency = parseCpu(index, payload);
+ index += (FLOAT_SIZE * coreCount);
+
+ float appCpuUsage = ByteUtils.toFloat(payload, index);
+ index += FLOAT_SIZE;
+
+ String cpuLoad = parseCpu(index, payload);
+ index += (FLOAT_SIZE * coreCount);
+
+ int virtualMemory = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+
+ int residentMemory = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+
+ int sharedMemory = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+
+ int pssMemory = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+
+ int totalAllocSize = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+
+ long systemMemoryTotal = ByteUtils.toLong(payload, index);
+ index += LONG_SIZE;
+
+ long systemMemoryUsed = ByteUtils.toLong(payload, index);
+ index += LONG_SIZE;
+
+ int totalUsedDrive = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+
+ int threadCount = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+
+ String threadLoad = parseLoad(index, payload);
+ index += (threadCount * (INT_SIZE + FLOAT_SIZE));
+
+ int processCount = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+
+ String processLoad = parseLoad(index, payload);
+ index += (processCount * (INT_SIZE + FLOAT_SIZE));
+
+ int diskReadSize = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+
+ int diskWriteSize = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+
+ int networkSendSize = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+
+ int networkReceiveSize = ByteUtils.toInt(payload, index);
+
+ data.setEnergy(energy);
+ data.setWifi(wifi);
+ data.setBtStatus(btStatus);
+ data.setGpsStatus(gpsStatus);
+ data.setBrightness(brightness);
+ data.setCamera(camera);
+ data.setSound(sound);
+ data.setAudio(audio);
+ data.setVibration(vibration);
+ data.setVoltage(voltage);
+ data.setRssi(rssi);
+ data.setVideo(video);
+ data.setCall(call);
+ data.setDnet(dnet);
+ data.setCpuFrequency(cpuFrequency);
+ data.setAppCpuUsage(appCpuUsage);
+ data.setCpuLoad(cpuLoad);
+ data.setVirtualMemory(virtualMemory);
+ data.setResidentMemory(residentMemory);
+ data.setSharedMemory(sharedMemory);
+ data.setPssMemory(pssMemory);
+ data.setTotalAllocSize(totalAllocSize);
+ data.setSystemMemoryTotal(systemMemoryTotal);
+ data.setSystemMemoryUsed(systemMemoryUsed);
+ data.setTotalUsedDrive(totalUsedDrive);
+ data.setThreadCount(threadCount);
+ data.setThreadLoad(threadLoad);
+ data.setProcessCount(processCount);
+ data.setProcessLoad(processLoad);
+ data.setDiskReadSize(diskReadSize);
+ data.setDiskWriteSize(diskWriteSize);
+ data.setNetworkSendSize(networkSendSize);
+ data.setNetworkReceiveSize(networkReceiveSize);
+ }
+
+ private static void createProfileData(LogData log, byte[] payload) {
+ ProfileData data = (ProfileData) log;
+
+ long pcAddr = 0; // profiling common
+ int pid = 0; // profiling common
+ int tid = 0; // profiling common
+ int cpuNum = 0; // profiling common
+ long ret = 0;
+
+ switch (data.getId()) {
+ case MSG_FUNCTION_ENTRY:
+ pcAddr = ByteUtils.toLong(payload, index);
+ index += LONG_SIZE;
+ long callerPcAddr = ByteUtils.toLong(payload, index);
+ index += LONG_SIZE;
+
+ int probeType = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ int probeSubType = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ pid = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ tid = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ cpuNum = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ ArgsInfo info = LogDataUtils.parseArgs(payload, index);
+ String args = info.getArgs();
+
+ data.setPcAddr(pcAddr);
+ data.setCallerPcAddr(callerPcAddr);
+ data.setProbeType(probeType);
+ data.setProbeSubType(probeSubType);
+ data.setPid(pid);
+ data.setTid(tid);
+ data.setCpuNum(cpuNum);
+ data.setArgs(args);
+ break;
+ case MSG_FUNCTION_EXIT:
+ pid = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ tid = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ pcAddr = ByteUtils.toLong(payload, index);
+ index += LONG_SIZE;
+ cpuNum = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ ret = ByteUtils.toLong(payload, index);
+
+ data.setPid(pid);
+ data.setTid(tid);
+ data.setPcAddr(pcAddr);
+ data.setCpuNum(cpuNum);
+ data.setRet(ret);
+ break;
+ case MSG_CONTEXT_SWITCH_ENTRY:
+ case MSG_CONTEXT_SWITCH_EXIT:
+ pcAddr = ByteUtils.toLong(payload, index);
+ index += LONG_SIZE;
+ pid = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ tid = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ cpuNum = ByteUtils.toInt(payload, index);
+
+ data.setPcAddr(pcAddr);
+ data.setPid(pid);
+ data.setTid(tid);
+ data.setCpuNum(cpuNum);
+ break;
+ case MSG_DATA_SAMPLE:
+ pid = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ pcAddr = ByteUtils.toLong(payload, index);
+ index += LONG_SIZE;
+ tid = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ cpuNum = ByteUtils.toInt(payload, index);
+
+ data.setPid(pid);
+ data.setPcAddr(pcAddr);
+ data.setTid(tid);
+ data.setCpuNum(cpuNum);
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ private static void createUserFunctionData(LogData log, byte[] payload) {
+ createCommonData(log, payload);
+ UserFunctionData data = (UserFunctionData) log;
+
+ long lowPc = ByteUtils.toLong(payload, index);
+ index += LONG_SIZE;
+ long highPc = ByteUtils.toLong(payload, index);
+ index += LONG_SIZE;
+ int type = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ long elapsedTime = ByteUtils.toLong(payload, index);
+ index += LONG_SIZE;
+ long pcAddr = ByteUtils.toLong(payload, index);
+
+ data.setLowPc(lowPc);
+ data.setHighPc(highPc);
+ data.setType(type);
+ data.setElapsedTime(elapsedTime);
+ data.setPcAddr(pcAddr);
+ }
+
+ private static String parseCpu(int start, byte[] payload) {
+ int coreCount = DACommunicator.getSelectedDevice().getTargetInfo()
+ .getCpuCount();
+ StringBuffer buffer = new StringBuffer();
+ for (int i = 0; i < coreCount; i++) {
+ float value = ByteUtils.toFloat(payload, start);
+ start += FLOAT_SIZE;
+ buffer.append(value);
+ if (i + 1 != coreCount) {
+ buffer.append(',');
+ }
+ }
+ return buffer.toString();
+ }
+
+ private static String parseLoad(int start, byte[] payload) {
+ int backPos = start - INT_SIZE;
+ int count = ByteUtils.toInt(payload, backPos);
+ StringBuffer outBuf = new StringBuffer();
+ for (int ii = 0; ii < count; ii++) {
+ int tid = ByteUtils.toInt(payload, start);
+ start += INT_SIZE;
+ outBuf.append(tid).append(CommonConstants.COMMA);
+ float f = ByteUtils.toFloat(payload, start);
+ outBuf.append(f);
+ start += FLOAT_SIZE;
+ if (ii + 1 != count) {
+ outBuf.append(',');
+ }
+ }
+
+ return outBuf.toString();
+ }
+}
package org.tizen.dynamicanalyzer.swap.model.probe2;
-import org.tizen.dynamicanalyzer.common.CommonConstants;
-import org.tizen.dynamicanalyzer.swap.model.ByteUtils;
+import org.tizen.dynamicanalyzer.swap.model.data.BasicDataMessage;
public class FileData extends ProbeCommonData {
- private int sizeIndex = 0;
- private int fdValueIndex = 0;
- private int fdTypeIndex = 0;
- private int fdApiTypeIndex = 0;
- private int fileSizeIndex = 0;
- private int filePathIndex = 0;
+ long size = 0;
+ int fdValue = 0;
+ int fdType = 0; // TODO: short
+ int fdApiType = 0; // TODO: short
+ long fileSize = 0;
+ String filePath = null;
- public FileData(BasicDataInterface data) {
- super(data);
- sizeIndex = getCommonColumnsSize();
- fdValueIndex = sizeIndex + CommonConstants.INT_SIZE;
- fdTypeIndex = fdValueIndex + CommonConstants.INT_SIZE;
- fdApiTypeIndex = fdTypeIndex + CommonConstants.INT_SIZE;
- fileSizeIndex = fdApiTypeIndex + CommonConstants.INT_SIZE;
- filePathIndex = fileSizeIndex + CommonConstants.INT_SIZE;
+ public long getSize() {
+ return size;
+ }
+
+ public void setSize(long size) {
+ this.size = size;
+ }
+
+ public int getFdValue() {
+ return fdValue;
+ }
+
+ public void setFdValue(int fdValue) {
+ this.fdValue = fdValue;
}
- public int getSize() {
- return ByteUtils.toInt(payload, sizeIndex);
+ public int getFdType() {
+ return fdType;
}
- public int getFDValue() {
- return ByteUtils.toInt(payload, fdValueIndex);
+ public void setFdType(int fdType) {
+ this.fdType = fdType;
}
- public int getFDType() {
- return ByteUtils.toInt(payload, fdTypeIndex);
+ public int getFdApiType() {
+ return fdApiType;
}
- public int getFDApiType() {
- return ByteUtils.toInt(payload, fdApiTypeIndex);
+ public void setFdApiType(int fdApiType) {
+ this.fdApiType = fdApiType;
}
- public int getFileSize() {
- return ByteUtils.toInt(payload, fileSizeIndex);
+ public long getFileSize() {
+ return fileSize;
+ }
+
+ public void setFileSize(long fileSize) {
+ this.fileSize = fileSize;
}
public String getFilePath() {
- int length = getStringLength(filePathIndex);
- byte[] temp = new byte[length];
- System.arraycopy(payload, filePathIndex, temp, 0, length);
- return new String(temp);
+ return filePath;
+ }
+
+ public void setFilePath(String filePath) {
+ this.filePath = filePath;
+ }
+
+ public FileData(BasicDataMessage data) {
+ super(data);
}
@Override
public int getKey() {
- Integer key = getFDValue();
+ Integer key = getFdValue();
return key.hashCode();
}
}
package org.tizen.dynamicanalyzer.swap.model.probe2;
+import org.tizen.dynamicanalyzer.swap.model.data.BasicDataMessage;
+
public class LifeCycleData extends ProbeCommonData {
- public LifeCycleData(BasicDataInterface data) {
+ public LifeCycleData(BasicDataMessage data) {
super(data);
}
-
}
import org.tizen.dynamicanalyzer.common.CommonConstants;
import org.tizen.dynamicanalyzer.communicator.DACommunicator;
-import org.tizen.dynamicanalyzer.swap.model.ByteUtils;
+import org.tizen.dynamicanalyzer.swap.model.data.BasicDataMessage;
public class LogData {
- public static int API_ID_INDEX = 0;
- public static int PID_INDEX = API_ID_INDEX + CommonConstants.INT_SIZE;
- public static int TID_INDEX = PID_INDEX + CommonConstants.INT_SIZE;
public static boolean isSWAP = false;
- protected BasicDataInterface basicData = null;
- protected byte[] payload = null;
+ int id = -1;
+ int seq = -1;
+ long time = 0;
- public LogData(BasicDataInterface data) {
+ public LogData(BasicDataMessage data) {
isSWAP = DACommunicator.isSWAPVersion();
- basicData = data;
- payload = data.getPayload();
+ id = data.getId();
+ seq = data.getSeq();
+ time = data.getTime();
}
- public int getId() {
- return basicData.getId();
- }
+ // public int getId() {
+ // return basicData.getId();
+ // }
+ //
+ // public int getSeq() {
+ // return basicData.getSeq();
+ // }
+ //
+ // public long getTime() {
+ // return basicData.getTime();
+ // }
+ //
+ // public void setTime(long time) {
+ // basicData.setTime(time);
+ // }
+ //
+ // public byte[] getPayload() {
+ // return payload;
+ // }
+ //
+ // protected int getStringLength(int start) {
+ // int length = 0;
+ // for (int i = start; i < payload.length; i++, length++) {
+ // if (payload[i] == 0) {
+ // return length + 1;
+ // }
+ // }
+ // return payload.length;
+ // }
- public int getSeq() {
- return basicData.getSeq();
- }
+ // protected String makeArgs(int start) {
+ // int countOfArgs = ByteUtils.toInt(payload, start);
+ // start += CommonConstants.INT_SIZE;
+ // StringBuffer buffer = new StringBuffer();
+ // for (int ii = 0; ii < countOfArgs; ii++) {
+ // char c = (char) payload[start];
+ // start += 1;
+ // switch (c) {
+ // case 'c':
+ // buffer.append((payload[start]));
+ // start += 1;
+ // break;
+ // case 'd':
+ // int iValue = ByteUtils.toInt(payload, start);
+ // buffer.append(iValue);
+ // start += Integer.SIZE / Byte.SIZE;
+ // break;
+ // case 'x':
+ // long lValue = ByteUtils.toLong(payload, start);
+ // buffer.append(lValue);
+ // start += Long.SIZE / Byte.SIZE;
+ // break;
+ // case 'p':
+ // long pValue = ByteUtils.toLong(payload, start);
+ // buffer.append(Long.toHexString(pValue));
+ // start += Long.SIZE / Byte.SIZE;
+ // break;
+ // case 'f':
+ // float fValue = ByteUtils.toFloat(payload, start);
+ // buffer.append(fValue);
+ // start += Float.SIZE / Byte.SIZE;
+ // break;
+ // case 'w':
+ // double dValue = ByteUtils.toDouble(payload, start);
+ // buffer.append(dValue);
+ // start += Double.SIZE / Byte.SIZE;
+ // break;
+ // case 's':
+ // for (int iii = start; iii < payload.length; iii++) {
+ // if (payload[iii] != 0) {
+ // buffer.append((char) payload[iii]);
+ // } else {
+ // start = iii + 1;
+ // }
+ // }
+ // break;
+ // default:
+ // break;
+ // }
+ // if (ii + 1 != countOfArgs) {
+ // buffer.append(',');
+ // }
+ // }
+ // return buffer.toString();
+ // }
- public long getTime() {
- return basicData.getTime();
+ public int getKey() {
+ Integer key = getSeq();
+ return key.hashCode();
}
- public void setTime(long time) {
- basicData.setTime(time);
- }
+ // protected static String getQuestionMarks(int count) {
+ // // row number
+ // // id
+ // // seq
+ // // time
+ // StringBuffer buf = new StringBuffer();
+ // for (int i = 0; i < count; i++) {
+ // buf.append("? ");
+ // if (i + 1 != count) {
+ // buf.append(CommonConstants.COMMA);
+ // }
+ // }
+ // return buf.toString();
+ // }
- public byte[] getPayload() {
- return payload;
+ // indicate DB row number
+ public int getLogNum() {
+ return 0;
}
- protected int getStringLength(int start) {
- int length = 0;
- for (int i = start; i < payload.length; i++, length++) {
- if (payload[i] == 0) {
- return length + 1;
- }
- }
- return payload.length;
+ public int getId() {
+ return id;
}
- protected String makeArgs(int start) {
- int countOfArgs = ByteUtils.toInt(payload, start);
- start += CommonConstants.INT_SIZE;
- StringBuffer buffer = new StringBuffer();
- for (int ii = 0; ii < countOfArgs; ii++) {
- char c = (char) payload[start];
- start += 1;
- switch (c) {
- case 'c':
- buffer.append((payload[start]));
- start += 1;
- break;
- case 'd':
- int iValue = ByteUtils.toInt(payload, start);
- buffer.append(iValue);
- start += Integer.SIZE / Byte.SIZE;
- break;
- case 'x':
- long lValue = ByteUtils.toLong(payload, start);
- buffer.append(lValue);
- start += Long.SIZE / Byte.SIZE;
- break;
- case 'p':
- long pValue = ByteUtils.toLong(payload, start);
- buffer.append(Long.toHexString(pValue));
- start += Long.SIZE / Byte.SIZE;
- break;
- case 'f':
- float fValue = ByteUtils.toFloat(payload, start);
- buffer.append(fValue);
- start += Float.SIZE / Byte.SIZE;
- break;
- case 'w':
- double dValue = ByteUtils.toDouble(payload, start);
- buffer.append(dValue);
- start += Double.SIZE / Byte.SIZE;
- break;
- case 's':
- for (int iii = start; iii < payload.length; iii++) {
- if (payload[iii] != 0) {
- buffer.append((char) payload[iii]);
- } else {
- start = iii + 1;
- }
- }
- break;
- default:
- break;
- }
- if (ii + 1 != countOfArgs) {
- buffer.append(',');
- }
- }
- return buffer.toString();
+ public void setId(int id) {
+ this.id = id;
}
- public LogData getClone() {
- LogData clone = LogDataFactory.createInstance(basicData);
- return clone;
+ public int getSeq() {
+ return seq;
}
- public int getKey() {
- Integer key = getSeq();
- return key.hashCode();
+ public void setSeq(int seq) {
+ this.seq = seq;
}
- protected static String getQuestionMarks(int count) {
- // row number
- // id
- // seq
- // time
- StringBuffer buf = new StringBuffer();
- for (int i = 0; i < count; i++) {
- buf.append("? ");
- if (i + 1 != count) {
- buf.append(CommonConstants.COMMA);
- }
- }
- return buf.toString();
+ public long getTime() {
+ return time;
}
- // indicate DB row number
- public int getLogNum() {
- return 0;
+ public void setTime(long time) {
+ this.time = time;
}
}
import java.util.List;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
-import org.tizen.dynamicanalyzer.communicator.DACommunicator;
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
+import org.tizen.dynamicanalyzer.swap.model.data.BasicDataMessage;
public class LogDataFactory {
private static List<Integer> logList = new ArrayList<Integer>();
+ private static int memoryLogNum = 0;
+ private static int controlLogNum = 0;
+ private static int uiEventLogNum = 0;
+ private static int fileLogNum = 0;
+ private static int lifecycleLogNum = 0;
+ private static int screenshotLogNum = 0;
+ private static int sceneLogNum = 0;
+ private static int threadLogNum = 0;
+ private static int customLogNum = 0;
+ private static int syncLogNum = 0;
+ private static int sampleLogNum = 0;
+ private static int systemLogNum = 0;
+ private static int userFunctionLogNum = 0;
+
private LogDataFactory() {
// is static class
}
public static void initLogList() {
logList.clear();
-// if (DACommunicator.isSWAPVersion()) {
- logList.add(AnalyzerConstants.MSG_PROBE_MEMORY);
- logList.add(AnalyzerConstants.MSG_PROBE_UICONTROL);
- logList.add(AnalyzerConstants.MSG_PROBE_UIEVENT);
- logList.add(AnalyzerConstants.MSG_PROBE_FILE);
- logList.add(AnalyzerConstants.MSG_PROBE_LIFECYCLE);
- logList.add(AnalyzerConstants.MSG_PROBE_SCREENSHOT);
- logList.add(AnalyzerConstants.MSG_PROBE_SCENE);
- logList.add(AnalyzerConstants.MSG_PROBE_THREAD);
- logList.add(AnalyzerConstants.MSG_PROBE_CUSTOM);
- logList.add(AnalyzerConstants.MSG_PROBE_SYNC);
- logList.add(AnalyzerConstants.MSG_DATA_SAMPLE);
- logList.add(AnalyzerConstants.MSG_DATA_SYSTEM);
- logList.add(LogCenterConstants.LOG_USER_FUNCTION);
-// } else {
-// logList.add(LogCenterConstants.LOG_MEMORY);
-// logList.add(LogCenterConstants.LOG_CONTROL);
-// logList.add(LogCenterConstants.LOG_RECODER);
-// logList.add(LogCenterConstants.LOG_RESOURCE);
-// logList.add(LogCenterConstants.LOG_LIFECYCLE);
-// logList.add(LogCenterConstants.LOG_SCREENSHOT);
-// logList.add(LogCenterConstants.LOG_SCENE);
-// logList.add(LogCenterConstants.LOG_THREAD);
-// logList.add(LogCenterConstants.LOG_CUSTOM_CHART);
-// logList.add(LogCenterConstants.LOG_SYNC);
-// logList.add(LogCenterConstants.LOG_USER_FUNCTION);
-// logList.add(LogCenterConstants.LOG_PROFILING);
-// logList.add(LogCenterConstants.LOG_DEVICE);
-// }
-
+ logList.add(AnalyzerConstants.MSG_PROBE_MEMORY);
+ logList.add(AnalyzerConstants.MSG_PROBE_UICONTROL);
+ logList.add(AnalyzerConstants.MSG_PROBE_UIEVENT);
+ logList.add(AnalyzerConstants.MSG_PROBE_FILE);
+ logList.add(AnalyzerConstants.MSG_PROBE_LIFECYCLE);
+ logList.add(AnalyzerConstants.MSG_PROBE_SCREENSHOT);
+ logList.add(AnalyzerConstants.MSG_PROBE_SCENE);
+ logList.add(AnalyzerConstants.MSG_PROBE_THREAD);
+ logList.add(AnalyzerConstants.MSG_PROBE_CUSTOM);
+ logList.add(AnalyzerConstants.MSG_PROBE_SYNC);
+ logList.add(AnalyzerConstants.MSG_DATA_SAMPLE);
+ logList.add(AnalyzerConstants.MSG_DATA_SYSTEM);
+ logList.add(LogCenterConstants.LOG_USER_FUNCTION);
}
- public static LogData createInstance(BasicDataInterface input) {
+ public static LogData createInstance(BasicDataMessage input) {
int id = input.getId();
+ byte[] payload = input.getPayload();
LogData output = null;
switch (id) {
case AnalyzerConstants.MSG_PROBE_MEMORY:
case LogCenterConstants.LOG_PROFILING:
// profiling sample log
output = new ProfileData(input);
+ ((ProfileData) output).setCallstack(input.getCallstack());
break;
case AnalyzerConstants.MSG_DATA_SYSTEM:
case LogCenterConstants.LOG_DEVICE:
output = new SystemData(input);
break;
default:
-
+ break;
}
+ DataFactory.createData(output, payload);
return output;
}
}
return count;
}
+
+ public static int getLogCountById(int id) {
+ switch (id) {
+ case AnalyzerConstants.MSG_PROBE_MEMORY:
+ // memory
+ return memoryLogNum++;
+ case AnalyzerConstants.MSG_PROBE_UICONTROL:
+ // ui control
+ return controlLogNum++;
+ case AnalyzerConstants.MSG_PROBE_UIEVENT:
+ return uiEventLogNum++;
+ case AnalyzerConstants.MSG_PROBE_FILE:
+ return fileLogNum++;
+ case AnalyzerConstants.MSG_PROBE_LIFECYCLE:
+ return lifecycleLogNum++;
+ case AnalyzerConstants.MSG_PROBE_SCREENSHOT:
+ return screenshotLogNum++;
+ case AnalyzerConstants.MSG_PROBE_SCENE:
+ return sceneLogNum++;
+ case AnalyzerConstants.MSG_PROBE_THREAD:
+ return threadLogNum++;
+ case AnalyzerConstants.MSG_PROBE_CUSTOM:
+ return customLogNum++;
+ case AnalyzerConstants.MSG_PROBE_SYNC:
+ return syncLogNum++;
+ case LogCenterConstants.LOG_USER_FUNCTION:
+ return userFunctionLogNum++;
+ case AnalyzerConstants.MSG_DATA_SAMPLE:
+ return sampleLogNum++;
+ case AnalyzerConstants.MSG_DATA_SYSTEM:
+ return systemLogNum++;
+ default:
+
+ }
+ return 0;
+ }
}
--- /dev/null
+package org.tizen.dynamicanalyzer.swap.model.probe2;
+
+import static org.tizen.dynamicanalyzer.common.CommonConstants.DOUBLE_SIZE;
+import static org.tizen.dynamicanalyzer.common.CommonConstants.FLOAT_SIZE;
+import static org.tizen.dynamicanalyzer.common.CommonConstants.INT_SIZE;
+import static org.tizen.dynamicanalyzer.common.CommonConstants.LONG_SIZE;
+
+import org.tizen.dynamicanalyzer.swap.model.ByteUtils;
+
+public class LogDataUtils {
+
+ public static ArgsInfo parseArgs(byte[] payload, int index) {
+ ArgsInfo args = new ArgsInfo();
+ int countOfArgs = ByteUtils.toInt(payload, index);
+ index += INT_SIZE;
+ StringBuffer buffer = new StringBuffer();
+ for (int ii = 0; ii < countOfArgs; ii++) {
+ char c = (char) payload[index];
+ index += 1;
+ switch (c) {
+ case 'c':
+ buffer.append((payload[index]));
+ index += 1;
+ break;
+ case 'd':
+ int iValue = ByteUtils.toInt(payload, index);
+ buffer.append(iValue);
+ index += Integer.SIZE / Byte.SIZE;
+ break;
+ case 'x':
+ long lValue = ByteUtils.toLong(payload, index);
+ buffer.append(lValue);
+ index += LONG_SIZE;
+ break;
+ case 'p':
+ long pValue = ByteUtils.toLong(payload, index);
+ buffer.append(Long.toHexString(pValue));
+ index += LONG_SIZE;
+ break;
+ case 'f':
+ float fValue = ByteUtils.toFloat(payload, index);
+ buffer.append(fValue);
+ index += FLOAT_SIZE;
+ break;
+ case 'w':
+ double dValue = ByteUtils.toDouble(payload, index);
+ buffer.append(dValue);
+ index += DOUBLE_SIZE;
+ break;
+ case 's':
+ for (int iii = index; iii < payload.length; iii++) {
+ if (payload[iii] != 0) {
+ buffer.append((char) payload[iii]);
+ } else {
+ index = iii + 1;
+ break;
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ if (ii + 1 != countOfArgs) {
+ buffer.append(',');
+ }
+ }
+
+ args.setArgs(buffer.toString());
+ args.setLastIndex(index);
+
+ return args;
+ }
+
+ public static int getStringLength(int start, byte[] payload) {
+ int length = 0;
+ for (int i = start; i < payload.length; i++, length++) {
+ if (payload[i] == 0) {
+ length++;
+ break;
+ }
+ }
+ return length;
+ }
+
+ public static String getString(int start, byte[] payload) {
+ int length = LogDataUtils.getStringLength(start, payload);
+ byte[] temp = new byte[length];
+ System.arraycopy(payload, start, temp, 0, length);
+ return new String(temp);
+ }
+}
package org.tizen.dynamicanalyzer.swap.model.probe2;
-import org.tizen.dynamicanalyzer.common.CommonConstants;
-import org.tizen.dynamicanalyzer.swap.model.ByteUtils;
+import org.tizen.dynamicanalyzer.swap.model.data.BasicDataMessage;
public class MemoryData extends ProbeCommonData {
- private int sizeIndex = 0;
- private int memoryApiTypeIndex = 0;
- private int addrIndex = 0;
+ long size = 0;
+ int apiType = 0; // TODO: short
+ long address = 0;
+
- public MemoryData(BasicDataInterface data) {
+ public MemoryData(BasicDataMessage data) {
super(data);
- sizeIndex = getCommonColumnsSize();
- memoryApiTypeIndex = sizeIndex + CommonConstants.INT_SIZE;
- addrIndex = memoryApiTypeIndex + CommonConstants.INT_SIZE;
}
- public int getSize() {
- return ByteUtils.toInt(payload, sizeIndex);
+
+ public long getSize() {
+ return size;
+ }
+
+
+ public void setSize(long size) {
+ this.size = size;
}
+
public int getMemoryApiType() {
- return ByteUtils.toInt(payload, memoryApiTypeIndex);
+ return apiType;
}
+
+ public void setApitype(int apiType) {
+ this.apiType = apiType;
+ }
+
+
public long getAddress() {
- return ByteUtils.toLong(payload, addrIndex);
+ return address;
+ }
+
+
+ public void setAddress(long address) {
+ this.address = address;
}
+
@Override
public int getKey() {
Long key = getAddress();
package org.tizen.dynamicanalyzer.swap.model.probe2;
-import static org.tizen.dynamicanalyzer.common.CommonConstants.DOUBLE_SIZE;
-import static org.tizen.dynamicanalyzer.common.CommonConstants.FLOAT_SIZE;
-import static org.tizen.dynamicanalyzer.common.CommonConstants.INT_SIZE;
-import static org.tizen.dynamicanalyzer.common.CommonConstants.LONG_SIZE;
-
-import org.tizen.dynamicanalyzer.swap.model.ByteUtils;
import org.tizen.dynamicanalyzer.swap.model.data.ApiNameManager;
+import org.tizen.dynamicanalyzer.swap.model.data.BasicDataMessage;
public class ProbeCommonData extends LogData {
- private String args = null;
-
- private static int rowNum = 0;
-
- private int apiIdIndex = 0;
- private int pidIndex = -1;
- private int tidIndex = -1;
- private int argIndex = -1;
- private int returnIndex = -1;
- private int errnoIndex = -1;
- private int internalCallIndex = -1;
- private int callerPcAddrIndex = -1;
- private int reserved1Index = -1;
- private int reserved2Index = -1;
- private int commonColumnsSize = -1;
+
+ protected int apiId = 0;
+ protected int pid = 0;
+ protected int tid = 0;
+ protected String args = null;
+ protected long ret = 0;
+ protected long errno = 0;
+ protected int internalCall = 0;
+ protected long callerAddress = 0;
+ protected int reserved1 = 0;
+ protected int reserved2 = 0;
private String apiName = null;
- public ProbeCommonData(BasicDataInterface data) {
+ public ProbeCommonData(BasicDataMessage data) {
super(data);
- apiIdIndex = 0;
- pidIndex = apiIdIndex + INT_SIZE;
- tidIndex = pidIndex + INT_SIZE;
- argIndex = tidIndex + INT_SIZE;
- returnIndex = parseArgs();
- errnoIndex = returnIndex + LONG_SIZE;
- internalCallIndex = errnoIndex + LONG_SIZE;
- callerPcAddrIndex = internalCallIndex + INT_SIZE;
- reserved1Index = callerPcAddrIndex + LONG_SIZE;
- reserved2Index = reserved1Index + INT_SIZE;
- commonColumnsSize = reserved2Index + INT_SIZE;
}
public int getApiId() {
- return ByteUtils.toInt(payload, apiIdIndex);
+ return apiId;
}
- public String getApiName() {
- if (null == apiName) {
- apiName = ApiNameManager.getApiName(getApiId());
- }
- return apiName;
+ public void setApiId(int apiId) {
+ this.apiId = apiId;
}
- public void setApiName(String name) {
- apiName = name;
+ public int getPid() {
+ return pid;
}
- public int getPid() {
- return ByteUtils.toInt(payload, pidIndex);
+ public void setPid(int pid) {
+ this.pid = pid;
}
public int getTid() {
- return ByteUtils.toInt(payload, tidIndex);
+ return tid;
}
- public long getTime() {
- return basicData.getTime();
+ public void setTid(int tid) {
+ this.tid = tid;
}
public String getArgs() {
return args;
}
+ public void setArgs(String args) {
+ this.args = args;
+ }
+
public long getReturn() {
- return ByteUtils.toLong(payload, returnIndex);
+ return ret;
+ }
+
+ public void setReturn(long ret) {
+ this.ret = ret;
}
public long getErrno() {
- return ByteUtils.toLong(payload, errnoIndex);
+ return errno;
+ }
+
+ public void setErrno(long errno) {
+ this.errno = errno;
}
public int getInternalCall() {
- return ByteUtils.toInt(payload, internalCallIndex);
+ return internalCall;
+ }
+
+ public void setInternalCall(int internalCall) {
+ this.internalCall = internalCall;
}
public long getCallerPcAddr() {
- return ByteUtils.toLong(payload, callerPcAddrIndex);
+ return callerAddress;
+ }
+
+ public void setCallerAddress(long callerAddress) {
+ this.callerAddress = callerAddress;
}
public int getReserved1() {
- return ByteUtils.toInt(payload, reserved1Index);
+ return reserved1;
+ }
+
+ public void setReserved1(int reserved1) {
+ this.reserved1 = reserved1;
}
public int getReserved2() {
- return ByteUtils.toInt(payload, reserved2Index);
- }
-
- public int getCommonColumnsSize() {
- return commonColumnsSize;
- }
-
- private int parseArgs() {
- int index = TID_INDEX + INT_SIZE;
- int countOfArgs = ByteUtils.toInt(payload, index);
- index += INT_SIZE;
- StringBuffer buffer = new StringBuffer();
- for (int ii = 0; ii < countOfArgs; ii++) {
- char c = (char) payload[index];
- index += 1;
- switch (c) {
- case 'c':
- buffer.append((payload[index]));
- index += 1;
- break;
- case 'd':
- int iValue = ByteUtils.toInt(payload, index);
- buffer.append(iValue);
- index += Integer.SIZE / Byte.SIZE;
- break;
- case 'x':
- long lValue = ByteUtils.toLong(payload, index);
- buffer.append(lValue);
- index += LONG_SIZE;
- break;
- case 'p':
- long pValue = ByteUtils.toLong(payload, index);
- buffer.append(Long.toHexString(pValue));
- index += LONG_SIZE;
- break;
- case 'f':
- float fValue = ByteUtils.toFloat(payload, index);
- buffer.append(fValue);
- index += FLOAT_SIZE;
- break;
- case 'w':
- double dValue = ByteUtils.toDouble(payload, index);
- buffer.append(dValue);
- index += DOUBLE_SIZE;
- break;
- case 's':
- for (int iii = index; iii < payload.length; iii++) {
- if (payload[iii] != 0) {
- buffer.append((char) payload[iii]);
- } else {
- index = iii + 1;
- break;
- }
- }
- break;
- default:
- break;
- }
- if (ii + 1 != countOfArgs) {
- buffer.append(',');
- }
+ return reserved2;
+ }
+
+ public void setReserved2(int reserved2) {
+ this.reserved2 = reserved2;
+ }
+
+ public String getApiName() {
+ if (null == apiName) {
+ apiName = ApiNameManager.getApiName(apiId);
}
- args = buffer.toString();
- return index;
+ return apiName;
}
+
+ public void setApiName(String apiName) {
+ this.apiName = apiName;
+ }
+
}
package org.tizen.dynamicanalyzer.swap.model.probe2;
-import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
-import org.tizen.dynamicanalyzer.common.CommonConstants;
-import org.tizen.dynamicanalyzer.swap.model.ByteUtils;
import org.tizen.dynamicanalyzer.swap.model.data.BasicDataMessage;
public class ProfileData extends LogData {
- private int pcAddrIndex = -1; // profiling common
- private int callerPcAddrIndex = -1; // function entry specific
- private int probeTypeIndex = -1;// function entry specific
- private int probeSubTypeIndex = -1;// function entry specific
- private int pidIndex = -1; // profiling common
- private int tidIndex = -1; // profiling common
- private int cpuNumIndex = -1; // profiling common
- private int argsIndex = -1; // function entry specific
- private int returnIndex = -1;
+ long pcAddr = 0; // profiling common
+ long callerPcAddr = 0; // function entry specific
+ int probeType = 0;// function entry specific
+ int probeSubType = 0;// function entry specific
+ int pid = 0; // profiling common
+ int tid = 0; // profiling common
+ int cpuNum = 0; // profiling common
+ String args = null; // function entry specific
+ long ret = 0;
- private int callstackIndex = -1;
+ String callstack = null;
- public ProfileData(BasicDataInterface data) {
+ public ProfileData(BasicDataMessage data) {
super(data);
- switch (getId()) {
- case AnalyzerConstants.MSG_DATA_FUNCTION_ENTRY:
- pcAddrIndex = 0;
- callerPcAddrIndex = pcAddrIndex + CommonConstants.LONG_SIZE;
- probeTypeIndex = callerPcAddrIndex + CommonConstants.LONG_SIZE;
- probeSubTypeIndex = probeTypeIndex + CommonConstants.INT_SIZE;
- pidIndex = probeSubTypeIndex + CommonConstants.INT_SIZE;
- tidIndex = pidIndex + CommonConstants.INT_SIZE;
- cpuNumIndex = tidIndex + CommonConstants.INT_SIZE;
- argsIndex = cpuNumIndex + CommonConstants.INT_SIZE;
- break;
- case AnalyzerConstants.MSG_DATA_FUNCTION_EXIT:
- pidIndex = 0;
- tidIndex = pidIndex + CommonConstants.INT_SIZE;
- pcAddrIndex = tidIndex + CommonConstants.INT_SIZE;
- cpuNumIndex = pcAddrIndex + CommonConstants.LONG_SIZE;
- returnIndex = cpuNumIndex + CommonConstants.INT_SIZE;
- break;
- case AnalyzerConstants.MSG_DATA_CONTEXT_SWITCH_ENTRY:
- case AnalyzerConstants.MSG_DATA_CONTEXT_SWITCH_EXIT:
- pcAddrIndex = 0;
- pidIndex = pcAddrIndex + CommonConstants.LONG_SIZE;
- tidIndex = pidIndex + CommonConstants.INT_SIZE;
- cpuNumIndex = tidIndex + CommonConstants.INT_SIZE;
- break;
- case AnalyzerConstants.MSG_DATA_SAMPLE:
- pidIndex = 0;
- pcAddrIndex = pidIndex + CommonConstants.INT_SIZE;
- break;
- default:
- break;
- }
- }
-
- public long getPcAddress() {
- return ByteUtils.toLong(payload, pcAddrIndex);
- }
-
- public long getCallerPcAddress() {
- return (callerPcAddrIndex < 0) ? -1 : ByteUtils.toLong(payload,
- callerPcAddrIndex);
+ }
+
+ public long getPcAddr() {
+ return pcAddr;
+ }
+
+ public void setPcAddr(long pcAddr) {
+ this.pcAddr = pcAddr;
+ }
+
+ public long getCallerPcAddr() {
+ return callerPcAddr;
+ }
+
+ public void setCallerPcAddr(long callerPcAddr) {
+ this.callerPcAddr = callerPcAddr;
}
public int getProbeType() {
- return (probeTypeIndex < 0) ? -1 : ByteUtils.toInt(payload,
- probeTypeIndex);
+ return probeType;
+ }
+
+ public void setProbeType(int probeType) {
+ this.probeType = probeType;
}
public int getProbeSubType() {
- return (probeSubTypeIndex < 0) ? -1 : ByteUtils.toInt(payload,
- probeSubTypeIndex);
+ return probeSubType;
+ }
+
+ public void setProbeSubType(int probeSubType) {
+ this.probeSubType = probeSubType;
}
public int getPid() {
- return (pidIndex < 0) ? -1 : ByteUtils.toInt(payload, pidIndex);
+ return pid;
+ }
+
+ public void setPid(int pid) {
+ this.pid = pid;
}
public int getTid() {
- return (tidIndex < 0) ? -1 : ByteUtils.toInt(payload, tidIndex);
+ return tid;
+ }
+
+ public void setTid(int tid) {
+ this.tid = tid;
}
public int getCpuNum() {
- return (cpuNumIndex < 0) ? -1 : ByteUtils.toInt(payload, cpuNumIndex);
+ return cpuNum;
}
- public String getCallstack() {
- return ((BasicDataMessage) basicData).getCallstack();
+ public void setCpuNum(int cpuNum) {
+ this.cpuNum = cpuNum;
}
public String getArgs() {
- return (argsIndex < 0) ? null : makeArgs(argsIndex);
+ return args;
+ }
+
+ public void setArgs(String args) {
+ this.args = args;
+ }
+
+ public long getRet() {
+ return ret;
}
- public long getReturn() {
- return (returnIndex < 0) ? -1 : ByteUtils.toLong(payload, returnIndex);
+ public void setRet(long ret) {
+ this.ret = ret;
}
public void setCallstack(String callstack) {
- // String[] temp = new String[log.length + 1];
- // System.arraycopy(log, 0, temp, 0, log.length);
- // temp[log.length] = callstack;
- // log = temp;
+ this.callstack = callstack;
+ }
+
+ public String getCallstack() {
+ return callstack;
}
}
package org.tizen.dynamicanalyzer.swap.model.probe2;
-import org.tizen.dynamicanalyzer.common.CommonConstants;
-import org.tizen.dynamicanalyzer.swap.model.ByteUtils;
+import org.tizen.dynamicanalyzer.swap.model.data.BasicDataMessage;
public class SceneData extends ProbeCommonData {
- private int sceneNameIndex = 0;
- private int formNameIndex = 0;
- private int formPointerIndex = 0;
- private int panelNameIndex = 0;
- private int panelPointerIndex = 0;
- private int transitionTimeIndex = 0;
- private int userTransitionTimeIndex = 0;
-
- public SceneData(BasicDataInterface data) {
+ String sceneName = null;
+ String formName = null;
+ long formPointer = 0;
+ String panelName = null;
+ long panelPointer = 0;
+ int transitionTime = 0;
+ int userTransitionTime = 0;
+
+ public SceneData(BasicDataMessage data) {
super(data);
- sceneNameIndex = getCommonColumnsSize();
- formNameIndex = getStringLength(sceneNameIndex);
- formPointerIndex = getStringLength(formNameIndex);
- panelNameIndex = formPointerIndex + CommonConstants.LONG_SIZE;
- panelPointerIndex = getStringLength(panelNameIndex);
- transitionTimeIndex = panelPointerIndex + CommonConstants.LONG_SIZE;
- userTransitionTimeIndex = transitionTimeIndex
- + CommonConstants.INT_SIZE;
}
public String getSceneName() {
- byte[] temp = new byte[formNameIndex - sceneNameIndex];
- System.arraycopy(payload, sceneNameIndex, temp, 0, temp.length);
- return new String(temp);
+ return sceneName;
+ }
+
+ public void setSceneName(String sceneName) {
+ this.sceneName = sceneName;
}
public String getFormName() {
- byte[] temp = new byte[formPointerIndex - formNameIndex];
- System.arraycopy(payload, formNameIndex, temp, 0, temp.length);
- return new String(temp);
+ return formName;
+ }
+
+ public void setFormName(String formName) {
+ this.formName = formName;
}
public long getFormPointer() {
- return ByteUtils.toLong(payload, formPointerIndex);
+ return formPointer;
}
- public String getPanelName() {
+ public void setFormPointer(long formPointer) {
+ this.formPointer = formPointer;
+ }
- byte[] temp = new byte[panelPointerIndex - panelNameIndex];
- System.arraycopy(payload, panelNameIndex, temp, 0, temp.length);
- return new String(temp);
+ public String getPanelName() {
+ return panelName;
+ }
+ public void setPanelName(String panelName) {
+ this.panelName = panelName;
}
public long getPanelPointer() {
- return ByteUtils.toLong(payload, panelPointerIndex);
+ return panelPointer;
+ }
+
+ public void setPanelPointer(long panelPointer) {
+ this.panelPointer = panelPointer;
}
public int getTransitionTime() {
- return ByteUtils.toInt(payload, transitionTimeIndex);
+ return transitionTime;
+ }
+
+ public void setTransitionTime(int transitionTime) {
+ this.transitionTime = transitionTime;
}
public int getUserTransitionTime() {
- return ByteUtils.toInt(payload, userTransitionTimeIndex);
+ return userTransitionTime;
+ }
+
+ public void setUserTransitionTime(int userTransitionTime) {
+ this.userTransitionTime = userTransitionTime;
}
+
}
package org.tizen.dynamicanalyzer.swap.model.probe2;
-import org.tizen.dynamicanalyzer.swap.model.ByteUtils;
+import org.tizen.dynamicanalyzer.swap.model.data.BasicDataMessage;
public class ScreenShotData extends ProbeCommonData {
- private int imageFilePathIndex = 0;
- private int orientationIndex = 0;
+ String imageFilePath = null;
+ int orientation = 0;
- public ScreenShotData(BasicDataInterface data) {
+ public ScreenShotData(BasicDataMessage data) {
super(data);
- imageFilePathIndex = getCommonColumnsSize();
- orientationIndex = imageFilePathIndex + getStringLength(imageFilePathIndex);
}
public String getImageFilePath() {
- byte[] temp = new byte[orientationIndex - imageFilePathIndex];
- System.arraycopy(payload, imageFilePathIndex, temp, 0, temp.length);
- return new String(temp);
+ return imageFilePath;
+ }
+
+ public void setImageFilePath(String imageFilePath) {
+ this.imageFilePath = imageFilePath;
}
public int getOrientation() {
- return ByteUtils.toInt(payload, orientationIndex);
+ return orientation;
}
+
+ public void setOrientation(int orientation) {
+ this.orientation = orientation;
+ }
+
}
package org.tizen.dynamicanalyzer.swap.model.probe2;
-import org.tizen.dynamicanalyzer.common.CommonConstants;
-import org.tizen.dynamicanalyzer.swap.model.ByteUtils;
+import org.tizen.dynamicanalyzer.swap.model.data.BasicDataMessage;
public class SyncData extends ProbeCommonData {
- private int syncValueIndex = 0;
- private int syncTypeIndex = 0;
- private int apiTypeIndex = 0;
+ long syncValue = 0;
+ int syncType = 0;
+ int apiType = 0;
- public SyncData(BasicDataInterface data) {
+ public SyncData(BasicDataMessage data) {
super(data);
-
- syncValueIndex = getCommonColumnsSize();
- syncTypeIndex = syncValueIndex + CommonConstants.LONG_SIZE;
- apiTypeIndex = syncTypeIndex + CommonConstants.INT_SIZE;
}
public long getSyncValue() {
- return ByteUtils.toLong(payload, syncValueIndex);
+ return syncValue;
+ }
+
+ public void setSyncValue(long syncValue) {
+ this.syncValue = syncValue;
}
public int getSyncType() {
- return ByteUtils.toInt(payload, syncTypeIndex);
+ return syncType;
+ }
+
+ public void setSyncType(int syncType) {
+ this.syncType = syncType;
}
public int getApiType() {
- return ByteUtils.toInt(payload, apiTypeIndex);
+ return apiType;
+ }
+
+ public void setApiType(int apiType) {
+ this.apiType = apiType;
}
+
}
package org.tizen.dynamicanalyzer.swap.model.probe2;
-import static org.tizen.dynamicanalyzer.common.CommonConstants.FLOAT_SIZE;
-import static org.tizen.dynamicanalyzer.common.CommonConstants.INT_SIZE;
-import static org.tizen.dynamicanalyzer.common.CommonConstants.LONG_SIZE;
-
-import org.tizen.dynamicanalyzer.common.CommonConstants;
-import org.tizen.dynamicanalyzer.communicator.DACommunicator;
-import org.tizen.dynamicanalyzer.swap.model.ByteUtils;
+import org.tizen.dynamicanalyzer.swap.model.data.BasicDataMessage;
public class SystemData extends LogData {
- public static final int PARSE_TYPE_THREAD = 1;
- public static final int PARSE_TYPE_PROCESS = 2;
-
- private int energyIndex = -1;
- private int wifiIndex = -1;
- private int btStatusIndex = -1;
- private int gpsStatusIndex = -1;
- private int brightnessIndex = -1;
- private int cameraIndex = -1;
- private int soundIndex = -1;
- private int audioIndex = -1;
- private int vibrationIndex = -1;
- private int voltageIndex = -1;
- private int rssiIndex = -1;
- private int videoIndex = -1;
- private int callIndex = -1;
- private int dnetIndex = -1;
- private int networkSendSizeIndex = -1;
- private int networkReceiveSizeIndex = -1;
- private int cpuFrequencyIndex = -1;
- private int appCpuUsageIndex = -1;
- private int cpuLoadIndex = -1;
- private int virtualMemoryIndex = -1;
- private int residentMemoryIndex = -1;
- private int sharedMemoryIndex = -1;
- private int pssMemoryIndex = -1;
- private int totalAllocSizeIndex = -1;
- private int systemMemoryTotalIndex = -1;
- private int systemMemoryUsedIndex = -1;
- private int totalUsedDriveIndex = -1;
-
- private int threadCountIndex = -1;
- private int threadLoadIndex = -1;
-
- private int processCountIndex = -1;
- private int processLoadIndex = -1;
- private int diskReadSizeIndex = -1;
- private int diskWriteSizeIndex = -1;
-
- private int callAlphaIndex = -1;
- private int rssiAlphaIndex = -1;
-
- private String threadLoad = null;
- private String processLoad = null;
- private String cpuFrequency = null;
- private String cpuLoad = null;
-
- public SystemData(BasicDataInterface data) {
+ int energy = 0;
+ int wifi = 0;
+ int btStatus = 0;
+ int gpsStatus = 0;
+ int brightness = 0;
+ int camera = 0;
+ int sound = 0;
+ int audio = 0;
+ int vibration = 0;
+ int voltage = 0;
+ int rssi = 0;
+ int video = 0;
+ int call = 0;
+ int dnet = 0;
+ int networkSendSize = 0;
+ int networkReceiveSize = 0;
+ String cpuFrequency = null;
+ float appCpuUsage = 0;
+ String cpuLoad = null;
+ int virtualMemory = 0;
+ int residentMemory = 0;
+ int sharedMemory = 0;
+ int pssMemory = 0;
+ int totalAllocSize = 0;
+ long systemMemoryTotal = 0;
+ long systemMemoryUsed = 0;
+ int totalUsedDrive = 0;
+
+ int threadCount = 0;
+ String threadLoad = null;
+
+ int processCount = 0;
+ String processLoad = null;
+ int diskReadSize = 0;
+ int diskWriteSize = 0;
+
+ int callAlpha = 0;
+ int rssiAlpha = 0;
+
+ public SystemData(BasicDataMessage data) {
super(data);
- int coreCount = DACommunicator.getSelectedDevice().getTargetInfo()
- .getCpuCount();
- energyIndex = 0;
- wifiIndex = energyIndex + INT_SIZE;
- btStatusIndex = wifiIndex + INT_SIZE;
- gpsStatusIndex = btStatusIndex + INT_SIZE;
- brightnessIndex = gpsStatusIndex + INT_SIZE;
- cameraIndex = brightnessIndex + INT_SIZE;
- soundIndex = cameraIndex + INT_SIZE;
- audioIndex = soundIndex + INT_SIZE;
- vibrationIndex = audioIndex + INT_SIZE;
- voltageIndex = vibrationIndex + INT_SIZE;
- rssiIndex = voltageIndex + INT_SIZE;
- videoIndex = rssiIndex + INT_SIZE;
- callIndex = videoIndex + INT_SIZE;
- dnetIndex = callIndex + INT_SIZE;
- cpuFrequencyIndex = dnetIndex + INT_SIZE;
- appCpuUsageIndex = cpuFrequencyIndex + (FLOAT_SIZE * coreCount);
- cpuLoadIndex = appCpuUsageIndex + FLOAT_SIZE;
- virtualMemoryIndex = cpuLoadIndex + (FLOAT_SIZE * coreCount);
- residentMemoryIndex = virtualMemoryIndex + INT_SIZE;
- sharedMemoryIndex = residentMemoryIndex + INT_SIZE;
- pssMemoryIndex = sharedMemoryIndex + INT_SIZE;
- totalAllocSizeIndex = pssMemoryIndex + INT_SIZE;
- systemMemoryTotalIndex = totalAllocSizeIndex + INT_SIZE;
- systemMemoryUsedIndex = systemMemoryTotalIndex + LONG_SIZE;
- totalUsedDriveIndex = systemMemoryUsedIndex + LONG_SIZE;
- threadCountIndex = totalUsedDriveIndex + INT_SIZE;
- threadLoadIndex = threadCountIndex + INT_SIZE;
- processCountIndex = parseLoad(threadLoadIndex, PARSE_TYPE_THREAD);
- processLoadIndex = processCountIndex + INT_SIZE;
- diskReadSizeIndex =parseLoad(processLoadIndex, PARSE_TYPE_PROCESS);
- diskWriteSizeIndex = diskReadSizeIndex + INT_SIZE;
- networkSendSizeIndex = diskWriteSizeIndex + INT_SIZE;
- networkReceiveSizeIndex = networkSendSizeIndex + INT_SIZE;
-
- cpuFrequency = parseCpu(cpuFrequencyIndex);
- cpuLoad = parseCpu(cpuLoadIndex);
- }
-
- private int parseLoad(int start, int type) {
- int backPos = start - INT_SIZE;
- int count = ByteUtils.toInt(payload, backPos);
- StringBuffer outBuf = new StringBuffer();
- for (int ii = 0; ii < count; ii++) {
- int tid = ByteUtils.toInt(payload, start);
- start += INT_SIZE;
- outBuf.append(tid).append(CommonConstants.COMMA);
- float f = ByteUtils.toFloat(payload, start);
- outBuf.append(f);
- start += FLOAT_SIZE;
- if (ii + 1 != count) {
- outBuf.append(',');
- }
- }
- if (type == PARSE_TYPE_THREAD) {
- threadLoad = outBuf.toString();
- } else if (type == PARSE_TYPE_PROCESS) {
- processLoad = outBuf.toString();
- }
- return start;
- }
-
- private String parseCpu(int start) {
- int coreCount = DACommunicator.getSelectedDevice().getTargetInfo()
- .getCpuCount();
- StringBuffer buffer = new StringBuffer();
- for (int i = 0; i < coreCount; i++) {
- float value = ByteUtils.toFloat(payload, start);
- start += FLOAT_SIZE;
- buffer.append(value);
- if (i + 1 != coreCount) {
- buffer.append(',');
- }
- }
- return buffer.toString();
}
public int getEnergy() {
- return ByteUtils.toInt(payload, energyIndex);
+ return energy;
}
- public int getWiFiStatus() {
- return ByteUtils.toInt(payload, wifiIndex);
+ public void setEnergy(int energy) {
+ this.energy = energy;
}
- public int getBlutToothStatus() {
- return ByteUtils.toInt(payload, btStatusIndex);
+ public int getWifi() {
+ return wifi;
}
- public int getGPSStatus() {
- return ByteUtils.toInt(payload, gpsStatusIndex);
+ public void setWifi(int wifi) {
+ this.wifi = wifi;
}
- public int getBrightnessStatus() {
- return ByteUtils.toInt(payload, brightnessIndex);
+ public int getBtStatus() {
+ return btStatus;
}
- public int getCameraStatus() {
- return ByteUtils.toInt(payload, cameraIndex);
+ public void setBtStatus(int btStatus) {
+ this.btStatus = btStatus;
}
- public int getSoundStatus() {
- return ByteUtils.toInt(payload, soundIndex);
+ public int getGpsStatus() {
+ return gpsStatus;
}
- public int getAudioStatus() {
- return ByteUtils.toInt(payload, audioIndex);
+ public void setGpsStatus(int gpsStatus) {
+ this.gpsStatus = gpsStatus;
}
- public int getVibrationStatus() {
- return ByteUtils.toInt(payload, vibrationIndex);
+ public int getBrightness() {
+ return brightness;
}
- public int getVoltageStatus() {
- return ByteUtils.toInt(payload, voltageIndex);
+ public void setBrightness(int brightness) {
+ this.brightness = brightness;
}
- public int getRSSIStatus() {
- return ByteUtils.toInt(payload, rssiIndex);
+ public int getCamera() {
+ return camera;
}
- public int getVideoStatus() {
- return ByteUtils.toInt(payload, videoIndex);
+ public void setCamera(int camera) {
+ this.camera = camera;
}
- public int getCallStatus() {
- return ByteUtils.toInt(payload, callIndex);
+ public int getSound() {
+ return sound;
}
- public int getDNetStatus() {
- return ByteUtils.toInt(payload, dnetIndex);
+ public void setSound(int sound) {
+ this.sound = sound;
}
- public int getCallAlphaStatus() {
- return ByteUtils.toInt(payload, callAlphaIndex);
+ public int getAudio() {
+ return audio;
}
- public int getRssiAlphaStatus() {
- return ByteUtils.toInt(payload, rssiAlphaIndex);
+ public void setAudio(int audio) {
+ this.audio = audio;
}
- public String getCpuFrequency() {
- return cpuFrequency;
+ public int getVibration() {
+ return vibration;
}
- public float getAppCpuUsage() {
- return ByteUtils.toFloat(payload, appCpuUsageIndex);
+ public void setVibration(int vibration) {
+ this.vibration = vibration;
}
- public String getCpuLoad() {
- return cpuLoad;
+ public int getVoltage() {
+ return voltage;
+ }
+
+ public void setVoltage(int voltage) {
+ this.voltage = voltage;
+ }
+
+ public int getRssi() {
+ return rssi;
+ }
+
+ public void setRssi(int rssi) {
+ this.rssi = rssi;
+ }
+
+ public int getVideo() {
+ return video;
+ }
+
+ public void setVideo(int video) {
+ this.video = video;
+ }
+
+ public int getCall() {
+ return call;
+ }
+
+ public void setCall(int call) {
+ this.call = call;
+ }
+
+ public int getDnet() {
+ return dnet;
+ }
+
+ public void setDnet(int dnet) {
+ this.dnet = dnet;
+ }
+
+ public int getNetworkSendSize() {
+ return networkSendSize;
+ }
+
+ public void setNetworkSendSize(int networkSendSize) {
+ this.networkSendSize = networkSendSize;
+ }
+
+ public int getNetworkReceiveSize() {
+ return networkReceiveSize;
+ }
+
+ public void setNetworkReceiveSize(int networkReceiveSize) {
+ this.networkReceiveSize = networkReceiveSize;
}
public int getVirtualMemory() {
- return ByteUtils.toInt(payload, virtualMemoryIndex);
+ return virtualMemory;
+ }
+
+ public void setVirtualMemory(int virtualMemory) {
+ this.virtualMemory = virtualMemory;
}
public int getResidentMemory() {
- return ByteUtils.toInt(payload, residentMemoryIndex);
+ return residentMemory;
+ }
+
+ public void setResidentMemory(int residentMemory) {
+ this.residentMemory = residentMemory;
}
public int getSharedMemory() {
- return ByteUtils.toInt(payload, sharedMemoryIndex);
+ return sharedMemory;
}
- public int getPSSMemory() {
- return ByteUtils.toInt(payload, pssMemoryIndex);
+ public void setSharedMemory(int sharedMemory) {
+ this.sharedMemory = sharedMemory;
}
- public int getTotalAllocSize() {
- return ByteUtils.toInt(payload, totalAllocSizeIndex);
+ public int getPssMemory() {
+ return pssMemory;
}
- public long getTotalSystemMemory() {
- return ByteUtils.toLong(payload, systemMemoryTotalIndex);
+ public void setPssMemory(int pssMemory) {
+ this.pssMemory = pssMemory;
}
- public long getUsedSystemMemory() {
- return ByteUtils.toLong(payload, systemMemoryUsedIndex);
+ public int getTotalAllocSize() {
+ return totalAllocSize;
+ }
+
+ public void setTotalAllocSize(int totalAllocSize) {
+ this.totalAllocSize = totalAllocSize;
}
public int getTotalUsedDrive() {
- return ByteUtils.toInt(payload, totalUsedDriveIndex);
+ return totalUsedDrive;
+ }
+
+ public void setTotalUsedDrive(int totalUsedDrive) {
+ this.totalUsedDrive = totalUsedDrive;
}
public int getThreadCount() {
- return ByteUtils.toInt(payload, threadCountIndex);
+ return threadCount;
+ }
+
+ public void setThreadCount(int threadCount) {
+ this.threadCount = threadCount;
+ }
+
+ public int getProcessCount() {
+ return processCount;
+ }
+
+ public void setProcessCount(int processCount) {
+ this.processCount = processCount;
+ }
+
+ public String getCpuFrequency() {
+ return cpuFrequency;
+ }
+
+ public void setCpuFrequency(String cpuFrequency) {
+ this.cpuFrequency = cpuFrequency;
+ }
+
+ public float getAppCpuUsage() {
+ return appCpuUsage;
+ }
+
+ public void setAppCpuUsage(float appCpuUsage) {
+ this.appCpuUsage = appCpuUsage;
+ }
+
+ public String getCpuLoad() {
+ return cpuLoad;
+ }
+
+ public void setCpuLoad(String cpuLoad) {
+ this.cpuLoad = cpuLoad;
+ }
+
+ public long getSystemMemoryTotal() {
+ return systemMemoryTotal;
+ }
+
+ public void setSystemMemoryTotal(long systemMemoryTotal) {
+ this.systemMemoryTotal = systemMemoryTotal;
+ }
+
+ public long getSystemMemoryUsed() {
+ return systemMemoryUsed;
+ }
+
+ public void setSystemMemoryUsed(long systemMemoryUsed) {
+ this.systemMemoryUsed = systemMemoryUsed;
}
public String getThreadLoad() {
return threadLoad;
}
- public int getProcessCount() {
- return ByteUtils.toInt(payload, processCountIndex);
+ public void setThreadLoad(String threadLoad) {
+ this.threadLoad = threadLoad;
}
public String getProcessLoad() {
return processLoad;
}
- public int getNetworkSendSize() {
- return ByteUtils.toInt(payload, networkSendSizeIndex);
+ public void setProcessLoad(String processLoad) {
+ this.processLoad = processLoad;
}
- public int getNetworkReceiveSize() {
- return ByteUtils.toInt(payload, networkReceiveSizeIndex);
+ public int getDiskReadSize() {
+ return diskReadSize;
+ }
+
+ public void setDiskReadSize(int diskReadSize) {
+ this.diskReadSize = diskReadSize;
+ }
+
+ public int getDiskWriteSize() {
+ return diskWriteSize;
+ }
+
+ public void setDiskWriteSize(int diskWriteSize) {
+ this.diskWriteSize = diskWriteSize;
}
public int getCallAlpha() {
- return -1;
+ return callAlpha;
}
- public int getRssiAlpha() {
- return -1;
+ public void setCallAlpha(int callAlpha) {
+ this.callAlpha = callAlpha;
}
- public int getDISKReadSize() {
- return ByteUtils.toInt(payload, diskReadSizeIndex);
+ public int getRssiAlpha() {
+ return rssiAlpha;
}
- public int getDISKWriteSize() {
- return ByteUtils.toInt(payload, diskWriteSizeIndex);
+ public void setRssiAlpha(int rssiAlpha) {
+ this.rssiAlpha = rssiAlpha;
}
+
}
package org.tizen.dynamicanalyzer.swap.model.probe2;
-import org.tizen.dynamicanalyzer.common.CommonConstants;
-import org.tizen.dynamicanalyzer.swap.model.ByteUtils;
+import org.tizen.dynamicanalyzer.swap.model.data.BasicDataMessage;
public class ThreadData extends ProbeCommonData {
- private int pThreadIdIndex = 0;
- private int ospThreadIdIndex = 0;
- private int threadTypeIndex = 0;
- private int apiTypeIndex = 0;
+ long pThreadId = 0;
+ long ospThreadId = 0;
+ int threadType = 0; // TODO: short
+ int apiType = 0;// TODO: short
- public ThreadData(BasicDataInterface data) {
+ public ThreadData(BasicDataMessage data) {
super(data);
- pThreadIdIndex = getCommonColumnsSize();
- ospThreadIdIndex = pThreadIdIndex + CommonConstants.LONG_SIZE;
- threadTypeIndex = ospThreadIdIndex + CommonConstants.LONG_SIZE;
- apiTypeIndex = threadTypeIndex + CommonConstants.INT_SIZE;
}
public long getPThreadId() {
- return ByteUtils.toLong(payload, pThreadIdIndex);
+ return pThreadId;
+ }
+
+ public void setpThreadId(long pThreadId) {
+ this.pThreadId = pThreadId;
}
public long getOspThreadId() {
- return ByteUtils.toLong(payload, ospThreadIdIndex);
+ return ospThreadId;
+ }
+
+ public void setOspThreadId(long ospThreadId) {
+ this.ospThreadId = ospThreadId;
}
public int getThreadType() {
- return ByteUtils.toInt(payload, threadTypeIndex);
+ return threadType;
+ }
+
+ public void setThreadType(int threadType) {
+ this.threadType = threadType;
}
public int getApiType() {
- return ByteUtils.toInt(payload, apiTypeIndex);
+ return apiType;
+ }
+
+ public void setApiType(int apiType) {
+ this.apiType = apiType;
}
}
package org.tizen.dynamicanalyzer.swap.model.probe2;
-import org.tizen.dynamicanalyzer.common.CommonConstants;
-import org.tizen.dynamicanalyzer.swap.model.ByteUtils;
+import org.tizen.dynamicanalyzer.swap.model.data.BasicDataMessage;
public class UIEventData extends ProbeCommonData {
- private int eventTypeIndex = 0;
- private int detailTypeIndex = 0;
- private int xIndex = 0;
- private int yIndex = 0;
- private int info1Index = 0;
- private int info2Index = 0;
+ int eventType = 0;
+ int detailType = 0;
+ int x = 0;
+ int y = 0;
+ int info1 = 0;
+ int info2 = 0;
- private int logNum = 0;
-
- public UIEventData(BasicDataInterface data) {
- super(data);
- eventTypeIndex = getCommonColumnsSize();
- detailTypeIndex = eventTypeIndex + CommonConstants.INT_SIZE;
- xIndex = detailTypeIndex + CommonConstants.INT_SIZE;
- yIndex = xIndex + CommonConstants.INT_SIZE;
- info1Index = yIndex + CommonConstants.INT_SIZE;
- info2Index = info1Index + CommonConstants.INT_SIZE;
+ public int getEventType() {
+ return eventType;
}
- public int getEventType() {
- return ByteUtils.toInt(payload, eventTypeIndex);
+ public void setEventType(int eventType) {
+ this.eventType = eventType;
}
public int getDetailType() {
- return ByteUtils.toInt(payload, detailTypeIndex);
+ return detailType;
+ }
+
+ public void setDetailType(int detailType) {
+ this.detailType = detailType;
}
public int getX() {
- return ByteUtils.toInt(payload, xIndex);
+ return x;
+ }
+
+ public void setX(int x) {
+ this.x = x;
}
public int getY() {
- return ByteUtils.toInt(payload, yIndex);
+ return y;
+ }
+
+ public void setY(int y) {
+ this.y = y;
}
public int getInfo1() {
- return ByteUtils.toInt(payload, info1Index);
+ return info1;
+ }
+
+ public void setInfo1(int info1) {
+ this.info1 = info1;
}
public int getInfo2() {
- return ByteUtils.toInt(payload, info2Index);
+ return info2;
+ }
+
+ public void setInfo2(int info2) {
+ this.info2 = info2;
+ }
+
+ private int logNum = 0;
+
+ public UIEventData(BasicDataMessage data) {
+ super(data);
}
@Override
package org.tizen.dynamicanalyzer.swap.model.probe2;
-import static org.tizen.dynamicanalyzer.common.CommonConstants.INT_SIZE;
-import static org.tizen.dynamicanalyzer.common.CommonConstants.LONG_SIZE;
-
-import org.tizen.dynamicanalyzer.swap.model.ByteUtils;
+import org.tizen.dynamicanalyzer.swap.model.data.BasicDataMessage;
public class UserFunctionData extends ProbeCommonData {
- private int lowPcIndex = -1;
- private int highPcIndex = -1;
- private int typeIndex = -1;
- private int elapsedTimeIndex = -1;
- private int pcAddrIndex = -1;
+ long lowPc = 0;
+ long highPc = 0;
+ int type = 0;
+ long elapsedTime = 0;
+ long pcAddr = 0;
- public UserFunctionData(BasicDataInterface data) {
+ public UserFunctionData(BasicDataMessage data) {
super(data);
- lowPcIndex = getCommonColumnsSize();
- highPcIndex = lowPcIndex + LONG_SIZE;
- typeIndex = highPcIndex + LONG_SIZE;
- elapsedTimeIndex = typeIndex + INT_SIZE;
- pcAddrIndex = elapsedTimeIndex + LONG_SIZE;
}
public long getLowPc() {
- return ByteUtils.toLong(payload, lowPcIndex);
+ return lowPc;
+ }
+
+ public void setLowPc(long lowPc) {
+ this.lowPc = lowPc;
}
public long getHighPc() {
- return ByteUtils.toLong(payload, highPcIndex);
+ return highPc;
+ }
+
+ public void setHighPc(long highPc) {
+ this.highPc = highPc;
}
public int getType() {
- return ByteUtils.toInt(payload, typeIndex);
+ return type;
+ }
+
+ public void setType(int type) {
+ this.type = type;
}
public long getElapsedTime() {
- return ByteUtils.toLong(payload, elapsedTimeIndex);
+ return elapsedTime;
+ }
+
+ public void setElapsedTime(long elapsedTime) {
+ this.elapsedTime = elapsedTime;
+ }
+
+ public long getPcAddr() {
+ return pcAddr;
}
- public long getPCAddress() {
- return ByteUtils.toLong(payload, pcAddrIndex);
+ public void setPcAddr(long pcAddr) {
+ this.pcAddr = pcAddr;
}
}
errMsg = "undefined error code"; //$NON-NLS-1$
}
contentText.add(errMsg);
- contentText.add(Integer.toString(contentTemp.getFileSize()));
+ contentText.add(Long.toString(contentTemp.getFileSize()));
DATableDataFormat tableData = new DATableDataFormat(
contentTemp.getSeq());
// String fdType =
// input.get(LogCenterConstants.RESOURCE_FDTYPE_INDEX);
// socket
- int type = input.getFDType();
+ int type = input.getFdType();
if (type == 1 || type == 2) {
continue;
}
- int fdApiType = input.getFDApiType();
+ int fdApiType = input.getFdApiType();
String path = input.getFilePath();
- int fd = input.getFDValue();
+ int fd = input.getFdValue();
long errno = input.getErrno();
if (null == binPath || binPath.isEmpty()) {
return;
}
- String strSelfAddr = Long.toString(log.getPCAddress());
+ String strSelfAddr = Long.toString(log.getPcAddr());
String strCallerAddr = Long.toString(log.getCallerPcAddr());
int seq = log.getSeq();
int tid = log.getTid();
- long selfAddr = log.getPCAddress();
+ long selfAddr = log.getPcAddr();
long callerAddr = log.getCallerPcAddr();
CallStackData callstackData = new CallStackData(seq);
// int tid = Integer.parseInt(strTid);
int seq = log.getSeq();
int tid = log.getTid();
- log.getCallerPcAddr();
// long callerAddr = 0;
long callerAddr = log.getCallerPcAddr();
// if (!strCallerAddr.isEmpty()) {
return false;
}
- String strSelfAddr = Long.toString(input.getPCAddress());
+ String strSelfAddr = Long.toString(input.getPcAddr());
int tid = input.getTid();
- long selfAddr = input.getPCAddress();
+ long selfAddr = input.getPcAddr();
CallStackUnit selfCallstackUnit = addrMap.get(selfAddr);
import org.eclipse.swt.widgets.Shell;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
-import org.tizen.dynamicanalyzer.common.CommonConstants;
import org.tizen.dynamicanalyzer.common.DASelectionData;
import org.tizen.dynamicanalyzer.common.SnapshotConstants;
import org.tizen.dynamicanalyzer.model.ImageInfo;
} else {
path = AnalyzerManager.getProject().getSavePath()
+ File.separator + AnalyzerConstants.IMAGE_FOLDER_NAME
- + File.separator + imageInfo.getSeq()
- + CommonConstants.EXTENSION_PNG_IMAGE;
+ + File.separator + imageInfo.getFileName();
}
Image img = null;
if (path.equals(AnalyzerConstants.DEFAULT_IMAGE_NAME)) {
ImageViewer snapshot;
CircularGraph processGraph;
FourBarGraph cpuGrp;
- private static String rss = CommonConstants.ZERO;
private String[] observingViews = null;
private Composite bottomComp = null;
import java.util.ArrayList;
import java.util.List;
+import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.swap.model.probe2.FailedData2;
import org.tizen.dynamicanalyzer.swap.model.probe2.FileData;
import org.tizen.dynamicanalyzer.swap.model.probe2.LogData;
}
checkUserDefinedFunc(log, cm);
}
-// if (cid == LogCenterConstants.LOG_RESOURCE) {
+ // if (cid == LogCenterConstants.LOG_RESOURCE) {
if (log instanceof FileData) {
- FileData fileData = ((FileData)log);
+ FileData fileData = ((FileData) log);
if (AnalyzerUtil.isInternal(fileData)) {
return;
}
-// String fdTypeStr = intput[LogCenterConstants.RESOURCE_FDTYPE_INDEX];
-// String errnoStr = intput[LogCenterConstants.ERROR_INDEX];
-// int fdType = Integer.parseInt(fdTypeStr);
-// long errno = Long.parseLong(errnoStr);
- int fdType = fileData.getFDType();
+ // String fdTypeStr =
+ // intput[LogCenterConstants.RESOURCE_FDTYPE_INDEX];
+ // String errnoStr = intput[LogCenterConstants.ERROR_INDEX];
+ // int fdType = Integer.parseInt(fdTypeStr);
+ // long errno = Long.parseLong(errnoStr);
+ int fdType = fileData.getFdType();
long errno = fileData.getErrno();
// file or (not error) - file error check file page
if (fdType == 0 || errno == 0) {
}
checkUserDefinedFunc(fileData, cm);
}
-// if (cid == LogCenterConstants.LOG_USER_FUNCTION) {
+ // if (cid == LogCenterConstants.LOG_USER_FUNCTION) {
if (log instanceof UserFunctionData) {
// TODO : check user function error???
return;
}
private void checkUserDefinedFunc(LogData log, CallStackManager cm) {
-// if (AnalyzerConstants.USER_CALL == AnalyzerUtil.checkUserCall((ProbeCommonData)log)) {
+ if (AnalyzerConstants.USER_CALL == AnalyzerUtil
+ .checkUserCall((ProbeCommonData) log)) {
FailedData2 fd = new FailedData2(log);
getFailedList().add(fd);
-// }
+ }
}
public List<FailedData2> getFailedList() {
List<Long> addrs = makeCallstackHashAndList(sampleCallstack);
HashMap<Long, CallStackUnit> addrMap = callstackManager
.getCallStackApiByAddrMap();
- long selfAddr = sampleLog.getPcAddress();
+ long selfAddr = sampleLog.getPcAddr();
CallStackUnit inputData = addrMap.get(selfAddr);
if (null == inputData) {
return;
}
/* PSS */
- if (log.getPSSMemory() != 0) {
+ if (log.getPssMemory() != 0) {
double time = ((double) log.getTime()) / TimelineConstants.MEGA;
- double value = (double) log.getPSSMemory();
+ double value = (double) log.getPssMemory();
PSSMemorySeries.addSeriesItem(new DAChartSeriesItem(time, value,
Formatter.toByteFormat(value)));
}
/* system & total */
- if (log.getUsedSystemMemory() != 0) {
+ if (log.getSystemMemoryUsed() != 0) {
double time = ((double) log.getTime()) / TimelineConstants.MEGA;
- double usage = (double) log.getUsedSystemMemory();
+ double usage = (double) log.getSystemMemoryUsed();
double total = (double) AnalyzerManager.getProject()
.getSystemMemorySize();
import org.tizen.dynamicanalyzer.logparser.LogParser;
import org.tizen.dynamicanalyzer.project.Project;
import org.tizen.dynamicanalyzer.sql.SqlManager;
+import org.tizen.dynamicanalyzer.swap.logparser.SWAPLogParser;
import org.tizen.dynamicanalyzer.ui.file.FileChartManager;
import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler;
import org.tizen.dynamicanalyzer.ui.thread.ThreadChartManager;
Project project = AnalyzerManager.getProject();
int percent = 0;
- LogParser.stopLogParser();
+ if (DACommunicator.isSWAPVersion()) {
+ SWAPLogParser.stopLogParser();
+ } else {
+ LogParser.stopLogParser();
+ }
percent += 10;
StopProcessManager.getInstance().setValue(percent);
// }
public UIControlListData(LogData input) {
- data = input.getClone();
+// data = input.getClone();
+ data = input;
}
public LogData getData() {
public UISceneData(LogData sceneLoginput) {
if (null != sceneLoginput) {
- data = sceneLoginput.getClone();
+// data = sceneLoginput.getClone();
+ data = sceneLoginput;
}
}
package org.tizen.dynamicanalyzer.utils;
+import static org.tizen.sdblib.service.SyncServiceConstants.RESULT_OK;
+
+import java.io.BufferedReader;
import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
+import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Collections;
+import java.util.HashMap;
import java.util.List;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.ui.part.ViewPart;
import org.tizen.dynamicanalyzer.common.AnalyzerConstants;
import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+import org.tizen.dynamicanalyzer.common.AnalyzerPaths;
import org.tizen.dynamicanalyzer.common.CommonConstants;
+import org.tizen.dynamicanalyzer.communicator.CommunicatorUtils;
import org.tizen.dynamicanalyzer.communicator.DACommunicator;
import org.tizen.dynamicanalyzer.handlers.RealtimePerspectiveHandler;
import org.tizen.dynamicanalyzer.logparser.LogCenterConstants;
import org.tizen.dynamicanalyzer.services.RecordStateSourceProvider;
import org.tizen.dynamicanalyzer.swap.model.ByteUtils;
import org.tizen.dynamicanalyzer.swap.model.data.ApiNameManager;
+import org.tizen.dynamicanalyzer.swap.model.probe2.LogData;
import org.tizen.dynamicanalyzer.swap.model.probe2.LogDataFactory;
import org.tizen.dynamicanalyzer.swap.model.probe2.ProbeCommonData;
+import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackData;
+import org.tizen.dynamicanalyzer.ui.info.callstack.CallStackUnit;
import org.tizen.dynamicanalyzer.ui.page.BaseView;
import org.tizen.dynamicanalyzer.ui.page.DAPageComposite;
import org.tizen.dynamicanalyzer.ui.page.ViewAction;
import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineView;
import org.tizen.dynamicanalyzer.ui.widgets.DATabComposite;
+import org.tizen.sdblib.IDevice;
+import org.tizen.sdblib.service.SyncResult;
public class AnalyzerUtil {
private static IWorkbenchWindow window = null;
return str.toString();
}
- // public static int checkUserCall(String[] input) {
- // String internalCall = input[LogCenterConstants.LOG_USER_FUNCTION];
- // if (null != internalCall && !internalCall.isEmpty()) {
- // int internalValue = Integer.parseInt(internalCall);
- //
- // if (internalValue == AnalyzerConstants.USER_CALL) {
- // return AnalyzerConstants.USER_CALL;
- // } else if (internalValue == AnalyzerConstants.INTERNAL_CALL) {
- // return AnalyzerConstants.INTERNAL_CALL;
- // }
- // }
- //
- // HashMap<Integer, CallStackData> cdMap = AnalyzerManager
- // .getCallstackManager().getCallStackDataBySeqMap();
- // HashMap<Long, CallStackUnit> addrMap = AnalyzerManager
- // .getCallstackManager().getCallStackApiByAddrMap();
- //
- // if (null == cdMap || null == addrMap) {
- // return AnalyzerConstants.USER_CALL_CHECK_ERROR;
- // }
- // int seqNum = Integer
- // .parseInt(input[LogCenterConstants.SEQUENCE_NUMBER_INDEX]);
- // CallStackData csd = cdMap.get(seqNum);
- // List<Long> addrs = csd.getAddrs();
- // if (addrs.isEmpty() || addrs.size() < 3) {
- // // FIXME
- // return AnalyzerConstants.USER_CALL_CHECK_ERROR;
- // }
- //
- // String funcName = addrMap.get(addrs.get(0)).getFunctionName();
- // if (AnalyzerManager.getCallstackManager().checkUserCall(funcName)) {
- // return AnalyzerConstants.USER_CALL;
- // }
- // return AnalyzerConstants.INTERNAL_CALL;
- // }
+ public static int checkUserCall(ProbeCommonData input) {
+ int internalValue = input.getInternalCall();
+ if (internalValue == AnalyzerConstants.USER_CALL) {
+ return AnalyzerConstants.USER_CALL;
+ // } else if (internalValue == AnalyzerConstants.INTERNAL_CALL) {
+ } else {
+ return AnalyzerConstants.INTERNAL_CALL;
+ }
+
+ // HashMap<Integer, CallStackData> cdMap = AnalyzerManager
+ // .getCallstackManager().getCallStackDataBySeqMap();
+ // HashMap<Long, CallStackUnit> addrMap = AnalyzerManager
+ // .getCallstackManager().getCallStackApiByAddrMap();
+ //
+ // if (null == cdMap || null == addrMap) {
+ // return AnalyzerConstants.USER_CALL_CHECK_ERROR;
+ // }
+ // int seqNum = Integer
+ // .parseInt(input[LogCenterConstants.SEQUENCE_NUMBER_INDEX]);
+ // CallStackData csd = cdMap.get(seqNum);
+ // List<Long> addrs = csd.getAddrs();
+ // if (addrs.isEmpty() || addrs.size() < 3) {
+ // // FIXME
+ // return AnalyzerConstants.USER_CALL_CHECK_ERROR;
+ // }
+ //
+ // String funcName = addrMap.get(addrs.get(0)).getFunctionName();
+ // if (AnalyzerManager.getCallstackManager().checkUserCall(funcName)) {
+ // return AnalyzerConstants.USER_CALL;
+ // }
+ // return AnalyzerConstants.INTERNAL_CALL;
+ }
public static boolean deleteFile(File file) {
if (file.isDirectory()) {
int pid = initIntPayload(newLog[0]);
long pcAddr = initLongPayload(newLog[1]);
+ int tid = 0;
+ int cpuNum = 0;
- front = ByteUtils.getByte(pid, pcAddr);
+ front = ByteUtils.getByte(pid, pcAddr, tid, cpuNum);
} else {
if (id == AnalyzerConstants.MSG_PROBE_SCREENSHOT) {
System.out.println("debug ");
// reserved
newLog[9] = CommonConstants.EMPTY;
+ if (id == AnalyzerConstants.MSG_PROBE_LIFECYCLE) {
+ System.out.println();
+ }
int apiId = ApiNameManager.getApiId(newLog[0]);
int pid = initIntPayload(newLog[1]);
int tid = initIntPayload(newLog[2]);
result = ByteUtils.concatByteArray(front, rear);
break;
case AnalyzerConstants.MSG_PROBE_THREAD:
- int pThreadId = Integer
- .parseInt(input[LogCenterConstants.THREAD_PTHREAD_ID_INDEX]);
- int ospThradId = Integer
- .parseInt(input[LogCenterConstants.THREAD_TIZENTHREAD_ID_INDEX]);
+ long pThreadId = Long
+ .parseLong(input[LogCenterConstants.THREAD_PTHREAD_ID_INDEX]);
+ long ospThradId = Long
+ .parseLong(input[LogCenterConstants.THREAD_TIZENTHREAD_ID_INDEX]);
int threadType = Integer
.parseInt(input[LogCenterConstants.THREAD_TYPE_INDEX]);
int threadApiType = Integer
.parseInt(input[LogCenterConstants.CUSTOM_CHART_HANDLE]);
int customType = Integer
.parseInt(input[LogCenterConstants.CUSTOM_CHART_TYPE]);
- int customName = Integer
- .parseInt(input[LogCenterConstants.CUSTOM_CHART_TEXT]);
+ String customName = input[LogCenterConstants.CUSTOM_CHART_TEXT];
int color = Integer
.parseInt(input[LogCenterConstants.CUSTOM_CHART_COLOR]);
- int value = Integer
- .parseInt(input[LogCenterConstants.CUSTOM_CHART_VALUE]);
+ double value = Double
+ .parseDouble(input[LogCenterConstants.CUSTOM_CHART_VALUE]);
rear = ByteUtils.getByte(handle, customType, customName, color,
value);
result = ByteUtils.concatByteArray(front, rear);
.parseInt(input[LogCenterConstants.USER_FUNCTION_TYPE_INDEX]);
long elapsedTime = Long
.parseLong(input[LogCenterConstants.USER_FUNCTION_ELAPSED_TIME_INDEX]);
- long pcAddr = Long.parseLong(input[LogCenterConstants.PCADDR_INDEX]);
- rear = ByteUtils.getByte(lowPc, highPc, ufType, elapsedTime, pcAddr);
+ long pcAddr = Long
+ .parseLong(input[LogCenterConstants.PCADDR_INDEX]);
+ rear = ByteUtils
+ .getByte(lowPc, highPc, ufType, elapsedTime, pcAddr);
result = ByteUtils.concatByteArray(front, rear);
break;
}
}
return num;
}
+
+ public static List<String> getApiMap(IDevice device) {
+ String apiFilePath = AnalyzerPaths.TEMP_FOLDER_PATH + File.separator
+ + device.getSerialNumber() + CommonConstants.UNDERBAR
+ + AnalyzerConstants.API_NAME_FILE_NAME;
+ SyncResult res = CommunicatorUtils.pull(device,
+ AnalyzerPaths.DA_API_MAP_PATH, apiFilePath);
+ if (null != res && RESULT_OK == res.getCode()) {
+ System.out.println("api map copying success!!");//$NON-NLS-1$
+ } else {
+ System.out.println("Failed to get " + apiFilePath); //$NON-NLS-1$
+ return null;
+ }
+
+ List<String> apiMap = new ArrayList<String>();
+ apiMap.add("unknown");
+
+ File file = new File(apiFilePath);
+ if (!file.exists()) {
+ System.out.println("file open failed...");
+ return null;
+ }
+ try {
+ FileInputStream fis = new FileInputStream(file);
+ InputStreamReader isr = new InputStreamReader(fis);
+ BufferedReader reader = new BufferedReader(isr);
+
+ String input = null;
+ while (null != (input = reader.readLine())) {
+ String[] splitLine = input.trim().split(CommonConstants.SPACE,
+ 2);
+ apiMap.add(new String(splitLine[1]));
+ }
+
+ } catch (FileNotFoundException e) {
+ e.printStackTrace();
+ return null;
+ } catch (IOException e) {
+ e.printStackTrace();
+ return null;
+ } catch (ArrayIndexOutOfBoundsException e) {
+ e.printStackTrace();
+ }
+ return apiMap;
+ }
}
projects / sdk / tools / dynamic-analyzer.git / commitdiff