From 62b08e13c22e0522dbf93ceb4dbc595b80da233f Mon Sep 17 00:00:00 2001 From: HappyZ Date: Tue, 31 Jan 2017 10:28:33 -0800 Subject: [PATCH] fixed rx end for new binaries --- .../sandlab/offloadingdemo/MainActivity.java | 17 +-- .../offloadingdemo/Thread_RX_CNormal.java | 106 +++++++++++------ .../offloadingdemo/Thread_RX_CNormalUDP.java | 109 +++++++++++------- .../offloadingdemo/Thread_RX_CRawNormal.java | 109 +++++++++++------- .../offloadingdemo/Thread_RX_CSendfile.java | 107 +++++++++++------ .../offloadingdemo/Thread_RX_CSplice.java | 103 +++++++++++------ .../offloadingdemo/Thread_TX_CRawNormal.java | 1 + .../offloadingdemo/Thread_TX_CSplice.java | 3 +- 8 files changed, 357 insertions(+), 198 deletions(-) diff --git a/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/MainActivity.java b/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/MainActivity.java index 0131490..978dce8 100755 --- a/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/MainActivity.java +++ b/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/MainActivity.java @@ -30,7 +30,7 @@ import java.util.Date; import java.util.Locale; public class MainActivity extends Activity { - // unchanged stuff + // tmp fixed protected static final String remoteIP = "128.111.68.220"; protected static final String remoteMAC = "18:03:73:c8:86:52"; protected static final String sshlinklab = "ssh linklab@hotcrp.cs.ucsb.edu" @@ -38,6 +38,7 @@ public class MainActivity extends Activity { protected static final String sshlinklablocal = "ssh linklab@" + remoteIP + " -i /data/.ssh/id_rsa -o StrictHostKeyChecking=no"; protected static final String udpserver_pathport = "~/mobileRDMABeach/UDPServer 32000 "; + // unchanged stuff protected static final String binaryFolderPath = "/data/local/tmp/"; protected static final String binary_tcpdump = "tcpdump"; private static final String TAG = "MainActivity"; @@ -135,9 +136,7 @@ public class MainActivity extends Activity { Runtime.getRuntime().exec("su -c killall -9 " + binary_RX_NormalUDP).waitFor(); Runtime.getRuntime().exec("su -c killall -9 " + binary_RX_Splice).waitFor(); Runtime.getRuntime().exec("su -c killall -9 " + binary_RX_RawNormal).waitFor(); - } catch (InterruptedException e) { - e.printStackTrace(); - } catch (IOException e) { + } catch (InterruptedException | IOException e) { e.printStackTrace(); } } @@ -196,7 +195,7 @@ public class MainActivity extends Activity { /** * start the record - * @param myflag + * @param myflag: */ protected void startRecording(boolean myflag) { final boolean flagRecv = myflag; @@ -275,9 +274,7 @@ public class MainActivity extends Activity { Runtime.getRuntime().exec( "su -c echo 0 > /sys/class/lcd/panel/lcd_power") .waitFor(); - } catch (InterruptedException e) { - e.printStackTrace(); - } catch (IOException e) { + } catch (InterruptedException | IOException e) { e.printStackTrace(); } myHandler.post(new Runnable() { @@ -311,9 +308,7 @@ public class MainActivity extends Activity { // } // }); // } - } catch (InterruptedException e) { - e.printStackTrace(); - } catch (IOException e) { + } catch (InterruptedException | IOException e) { e.printStackTrace(); } // start iteration diff --git a/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/Thread_RX_CNormal.java b/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/Thread_RX_CNormal.java index cabdd09..1484574 100755 --- a/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/Thread_RX_CNormal.java +++ b/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/Thread_RX_CNormal.java @@ -2,71 +2,105 @@ package edu.ucsb.cs.sandlab.offloadingdemo; import android.util.Log; +import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; +import java.io.InputStreamReader; /** * Created by yanzi on 9/18/15. + * Updated on 01/31/17 */ -public class Thread_RX_CNormal implements Runnable { + +class Thread_RX_CNormal implements Runnable { + private double recvBytes = 0.0; + private double duration = 0.0; + private double throughput = 0.0; + @Override public void run() { + + // prevent multiple runs if (MainActivity.isRunning_RX_Normal) return; - if (MainActivity.isVerbose) - Log.d("RX_Normal", "Start RX Normal"); MainActivity.isRunning_RX_Normal = true; + + // variables Process proc; + String stdout; + BufferedReader stdout_buf, error_buf; String[] commd = new String[3]; + + // get the right command commd[0] = "su"; commd[1] = "-c"; + // ./client_recv_normaltcp + // <[optional] recvsize (bytes)> <[optional] filepath> commd[2] = (MainActivity.isForcingCPU0?"taskset 1 ":"") - + MainActivity.binaryFolderPath + MainActivity.binary_RX_Normal + " " - + MainActivity.bytes2send + " " + MainActivity.RXportNum; + + MainActivity.binaryFolderPath + MainActivity.binary_RX_Normal + + " " + (MainActivity.isLocal ? Utilities.myInetIP : MainActivity.remoteIP) + + " " + MainActivity.RXportNum + + " " + MainActivity.bytes2send; + + Log.d("RX_Normal", "Start RX Normal"); + try { + // run process proc = Runtime.getRuntime().exec(commd); + + // if config to log per process while (MainActivity.isLoggingPerProcPID && MainActivity.perProcPID == -1) { - MainActivity.perProcPID = Utilities.getMyPID(MainActivity.binary_RX_Normal, false); + MainActivity.perProcPID = Utilities.getMyPID(MainActivity.binary_RX_Splice, false); } proc.waitFor(); - InputStream stdout = proc.getInputStream(); - byte[] buffer = new byte[20]; - int read; - StringBuilder out = new StringBuilder(); - while(true){ - read = stdout.read(buffer); - if(read<0){ - MainActivity.myHandler.post(new Runnable() { - @Override - public void run() { - MainActivity.txt_results.append("Failed in RX_Normal at port " + MainActivity.RXportNum + "\n"); - } - }); - break; - } - out.append(new String(buffer, 0, read)); - if(read<20){ - break; - } - } - final String mOut = out.toString().trim(); - MainActivity.reportedFinishTime = Double.parseDouble(mOut); - if (MainActivity.isVerbose) { - Log.d("Thread_RX_CNormal", mOut + "ms"); + + // read error + error_buf = new BufferedReader(new InputStreamReader( + proc.getErrorStream())); + final String error = error_buf.readLine(); // only one line error + + // read std out + stdout_buf = new BufferedReader(new InputStreamReader( + proc.getInputStream())); + + // get received bytes + stdout = stdout_buf.readLine(); + if (stdout == null) { + // error happens MainActivity.myHandler.post(new Runnable() { @Override public void run() { - MainActivity.txt_results.append("Time: " + mOut + "ms\n"); + MainActivity.txt_results.append("Err in RX_Normal: " + error + "\n"); } }); + } else { + // sent bytes + recvBytes = Utilities.parseBinOutput(stdout); + + // duration + stdout = stdout_buf.readLine(); + duration = Utilities.parseBinOutput(stdout); + MainActivity.reportedFinishTime = duration; + if (MainActivity.isVerbose) { + MainActivity.myHandler.post(new Runnable() { + @Override + public void run() { + MainActivity.txt_results.append("Time: " + duration + "ms\n"); + } + }); + } + + // throughput + stdout = stdout_buf.readLine(); + throughput = Utilities.parseBinOutput(stdout); } - } catch (IOException e) { - e.printStackTrace(); - } catch (InterruptedException e) { + + } catch (IOException | InterruptedException e) { e.printStackTrace(); } - if (MainActivity.isVerbose) - Log.d("RX_Normal", "Stop RX Normal"); + + Log.d("RX_Normal", "Stop RX Normal"); + MainActivity.isRunning_RX_Normal = false; MainActivity.perProcPID = -1; } diff --git a/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/Thread_RX_CNormalUDP.java b/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/Thread_RX_CNormalUDP.java index bfdf216..27e8b08 100755 --- a/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/Thread_RX_CNormalUDP.java +++ b/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/Thread_RX_CNormalUDP.java @@ -2,74 +2,105 @@ package edu.ucsb.cs.sandlab.offloadingdemo; import android.util.Log; +import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; +import java.io.InputStreamReader; /** * Created by yanzi on 9/18/15. + * Updated on 01/31/17 */ -public class Thread_RX_CNormalUDP implements Runnable { + +class Thread_RX_CNormalUDP implements Runnable { + private double recvBytes = 0.0; + private double duration = 0.0; + private double throughput = 0.0; + @Override public void run() { + + // prevent multiple runs if (MainActivity.isRunning_RX_NormalUDP) return; - if (MainActivity.isVerbose) - Log.d("RX_NormalUDP", "Start RX NormalUDP"); MainActivity.isRunning_RX_NormalUDP = true; + + // variables Process proc; + String stdout; + BufferedReader stdout_buf, error_buf; String[] commd = new String[3]; + + // get the right command commd[0] = "su"; commd[1] = "-c"; + // ./client_recv_normaludp + // <[optional] recvsize (bytes)> <[optional] filepath> commd[2] = (MainActivity.isForcingCPU0?"taskset 1 ":"") - + MainActivity.binaryFolderPath + MainActivity.binary_RX_NormalUDP + " " - + MainActivity.bytes2send + " 32000"; + + MainActivity.binaryFolderPath + MainActivity.binary_RX_Normal + + " " + (MainActivity.isLocal ? Utilities.myInetIP : MainActivity.remoteIP) + + " " + MainActivity.RXportNum + + " " + MainActivity.bytes2send; + + Log.d("RX_NormalUDP", "Start RX NormalUDP"); + try { + // run process proc = Runtime.getRuntime().exec(commd); + + // if config to log per process while (MainActivity.isLoggingPerProcPID && MainActivity.perProcPID == -1) { - MainActivity.perProcPID = Utilities.getMyPID(MainActivity.binary_RX_NormalUDP, false); + MainActivity.perProcPID = Utilities.getMyPID(MainActivity.binary_RX_Splice, false); } proc.waitFor(); - InputStream stdout = proc.getInputStream(); - byte[] buffer = new byte[20]; - int read; - StringBuilder out = new StringBuilder(); - while(true){ - read = stdout.read(buffer); - if(read<0){ - MainActivity.myHandler.post(new Runnable() { - @Override - public void run() { - MainActivity.txt_results.append("Failed in RX_NormalUDP at port 32000\n"); - } - }); - break; - } - out.append(new String(buffer, 0, read)); - if(read<20){ - break; - } - } - if (out.length() > 0) { - MainActivity.UDPfinishTime = (int)Float.parseFloat(out.toString().trim()); - } - final String mOut = out.toString().trim(); - MainActivity.reportedFinishTime = Double.parseDouble(mOut); - if (MainActivity.isVerbose) { - Log.d("Thread_RX_CNormalUDP", mOut + "ms"); + + // read error + error_buf = new BufferedReader(new InputStreamReader( + proc.getErrorStream())); + final String error = error_buf.readLine(); // only one line error + + // read std out + stdout_buf = new BufferedReader(new InputStreamReader( + proc.getInputStream())); + + // get received bytes + stdout = stdout_buf.readLine(); + if (stdout == null) { + // error happens MainActivity.myHandler.post(new Runnable() { @Override public void run() { - MainActivity.txt_results.append("Time: " + mOut + "ms\n"); + MainActivity.txt_results.append("Err in RX_NormalUDP: " + error + "\n"); } }); + } else { + // sent bytes + recvBytes = Utilities.parseBinOutput(stdout); + + // duration + stdout = stdout_buf.readLine(); + duration = Utilities.parseBinOutput(stdout); + MainActivity.reportedFinishTime = duration; + if (MainActivity.isVerbose) { + MainActivity.myHandler.post(new Runnable() { + @Override + public void run() { + MainActivity.txt_results.append("Time: " + duration + "ms\n"); + } + }); + } + + // throughput + stdout = stdout_buf.readLine(); + throughput = Utilities.parseBinOutput(stdout); } - } catch (IOException e) { - e.printStackTrace(); - } catch (InterruptedException e) { + + } catch (IOException | InterruptedException e) { e.printStackTrace(); } - if (MainActivity.isVerbose) - Log.d("RX_NormalUDP", "Stop RX NormalUDP"); + + Log.d("RX_NormalUDP", "Stop RX NormalUDP"); + MainActivity.isRunning_RX_NormalUDP = false; MainActivity.perProcPID = -1; } diff --git a/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/Thread_RX_CRawNormal.java b/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/Thread_RX_CRawNormal.java index dbcbba4..2f5ec5f 100755 --- a/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/Thread_RX_CRawNormal.java +++ b/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/Thread_RX_CRawNormal.java @@ -2,74 +2,105 @@ package edu.ucsb.cs.sandlab.offloadingdemo; import android.util.Log; +import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; +import java.io.InputStreamReader; /** * Created by yanzi on 9/18/15. + * Updated on 01/31/17 */ -public class Thread_RX_CRawNormal implements Runnable { + +class Thread_RX_CRawNormal implements Runnable { + private double recvBytes = 0.0; + private double duration = 0.0; + private double throughput = 0.0; + @Override public void run() { + + // prevent multiple runs if (MainActivity.isRunning_RX_RawNormal) return; - if (MainActivity.isVerbose) - Log.d("RX_RawNormal", "Start RX RawNormal"); MainActivity.isRunning_RX_RawNormal = true; + + // variables Process proc; + String stdout; + BufferedReader stdout_buf, error_buf; String[] commd = new String[3]; + + // get the right command commd[0] = "su"; commd[1] = "-c"; + // ./client_recv_bypassl3 + // <[optional] recvsize (bytes)> <[optional] interface> <[optional] filepath> commd[2] = (MainActivity.isForcingCPU0?"taskset 1 ":"") - + MainActivity.binaryFolderPath + MainActivity.binary_RX_RawNormal + " " - + MainActivity.bytes2send; + + MainActivity.binaryFolderPath + MainActivity.binary_RX_RawNormal + + " " + (MainActivity.isLocal ? Utilities.myInetIP : MainActivity.remoteIP) + + " " + MainActivity.RXportNum + + " " + MainActivity.bytes2send; + + Log.d("RX_RawNormal", "Start RX RawNormal"); + try { + // run process proc = Runtime.getRuntime().exec(commd); + + // if config to log per process while (MainActivity.isLoggingPerProcPID && MainActivity.perProcPID == -1) { - MainActivity.perProcPID = Utilities.getMyPID(MainActivity.binary_RX_RawNormal, false); + MainActivity.perProcPID = Utilities.getMyPID(MainActivity.binary_RX_Splice, false); } proc.waitFor(); - InputStream stdout = proc.getInputStream(); - byte[] buffer = new byte[20]; - int read; - StringBuilder out = new StringBuilder(); - while(true){ - read = stdout.read(buffer); - if(read<0){ - MainActivity.myHandler.post(new Runnable() { - @Override - public void run() { - MainActivity.txt_results.append("Failed in RX_RawNormal at port " + MainActivity.RXportNum + "\n"); - } - }); - break; - } - out.append(new String(buffer, 0, read)); - if(read<20){ - break; - } - } - if (out.length() > 0) { - MainActivity.UDPfinishTime = (int)Float.parseFloat(out.toString().trim()); - } - final String mOut = out.toString().trim(); - MainActivity.reportedFinishTime = Double.parseDouble(mOut); - if (MainActivity.isVerbose) { - Log.d("Thread_RX_CRawNormal", mOut + "ms"); + + // read error + error_buf = new BufferedReader(new InputStreamReader( + proc.getErrorStream())); + final String error = error_buf.readLine(); // only one line error + + // read std out + stdout_buf = new BufferedReader(new InputStreamReader( + proc.getInputStream())); + + // get received bytes + stdout = stdout_buf.readLine(); + if (stdout == null) { + // error happens MainActivity.myHandler.post(new Runnable() { @Override public void run() { - MainActivity.txt_results.append("Time: " + mOut + "ms\n"); + MainActivity.txt_results.append("Err in RX_RawNormal: " + error + "\n"); } }); + } else { + // sent bytes + recvBytes = Utilities.parseBinOutput(stdout); + + // duration + stdout = stdout_buf.readLine(); + duration = Utilities.parseBinOutput(stdout); + MainActivity.reportedFinishTime = duration; + if (MainActivity.isVerbose) { + MainActivity.myHandler.post(new Runnable() { + @Override + public void run() { + MainActivity.txt_results.append("Time: " + duration + "ms\n"); + } + }); + } + + // throughput + stdout = stdout_buf.readLine(); + throughput = Utilities.parseBinOutput(stdout); } - } catch (IOException e) { - e.printStackTrace(); - } catch (InterruptedException e) { + + } catch (IOException | InterruptedException e) { e.printStackTrace(); } - if (MainActivity.isVerbose) - Log.d("RX_RawNormal", "Stop RX RawNormal"); + + Log.d("RX_RawNormal", "Stop RX RawNormal"); + MainActivity.isRunning_RX_RawNormal = false; MainActivity.perProcPID = -1; } diff --git a/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/Thread_RX_CSendfile.java b/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/Thread_RX_CSendfile.java index 8661048..e03bf2c 100755 --- a/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/Thread_RX_CSendfile.java +++ b/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/Thread_RX_CSendfile.java @@ -2,71 +2,106 @@ package edu.ucsb.cs.sandlab.offloadingdemo; import android.util.Log; +import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; +import java.io.InputStreamReader; /** * Created by yanzi on 9/18/15. + * Updated on 01/31/17 */ -public class Thread_RX_CSendfile implements Runnable { + +class Thread_RX_CSendfile implements Runnable { + private double recvBytes = 0.0; + private double duration = 0.0; + private double throughput = 0.0; + @Override public void run() { + + // prevent multiple runs if (MainActivity.isRunning_RX_Sendfile) return; - if (MainActivity.isVerbose) - Log.d("RX_Sendfile", "Start RX Sendfile"); MainActivity.isRunning_RX_Sendfile = true; + + // variables Process proc; + String stdout; + BufferedReader stdout_buf, error_buf; String[] commd = new String[3]; + + // get the right command commd[0] = "su"; commd[1] = "-c"; + // ./client_recv_normaltcp_sendfile + // <[optional] recvsize (bytes)> <[optional] filepath> commd[2] = (MainActivity.isForcingCPU0?"taskset 1 ":"") - + MainActivity.binaryFolderPath + MainActivity.binary_RX_Sendfile + " " - + MainActivity.bytes2send + " " + MainActivity.RXportNum; + + MainActivity.binaryFolderPath + MainActivity.binary_RX_Sendfile + + " " + (MainActivity.isLocal ? Utilities.myInetIP : MainActivity.remoteIP) + + " " + MainActivity.RXportNum + + " " + MainActivity.bytes2send; + + + Log.d("RX_Sendfile", "Start RX Sendfile"); try { + // run process proc = Runtime.getRuntime().exec(commd); + + // if config to log per process while (MainActivity.isLoggingPerProcPID && MainActivity.perProcPID == -1) { - MainActivity.perProcPID = Utilities.getMyPID(MainActivity.binary_RX_Sendfile, false); + MainActivity.perProcPID = Utilities.getMyPID(MainActivity.binary_RX_Splice, false); } proc.waitFor(); - InputStream stdout = proc.getInputStream(); - byte[] buffer = new byte[20]; - int read; - StringBuilder out = new StringBuilder(); - while(true){ - read = stdout.read(buffer); - if(read<0){ - MainActivity.myHandler.post(new Runnable() { - @Override - public void run() { - MainActivity.txt_results.append("Failed in RX_Sendfile at port " + MainActivity.RXportNum + "\n"); - } - }); - break; - } - out.append(new String(buffer, 0, read)); - if(read<20){ - break; - } - } - final String mOut = out.toString().trim(); - MainActivity.reportedFinishTime = Double.parseDouble(mOut); - if (MainActivity.isVerbose) { - Log.d("Thread_RX_CSendfile", mOut + "ms"); + + // read error + error_buf = new BufferedReader(new InputStreamReader( + proc.getErrorStream())); + final String error = error_buf.readLine(); // only one line error + + // read std out + stdout_buf = new BufferedReader(new InputStreamReader( + proc.getInputStream())); + + // get received bytes + stdout = stdout_buf.readLine(); + if (stdout == null) { + // error happens MainActivity.myHandler.post(new Runnable() { @Override public void run() { - MainActivity.txt_results.append("Time: " + mOut + "ms\n"); + MainActivity.txt_results.append( + "Err in RX_Normal_Sendfile: " + error + "\n"); } }); + } else { + // sent bytes + recvBytes = Utilities.parseBinOutput(stdout); + + // duration + stdout = stdout_buf.readLine(); + duration = Utilities.parseBinOutput(stdout); + MainActivity.reportedFinishTime = duration; + if (MainActivity.isVerbose) { + MainActivity.myHandler.post(new Runnable() { + @Override + public void run() { + MainActivity.txt_results.append("Time: " + duration + "ms\n"); + } + }); + } + + // throughput + stdout = stdout_buf.readLine(); + throughput = Utilities.parseBinOutput(stdout); } - } catch (IOException e) { - e.printStackTrace(); - } catch (InterruptedException e) { + + } catch (IOException | InterruptedException e) { e.printStackTrace(); } - if (MainActivity.isVerbose) - Log.d("RX_Sendfile", "Stop RX Sendfile"); + + Log.d("RX_Sendfile", "Stop RX Sendfile"); + MainActivity.isRunning_RX_Sendfile = false; MainActivity.perProcPID = -1; } diff --git a/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/Thread_RX_CSplice.java b/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/Thread_RX_CSplice.java index 513749c..36b20ac 100755 --- a/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/Thread_RX_CSplice.java +++ b/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/Thread_RX_CSplice.java @@ -2,71 +2,104 @@ package edu.ucsb.cs.sandlab.offloadingdemo; import android.util.Log; +import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; +import java.io.InputStreamReader; /** * Created by yanzi on 9/18/15. + * Updated on 01/31/17 */ -public class Thread_RX_CSplice implements Runnable { + +class Thread_RX_CSplice implements Runnable { + private double recvBytes = 0.0; + private double duration = 0.0; + private double throughput = 0.0; + @Override public void run() { + + // prevent multiple runs if (MainActivity.isRunning_RX_Splice) return; - if (MainActivity.isVerbose) - Log.d("RX_Splicee", "Start RX Splice"); MainActivity.isRunning_RX_Splice = true; + + // variables Process proc; + String stdout; + BufferedReader stdout_buf, error_buf; String[] commd = new String[3]; + + // get the right command commd[0] = "su"; commd[1] = "-c"; + // ./client_recv_normaltcp_splice + // <[optional] recvsize (bytes)> <[optional] filepath> commd[2] = (MainActivity.isForcingCPU0?"taskset 1 ":"") - + MainActivity.binaryFolderPath + MainActivity.binary_RX_Splice + " " - + MainActivity.bytes2send + " " + MainActivity.RXportNum; + + MainActivity.binaryFolderPath + MainActivity.binary_RX_Splice + + " " + (MainActivity.isLocal ? Utilities.myInetIP : MainActivity.remoteIP) + + " " + MainActivity.RXportNum + + " " + MainActivity.bytes2send; + + Log.d("RX_Splice", "Start RX Splice"); try { + // run process proc = Runtime.getRuntime().exec(commd); + + // if config to log per process while (MainActivity.isLoggingPerProcPID && MainActivity.perProcPID == -1) { MainActivity.perProcPID = Utilities.getMyPID(MainActivity.binary_RX_Splice, false); } proc.waitFor(); - InputStream stdout = proc.getInputStream(); - byte[] buffer = new byte[20]; - int read; - StringBuilder out = new StringBuilder(); - while(true){ - read = stdout.read(buffer); - if(read<0){ - MainActivity.myHandler.post(new Runnable() { - @Override - public void run() { - MainActivity.txt_results.append("Failed in RX_Splice at port " + MainActivity.RXportNum + "\n"); - } - }); - break; - } - out.append(new String(buffer, 0, read)); - if(read<20){ - break; - } - } - final String mOut = out.toString().trim(); - MainActivity.reportedFinishTime = Double.parseDouble(mOut); - if (MainActivity.isVerbose) { - Log.d("Thread_RX_CSplice", mOut + "ms"); + + // read error + error_buf = new BufferedReader(new InputStreamReader( + proc.getErrorStream())); + final String error = error_buf.readLine(); // only one line error + + // read std out + stdout_buf = new BufferedReader(new InputStreamReader( + proc.getInputStream())); + + // get received bytes + stdout = stdout_buf.readLine(); + if (stdout == null) { + // error happens MainActivity.myHandler.post(new Runnable() { @Override public void run() { - MainActivity.txt_results.append("Time: " + mOut + "ms\n"); + MainActivity.txt_results.append("Err in RX_Normal_Splice: " + error + "\n"); } }); + } else { + // sent bytes + recvBytes = Utilities.parseBinOutput(stdout); + + // duration + stdout = stdout_buf.readLine(); + duration = Utilities.parseBinOutput(stdout); + MainActivity.reportedFinishTime = duration; + if (MainActivity.isVerbose) { + MainActivity.myHandler.post(new Runnable() { + @Override + public void run() { + MainActivity.txt_results.append("Time: " + duration + "ms\n"); + } + }); + } + + // throughput + stdout = stdout_buf.readLine(); + throughput = Utilities.parseBinOutput(stdout); } - } catch (IOException e) { - e.printStackTrace(); - } catch (InterruptedException e) { + + } catch (IOException | InterruptedException e) { e.printStackTrace(); } - if (MainActivity.isVerbose) - Log.d("RX_Splice", "Stop RX Splice"); + + Log.d("RX_Splice", "Stop RX Splice"); + MainActivity.isRunning_RX_Splice = false; MainActivity.perProcPID = -1; } diff --git a/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/Thread_TX_CRawNormal.java b/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/Thread_TX_CRawNormal.java index b37d1d4..8ae6b9b 100755 --- a/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/Thread_TX_CRawNormal.java +++ b/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/Thread_TX_CRawNormal.java @@ -19,6 +19,7 @@ class Thread_TX_CRawNormal implements Runnable { @Override public void run() { + // prevent multiple runs if (MainActivity.isRunning_TX_RawNormal) return; diff --git a/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/Thread_TX_CSplice.java b/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/Thread_TX_CSplice.java index 30780bc..7bd65d4 100755 --- a/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/Thread_TX_CSplice.java +++ b/OffloadingDemo/mobile/src/main/java/edu/ucsb/cs/sandlab/offloadingdemo/Thread_TX_CSplice.java @@ -19,6 +19,7 @@ class Thread_TX_CSplice implements Runnable { @Override public void run() { + // prevent multiple runs if (MainActivity.isRunning_TX_Splice) return; @@ -30,8 +31,6 @@ class Thread_TX_CSplice implements Runnable { BufferedReader stdout_buf, error_buf; String[] commd = new String[3]; - MainActivity.isRunning_TX_Splice = true; - // get the right command commd[0] = "su"; commd[1] = "-c";