solved large bandwidth serialization problem

ObliVMGC/com/oblivm/backend/gc/regular/GCEva.java

@@ -2,7 +2,6 @@ package com.oblivm.backend.gc.regular;
 
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.List;
 
 import com.oblivm.backend.flexsc.Flag;
 import com.oblivm.backend.flexsc.Mode;
@@ -23,7 +22,7 @@ public class GCEva extends GCEvaComp {
 	Timer timer = null;
 	int p;
 	int m;
-	List<byte[]> msg = new ArrayList<byte[]>(threshold);
+	ArrayList<byte[]> msg = new ArrayList<byte[]>(threshold);
 
 	public GCEva(Network channel) {
 		super(channel, Mode.REAL);
@@ -55,7 +54,7 @@ public class GCEva extends GCEvaComp {
 	public void receiveLastSetGTT() {
 		int remainder = (int) (numOfAnds % threshold);
 		if (remainder > 0) {
-			msg = channel.sender.readObject();
+			msg = channel.sender.readArrayList();
 			for (int i = 0; i < remainder; i++) {
 				if (curr == null) {
 					curr = this;
@@ -88,7 +87,7 @@ public class GCEva extends GCEvaComp {
 			}
 		} else {
 			if (numOfAnds % threshold == 0) {
-				msg = channel.sender.readObject();
+				msg = channel.sender.readArrayList();
 				for (int i = 0; i < threshold; i++) {
 					if (curr == null) {
 						curr = this;

ObliVMGC/com/oblivm/backend/gc/regular/GCGen.java

@@ -1,7 +1,6 @@
 package com.oblivm.backend.gc.regular;
 
 import java.util.ArrayList;
-import java.util.List;
 
 import com.oblivm.backend.flexsc.Flag;
 import com.oblivm.backend.flexsc.Mode;
@@ -17,7 +16,7 @@ public class GCGen extends GCGenComp {
 	Timer timer = null;
 	int p;
 	int m;
-	List<byte[]> msg = new ArrayList<byte[]>(threshold);
+	ArrayList<byte[]> msg = new ArrayList<byte[]>(threshold);
 
 	public GCGen(Network channel) {
 		super(channel, Mode.REAL);

src/communication/ComUtil.java

@@ -1,232 +1,632 @@
 package communication;
 
-import java.util.Arrays;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
 
 import com.oblivm.backend.gc.GCSignal;
 
+import oram.Bucket;
 import oram.Tuple;
-import util.Util;
 
 public class ComUtil {
-	public static byte[] toByteArray(byte[][] in) {
+	public static byte[] serialize(byte[][] in) {
-		int len1 = in.length;
+		ByteArrayOutputStream baos = new ByteArrayOutputStream();
-		int len2 = in[0].length;
+		DataOutputStream dos = new DataOutputStream(baos);
-		byte[] out = new byte[len1 * len2];
+		byte[] out = null;
-		for (int i = 0; i < len1; i++)
+		try {
-			System.arraycopy(in[i], 0, out, i * len2, len2);
+			dos.writeInt(in.length);
+			dos.writeInt(in[0].length);
+			for (int i = 0; i < in.length; i++)
+				dos.write(in[i]);
+			out = baos.toByteArray();
+		} catch (IOException e) {
+			e.printStackTrace();
+		} finally {
+			try {
+				dos.close();
+				baos.close();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
 		return out;
 	}
 
-	public static byte[][] toDoubleByteArray(byte[] in, int len1) {
+	public static byte[][] toDoubleByteArray(byte[] in) {
-		int len2 = in.length / len1;
+		ByteArrayInputStream bais = new ByteArrayInputStream(in);
-		byte[][] out = new byte[len1][];
+		DataInputStream dis = new DataInputStream(bais);
-		for (int i = 0; i < len1; i++) {
+		byte[][] out = null;
-			out[i] = Arrays.copyOfRange(in, i * len2, (i + 1) * len2);
+		try {
+			int len1 = dis.readInt();
+			int len2 = dis.readInt();
+			out = new byte[len1][len2];
+			for (int i = 0; i < len1; i++)
+				dis.read(out[i]);
+		} catch (IOException e) {
+			e.printStackTrace();
+		} finally {
+			try {
+				dis.close();
+				bais.close();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
 		}
 		return out;
 	}
 
-	public static byte[] toByteArray(byte[][][] in) {
+	public static byte[] serialize(byte[][][] in) {
-		int len1 = in.length;
+		ByteArrayOutputStream baos = new ByteArrayOutputStream();
-		int len2 = in[0].length;
+		DataOutputStream dos = new DataOutputStream(baos);
-		int len3 = in[0][0].length;
+		byte[] out = null;
-		byte[] out = new byte[len1 * len2 * len3];
+		try {
-		for (int i = 0; i < len1; i++)
+			dos.writeInt(in.length);
-			for (int j = 0; j < len2; j++)
+			dos.writeInt(in[0].length);
-				System.arraycopy(in[i][j], 0, out, i * len2 * len3 + j * len3, len3);
+			dos.writeInt(in[0][0].length);
+			for (int i = 0; i < in.length; i++)
+				for (int j = 0; j < in[i].length; j++)
+					dos.write(in[i][j]);
+			out = baos.toByteArray();
+		} catch (IOException e) {
+			e.printStackTrace();
+		} finally {
+			try {
+				dos.close();
+				baos.close();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
 		return out;
 	}
 
-	public static byte[][][] toTripleByteArray(byte[] in, int len1, int len2) {
+	public static byte[][][] toTripleByteArray(byte[] in) {
-		int len3 = in.length / len1 / len2;
+		ByteArrayInputStream bais = new ByteArrayInputStream(in);
-		byte[][][] out = new byte[len1][len2][];
+		DataInputStream dis = new DataInputStream(bais);
-		for (int i = 0; i < len1; i++) {
+		byte[][][] out = null;
-			for (int j = 0; j < len2; j++) {
+		try {
-				out[i][j] = Arrays.copyOfRange(in, i * len2 * len3 + j * len3, i * len2 * len3 + j * len3 + len3);
+			int len1 = dis.readInt();
+			int len2 = dis.readInt();
+			int len3 = dis.readInt();
+			out = new byte[len1][len2][len3];
+			for (int i = 0; i < len1; i++)
+				for (int j = 0; j < len2; j++)
+					dis.read(out[i][j]);
+		} catch (IOException e) {
+			e.printStackTrace();
+		} finally {
+			try {
+				dis.close();
+				bais.close();
+			} catch (IOException e) {
+				e.printStackTrace();
 			}
 		}
 		return out;
 	}
 
-	public static byte[] toByteArray(int[] in) {
+	public static byte[] serialize(int[] in) {
-		byte[] out = new byte[in.length * 4];
+		ByteArrayOutputStream baos = new ByteArrayOutputStream();
-		for (int i = 0; i < in.length; i++) {
+		DataOutputStream dos = new DataOutputStream(baos);
-			byte[] n = Util.intToBytes(in[i]);
+		byte[] out = null;
-			System.arraycopy(n, 0, out, i * 4, 4);
+		try {
+			dos.writeInt(in.length);
+			for (int i = 0; i < in.length; i++)
+				dos.writeInt(in[i]);
+			out = baos.toByteArray();
+		} catch (IOException e) {
+			e.printStackTrace();
+		} finally {
+			try {
+				dos.close();
+				baos.close();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
 		}
 		return out;
 	}
 
 	public static int[] toIntArray(byte[] in) {
-		int len1 = in.length / 4;
+		ByteArrayInputStream bais = new ByteArrayInputStream(in);
-		int[] out = new int[len1];
+		DataInputStream dis = new DataInputStream(bais);
-		for (int i = 0; i < len1; i++) {
+		int[] out = null;
-			byte[] b = Arrays.copyOfRange(in, i * 4, (i + 1) * 4);
+		try {
-			out[i] = Util.bytesToInt(b);
+			int len1 = dis.readInt();
+			out = new int[len1];
+			for (int i = 0; i < len1; i++)
+				out[i] = dis.readInt();
+		} catch (IOException e) {
+			e.printStackTrace();
+		} finally {
+			try {
+				dis.close();
+				bais.close();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
 		}
 		return out;
 	}
 
-	public static byte[] toByteArray(int[][] in) {
+	public static byte[] serialize(int[][] in) {
-		int len1 = in.length;
+		ByteArrayOutputStream baos = new ByteArrayOutputStream();
-		int len2 = in[0].length;
+		DataOutputStream dos = new DataOutputStream(baos);
-		byte[] out = new byte[len1 * len2 * 4];
+		byte[] out = null;
-		for (int i = 0; i < len1; i++) {
+		try {
-			for (int j = 0; j < len2; j++) {
+			dos.writeInt(in.length);
-				byte[] n = Util.intToBytes(in[i][j]);
+			dos.writeInt(in[0].length);
-				System.arraycopy(n, 0, out, (i * len2 + j) * 4, 4);
+			for (int i = 0; i < in.length; i++)
+				for (int j = 0; j < in[i].length; j++)
+					dos.writeInt(in[i][j]);
+			out = baos.toByteArray();
+		} catch (IOException e) {
+			e.printStackTrace();
+		} finally {
+			try {
+				dos.close();
+				baos.close();
+			} catch (IOException e) {
+				e.printStackTrace();
 			}
 		}
 		return out;
 	}
 
-	public static int[][] toDoubleIntArray(byte[] in, int len1) {
+	public static int[][] toDoubleIntArray(byte[] in) {
-		int len2 = in.length / len1 / 4;
+		ByteArrayInputStream bais = new ByteArrayInputStream(in);
-		int[][] out = new int[len1][len2];
+		DataInputStream dis = new DataInputStream(bais);
-		for (int i = 0; i < len1; i++) {
+		int[][] out = null;
-			for (int j = 0; j < len2; j++) {
+		try {
-				byte[] b = Arrays.copyOfRange(in, (i * len2 + j) * 4, (i * len2 + j + 1) * 4);
+			int len1 = dis.readInt();
-				out[i][j] = Util.bytesToInt(b);
+			int len2 = dis.readInt();
+			out = new int[len1][len2];
+			for (int i = 0; i < len1; i++)
+				for (int j = 0; j < len2; j++)
+					out[i][j] = dis.readInt();
+		} catch (IOException e) {
+			e.printStackTrace();
+		} finally {
+			try {
+				dis.close();
+				bais.close();
+			} catch (IOException e) {
+				e.printStackTrace();
 			}
 		}
 		return out;
 	}
 
-	public static byte[] toByteArray(Tuple[] in) {
+	public static byte[] serialize(Tuple in) {
-		int len1 = in.length;
+		ByteArrayOutputStream baos = new ByteArrayOutputStream();
-		int f = in[0].getF().length;
+		DataOutputStream dos = new DataOutputStream(baos);
-		int n = in[0].getN().length;
+		byte[] out = null;
-		int l = in[0].getL().length;
+		try {
-		int a = in[0].getA().length;
+			dos.writeInt(in.getF().length);
-		int len2 = f + n + l + a;
+			dos.writeInt(in.getN().length);
-		byte[] out = new byte[len1 * len2];
+			dos.writeInt(in.getL().length);
-		for (int i = 0; i < len1; i++) {
+			dos.writeInt(in.getA().length);
-			System.arraycopy(in[i].getF(), 0, out, i * len2, f);
+			dos.write(in.getF());
-			System.arraycopy(in[i].getN(), 0, out, i * len2 + f, n);
+			dos.write(in.getN());
-			System.arraycopy(in[i].getL(), 0, out, i * len2 + f + n, l);
+			dos.write(in.getL());
-			System.arraycopy(in[i].getA(), 0, out, i * len2 + f + n + l, a);
+			dos.write(in.getA());
+			out = baos.toByteArray();
+		} catch (IOException e) {
+			e.printStackTrace();
+		} finally {
+			try {
+				dos.close();
+				baos.close();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
 		}
 		return out;
 	}
 
-	public static Tuple[] toTupleArray(byte[] in, int len1, int f, int n, int l) {
+	public static Tuple toTuple(byte[] in) {
-		int len2 = in.length / len1;
+		ByteArrayInputStream bais = new ByteArrayInputStream(in);
-		Tuple[] out = new Tuple[len1];
+		DataInputStream dis = new DataInputStream(bais);
-		for (int i = 0; i < len1; i++) {
+		Tuple out = null;
-			byte[] F = Arrays.copyOfRange(in, i * len2, i * len2 + f);
+		try {
-			byte[] N = Arrays.copyOfRange(in, i * len2 + f, i * len2 + f + n);
+			int f = dis.readInt();
-			byte[] L = Arrays.copyOfRange(in, i * len2 + f + n, i * len2 + f + n + l);
+			int n = dis.readInt();
-			byte[] A = Arrays.copyOfRange(in, i * len2 + f + n + l, (i + 1) * len2);
+			int l = dis.readInt();
-			out[i] = new Tuple(F, N, L, A);
+			int a = dis.readInt();
+			byte[] F = new byte[f];
+			byte[] N = new byte[n];
+			byte[] L = new byte[l];
+			byte[] A = new byte[a];
+			dis.read(F);
+			dis.read(N);
+			dis.read(L);
+			dis.read(A);
+			out = new Tuple(F, N, L, A);
+		} catch (IOException e) {
+			e.printStackTrace();
+		} finally {
+			try {
+				dis.close();
+				bais.close();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
 		}
 		return out;
 	}
 
-	public static byte[] toByteArray(GCSignal[] in) {
+	public static byte[] serialize(Tuple[] in) {
-		byte[] out = new byte[in.length * GCSignal.len];
+		ByteArrayOutputStream baos = new ByteArrayOutputStream();
-		for (int i = 0; i < in.length; i++) {
+		DataOutputStream dos = new DataOutputStream(baos);
-			System.arraycopy(in[i].bytes, 0, out, i * GCSignal.len, GCSignal.len);
+		byte[] out = null;
+		try {
+			dos.writeInt(in.length);
+			dos.writeInt(in[0].getF().length);
+			dos.writeInt(in[0].getN().length);
+			dos.writeInt(in[0].getL().length);
+			dos.writeInt(in[0].getA().length);
+			for (int i = 0; i < in.length; i++) {
+				dos.write(in[i].getF());
+				dos.write(in[i].getN());
+				dos.write(in[i].getL());
+				dos.write(in[i].getA());
+			}
+			out = baos.toByteArray();
+		} catch (IOException e) {
+			e.printStackTrace();
+		} finally {
+			try {
+				dos.close();
+				baos.close();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
 		}
 		return out;
 	}
 
-	public static GCSignal[] toGCSignalArray(byte[] in) {
+	public static Tuple[] toTupleArray(byte[] in) {
-		int len1 = in.length / GCSignal.len;
+		ByteArrayInputStream bais = new ByteArrayInputStream(in);
-		GCSignal[] out = new GCSignal[len1];
+		DataInputStream dis = new DataInputStream(bais);
-		for (int i = 0; i < len1; i++) {
+		Tuple[] out = null;
-			byte[] b = Arrays.copyOfRange(in, i * GCSignal.len, (i + 1) * GCSignal.len);
+		try {
-			out[i] = new GCSignal(b);
+			int len = dis.readInt();
+			int f = dis.readInt();
+			int n = dis.readInt();
+			int l = dis.readInt();
+			int a = dis.readInt();
+			out = new Tuple[len];
+			for (int i = 0; i < len; i++) {
+				byte[] F = new byte[f];
+				byte[] N = new byte[n];
+				byte[] L = new byte[l];
+				byte[] A = new byte[a];
+				dis.read(F);
+				dis.read(N);
+				dis.read(L);
+				dis.read(A);
+				out[i] = new Tuple(F, N, L, A);
+			}
+		} catch (IOException e) {
+			e.printStackTrace();
+		} finally {
+			try {
+				dis.close();
+				bais.close();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
 		}
 		return out;
 	}
 
-	public static byte[] toByteArray(GCSignal[][] in) {
+	public static byte[] serialize(GCSignal[] in) {
-		int len1 = in.length;
+		ByteArrayOutputStream baos = new ByteArrayOutputStream();
-		int len2 = in[0].length;
+		DataOutputStream dos = new DataOutputStream(baos);
-		byte[] out = new byte[len1 * len2 * GCSignal.len];
+		byte[] out = null;
-		for (int i = 0; i < len1; i++) {
+		try {
-			for (int j = 0; j < len2; j++) {
+			dos.writeInt(in.length);
-				System.arraycopy(in[i][j].bytes, 0, out, (i * len2 + j) * GCSignal.len, GCSignal.len);
+			for (int i = 0; i < in.length; i++)
+				dos.write(in[i].bytes);
+			out = baos.toByteArray();
+		} catch (IOException e) {
+			e.printStackTrace();
+		} finally {
+			try {
+				dos.close();
+				baos.close();
+			} catch (IOException e) {
+				e.printStackTrace();
 			}
 		}
 		return out;
 	}
 
-	public static GCSignal[][] toDoubleGCSignalArray(byte[] in, int len1) {
+	public static GCSignal[] toGCSignalArray(byte[] in) {
-		int len2 = in.length / len1 / GCSignal.len;
+		ByteArrayInputStream bais = new ByteArrayInputStream(in);
-		GCSignal[][] out = new GCSignal[len1][len2];
+		DataInputStream dis = new DataInputStream(bais);
-		for (int i = 0; i < len1; i++) {
+		GCSignal[] out = null;
-			for (int j = 0; j < len2; j++) {
+		try {
-				byte[] b = Arrays.copyOfRange(in, (i * len2 + j) * GCSignal.len, (i * len2 + j + 1) * GCSignal.len);
+			int len1 = dis.readInt();
-				out[i][j] = new GCSignal(b);
+			out = new GCSignal[len1];
+			for (int i = 0; i < len1; i++) {
+				out[i] = new GCSignal(new byte[GCSignal.len]);
+				dis.read(out[i].bytes);
+			}
+		} catch (IOException e) {
+			e.printStackTrace();
+		} finally {
+			try {
+				dis.close();
+				bais.close();
+			} catch (IOException e) {
+				e.printStackTrace();
 			}
 		}
 		return out;
 	}
 
-	public static byte[] toByteArray(GCSignal[][][] in) {
+	public static byte[] serialize(GCSignal[][] in) {
-		int len1 = in.length;
+		ByteArrayOutputStream baos = new ByteArrayOutputStream();
-		int len2 = in[0].length;
+		DataOutputStream dos = new DataOutputStream(baos);
-		int len3 = in[0][0].length;
+		byte[] out = null;
-		byte[] out = new byte[len1 * len2 * len3 * GCSignal.len];
+		try {
-		for (int i = 0; i < len1; i++) {
+			dos.writeInt(in.length);
-			for (int j = 0; j < len2; j++) {
+			dos.writeInt(in[0].length);
-				for (int k = 0; k < len3; k++) {
+			for (int i = 0; i < in.length; i++)
-					System.arraycopy(in[i][j][k].bytes, 0, out, (i * len2 * len3 + j * len3 + k) * GCSignal.len,
+				for (int j = 0; j < in[i].length; j++)
-							GCSignal.len);
+					dos.write(in[i][j].bytes);
-				}
+			out = baos.toByteArray();
+		} catch (IOException e) {
+			e.printStackTrace();
+		} finally {
+			try {
+				dos.close();
+				baos.close();
+			} catch (IOException e) {
+				e.printStackTrace();
 			}
 		}
 		return out;
 	}
 
-	public static GCSignal[][][] toTripleGCSignalArray(byte[] in, int len1, int len2) {
+	public static GCSignal[][] toDoubleGCSignalArray(byte[] in) {
-		int len3 = in.length / len1 / len2 / GCSignal.len;
+		ByteArrayInputStream bais = new ByteArrayInputStream(in);
-		GCSignal[][][] out = new GCSignal[len1][len2][len3];
+		DataInputStream dis = new DataInputStream(bais);
-		for (int i = 0; i < len1; i++) {
+		GCSignal[][] out = null;
-			for (int j = 0; j < len2; j++) {
+		try {
-				for (int k = 0; k < len3; k++) {
+			int len1 = dis.readInt();
-					byte[] b = Arrays.copyOfRange(in, (i * len2 * len3 + j * len3 + k) * GCSignal.len,
+			int len2 = dis.readInt();
-							(i * len2 * len3 + j * len3 + k + 1) * GCSignal.len);
+			out = new GCSignal[len1][len2];
-					out[i][j][k] = new GCSignal(b);
+			for (int i = 0; i < len1; i++)
+				for (int j = 0; j < len2; j++) {
+					out[i][j] = new GCSignal(new byte[GCSignal.len]);
+					dis.read(out[i][j].bytes);
 				}
+		} catch (IOException e) {
+			e.printStackTrace();
+		} finally {
+			try {
+				dis.close();
+				bais.close();
+			} catch (IOException e) {
+				e.printStackTrace();
 			}
 		}
 		return out;
 	}
 
-	public static byte[] toByteArray(GCSignal[][][][] in) {
+	public static byte[] serialize(GCSignal[][][] in) {
-		int len1 = in.length;
+		ByteArrayOutputStream baos = new ByteArrayOutputStream();
-		int len2 = in[0].length;
+		DataOutputStream dos = new DataOutputStream(baos);
-		int len3 = in[0][0].length;
+		byte[] out = null;
-		int len4 = in[0][0][0].length;
+		try {
-		byte[] out = new byte[len1 * len2 * len3 * len4 * GCSignal.len];
+			dos.writeInt(in.length);
-		for (int i = 0; i < len1; i++) {
+			dos.writeInt(in[0].length);
-			for (int j = 0; j < len2; j++) {
+			dos.writeInt(in[0][0].length);
-				for (int k = 0; k < len3; k++) {
+			for (int i = 0; i < in.length; i++)
-					for (int l = 0; l < len4; l++) {
+				for (int j = 0; j < in[i].length; j++)
-						System.arraycopy(in[i][j][k][l].bytes, 0, out,
+					for (int k = 0; k < in[i][j].length; k++)
-								(i * len2 * len3 * len4 + j * len3 * len4 + k * len4 + l) * GCSignal.len, GCSignal.len);
+						dos.write(in[i][j][k].bytes);
-					}
+			out = baos.toByteArray();
-				}
+		} catch (IOException e) {
+			e.printStackTrace();
+		} finally {
+			try {
+				dos.close();
+				baos.close();
+			} catch (IOException e) {
+				e.printStackTrace();
 			}
 		}
 		return out;
 	}
 
-	public static GCSignal[][][][] toQuadGCSignalArray(byte[] in, int len1, int len2, int len3) {
+	public static GCSignal[][][] toTripleGCSignalArray(byte[] in) {
-		int len4 = in.length / len1 / len2 / len3 / GCSignal.len;
+		ByteArrayInputStream bais = new ByteArrayInputStream(in);
-		GCSignal[][][][] out = new GCSignal[len1][len2][len3][len4];
+		DataInputStream dis = new DataInputStream(bais);
-		for (int i = 0; i < len1; i++) {
+		GCSignal[][][] out = null;
-			for (int j = 0; j < len2; j++) {
+		try {
-				for (int k = 0; k < len3; k++) {
+			int len1 = dis.readInt();
-					for (int l = 0; l < len4; l++) {
+			int len2 = dis.readInt();
-						byte[] b = Arrays.copyOfRange(in,
+			int len3 = dis.readInt();
-								(i * len2 * len3 * len4 + j * len3 * len4 + k * len4 + l) * GCSignal.len,
+			out = new GCSignal[len1][len2][len3];
-								(i * len2 * len3 * len4 + j * len3 * len4 + k * len4 + l + 1) * GCSignal.len);
+			for (int i = 0; i < len1; i++)
-						out[i][j][k][l] = new GCSignal(b);
+				for (int j = 0; j < len2; j++)
+					for (int k = 0; k < len3; k++) {
+						out[i][j][k] = new GCSignal(new byte[GCSignal.len]);
+						dis.read(out[i][j][k].bytes);
 					}
-				}
+		} catch (IOException e) {
+			e.printStackTrace();
+		} finally {
+			try {
+				dis.close();
+				bais.close();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+		return out;
+	}
+
+	public static byte[] serialize(GCSignal[][][][] in) {
+		ByteArrayOutputStream baos = new ByteArrayOutputStream();
+		DataOutputStream dos = new DataOutputStream(baos);
+		byte[] out = null;
+		try {
+			dos.writeInt(in.length);
+			dos.writeInt(in[0].length);
+			dos.writeInt(in[0][0].length);
+			dos.writeInt(in[0][0][0].length);
+			for (int i = 0; i < in.length; i++)
+				for (int j = 0; j < in[i].length; j++)
+					for (int k = 0; k < in[i][j].length; k++)
+						for (int l = 0; l < in[i][j][k].length; l++)
+							dos.write(in[i][j][k][l].bytes);
+			out = baos.toByteArray();
+		} catch (IOException e) {
+			e.printStackTrace();
+		} finally {
+			try {
+				dos.close();
+				baos.close();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+		return out;
+	}
+
+	public static GCSignal[][][][] toQuadGCSignalArray(byte[] in) {
+		ByteArrayInputStream bais = new ByteArrayInputStream(in);
+		DataInputStream dis = new DataInputStream(bais);
+		GCSignal[][][][] out = null;
+		try {
+			int len1 = dis.readInt();
+			int len2 = dis.readInt();
+			int len3 = dis.readInt();
+			int len4 = dis.readInt();
+			out = new GCSignal[len1][len2][len3][len4];
+			for (int i = 0; i < len1; i++)
+				for (int j = 0; j < len2; j++)
+					for (int k = 0; k < len3; k++)
+						for (int l = 0; l < len4; l++) {
+							out[i][j][k][l] = new GCSignal(new byte[GCSignal.len]);
+							dis.read(out[i][j][k][l].bytes);
+						}
+		} catch (IOException e) {
+			e.printStackTrace();
+		} finally {
+			try {
+				dis.close();
+				bais.close();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+		return out;
+	}
+
+	public static byte[] serialize(Bucket[] in) {
+		ByteArrayOutputStream baos = new ByteArrayOutputStream();
+		DataOutputStream dos = new DataOutputStream(baos);
+		byte[] out = null;
+		try {
+			byte[] b = serialize(Bucket.bucketsToTuples(in));
+			dos.writeInt(in.length);
+			dos.writeInt(in[0].getNumTuples());
+			dos.writeInt(in[1].getNumTuples());
+			dos.writeInt(b.length);
+			dos.write(b);
+			out = baos.toByteArray();
+		} catch (IOException e) {
+			e.printStackTrace();
+		} finally {
+			try {
+				dos.close();
+				baos.close();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+		return out;
+	}
+
+	public static Bucket[] toBucketArray(byte[] in) {
+		ByteArrayInputStream bais = new ByteArrayInputStream(in);
+		DataInputStream dis = new DataInputStream(bais);
+		Bucket[] out = null;
+		try {
+			int d = dis.readInt();
+			int sw = dis.readInt();
+			int w = dis.readInt();
+			int bytes = dis.readInt();
+			byte[] b = new byte[bytes];
+			dis.read(b);
+			Tuple[] tuples = toTupleArray(b);
+			out = Bucket.tuplesToBuckets(tuples, d, sw, w);
+		} catch (IOException e) {
+			e.printStackTrace();
+		} finally {
+			try {
+				dis.close();
+				bais.close();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+		return out;
+	}
+
+	public static byte[] serialize(ArrayList<byte[]> in) {
+		ByteArrayOutputStream baos = new ByteArrayOutputStream();
+		DataOutputStream dos = new DataOutputStream(baos);
+		byte[] out = null;
+		try {
+			dos.writeInt(in.size());
+			dos.writeInt(in.get(0).length);
+			for (int i = 0; i < in.size(); i++)
+				dos.write(in.get(i));
+			out = baos.toByteArray();
+		} catch (IOException e) {
+			e.printStackTrace();
+		} finally {
+			try {
+				dos.close();
+				baos.close();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+		return out;
+	}
+
+	public static ArrayList<byte[]> toArrayList(byte[] in) {
+		ByteArrayInputStream bais = new ByteArrayInputStream(in);
+		DataInputStream dis = new DataInputStream(bais);
+		ArrayList<byte[]> out = null;
+		try {
+			int len = dis.readInt();
+			int bytes = dis.readInt();
+			out = new ArrayList<byte[]>(len);
+			for (int i = 0; i < len; i++) {
+				byte[] b = new byte[bytes];
+				dis.read(b);
+				out.add(b);
+			}
+		} catch (IOException e) {
+			e.printStackTrace();
+		} finally {
+			try {
+				dis.close();
+				bais.close();
+			} catch (IOException e) {
+				e.printStackTrace();
 			}
 		}
 		return out;

src/communication/Communication.java

@@ -3,7 +3,6 @@ package communication;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
-import java.io.Serializable;
 import java.io.StreamCorruptedException;
 import java.math.BigInteger;
 import java.net.InetSocketAddress;
@@ -15,8 +14,10 @@ import java.util.ArrayList;
 import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.LinkedBlockingQueue;
 
-import org.apache.commons.lang3.SerializationUtils;
+import com.oblivm.backend.gc.GCSignal;
 
+import oram.Bucket;
+import oram.Tuple;
 import util.Bandwidth;
 import util.P;
 import util.Util;
@@ -345,13 +346,13 @@ public class Communication {
 		write(out);
 	}
 
-	public <T> void write(T out) {
+	/*
-		write(SerializationUtils.serialize((Serializable) out));
+	 * public <T> void write(T out) {
-	}
+	 * write(SerializationUtils.serialize((Serializable) out)); }
-
+	 * 
-	public <T> void write(int pid, T out) {
+	 * public <T> void write(int pid, T out) { write(pid,
-		write(pid, SerializationUtils.serialize((Serializable) out));
+	 * SerializationUtils.serialize((Serializable) out)); }
-	}
+	 */
 
 	public void write(BigInteger b) {
 		write(b.toByteArray());
@@ -377,85 +378,117 @@ public class Communication {
 		write(pid, BigInteger.valueOf(n));
 	}
 
-	/*
+	public void write(byte[][] arr) {
-	 * public void write(byte[][] arr) { write(arr.length);
+		write(ComUtil.serialize(arr));
-	 * write(ComUtil.toByteArray(arr)); }
+	}
-	 * 
+
-	 * public void write(int pid, byte[][] arr) { write(pid, arr.length);
+	public void write(int pid, byte[][] arr) {
-	 * write(pid, ComUtil.toByteArray(arr)); }
+		write(pid, ComUtil.serialize(arr));
-	 * 
+	}
-	 * public void write(byte[][][] arr) { write(arr.length);
+
-	 * write(arr[0].length); write(ComUtil.toByteArray(arr)); }
+	public void write(byte[][][] arr) {
-	 * 
+		write(ComUtil.serialize(arr));
-	 * public void write(int pid, byte[][][] arr) { write(pid, arr.length);
+	}
-	 * write(pid, arr[0].length); write(pid, ComUtil.toByteArray(arr)); }
+
-	 * 
+	public void write(int pid, byte[][][] arr) {
-	 * public void write(int[] arr) { write(ComUtil.toByteArray(arr)); }
+		write(pid, ComUtil.serialize(arr));
-	 * 
+	}
-	 * public void write(int pid, int[] arr) { write(pid,
+
-	 * ComUtil.toByteArray(arr)); }
+	public void write(int[] arr) {
-	 * 
+		write(ComUtil.serialize(arr));
-	 * public void write(int[][] arr) { write(arr.length);
+	}
-	 * write(ComUtil.toByteArray(arr)); }
+
-	 * 
+	public void write(int pid, int[] arr) {
-	 * public void write(int pid, int[][] arr) { write(pid, arr.length);
+		write(pid, ComUtil.serialize(arr));
-	 * write(pid, ComUtil.toByteArray(arr)); }
+	}
-	 * 
+
-	 * public void write(Tuple t) { write(t.getF().length);
+	public void write(int[][] arr) {
-	 * write(t.getN().length); write(t.getL().length); write(t.toByteArray()); }
+		write(ComUtil.serialize(arr));
-	 * 
+	}
-	 * public void write(int pid, Tuple t) { write(pid, t.getF().length);
+
-	 * write(pid, t.getN().length); write(pid, t.getL().length); write(pid,
+	public void write(int pid, int[][] arr) {
-	 * t.toByteArray()); }
+		write(pid, ComUtil.serialize(arr));
-	 * 
+	}
-	 * public void write(Tuple[] arr) { write(arr.length);
+
-	 * write(arr[0].getF().length); write(arr[0].getN().length);
+	public void write(Tuple t) {
-	 * write(arr[0].getL().length); write(ComUtil.toByteArray(arr)); }
+		write(ComUtil.serialize(t));
-	 * 
+	}
-	 * public void write(int pid, Tuple[] arr) { write(pid, arr.length);
+
-	 * write(pid, arr[0].getF().length); write(pid, arr[0].getN().length);
+	public void write(int pid, Tuple t) {
-	 * write(pid, arr[0].getL().length); write(pid, ComUtil.toByteArray(arr)); }
+		write(pid, ComUtil.serialize(t));
-	 * 
+	}
-	 * public void write(Bucket b) { write(b.getTuples()); }
+
-	 * 
+	public void write(Tuple[] arr) {
-	 * public void write(int pid, Bucket b) { write(pid, b.getTuples()); }
+		write(ComUtil.serialize(arr));
-	 * 
+	}
-	 * public void write(Bucket[] arr) { write(arr.length);
+
-	 * write(arr[0].getNumTuples()); write(Bucket.bucketsToTuples(arr)); }
+	public void write(int pid, Tuple[] arr) {
-	 * 
+		write(pid, ComUtil.serialize(arr));
-	 * public void write(int pid, Bucket[] arr) { write(pid, arr.length);
+	}
-	 * write(pid, arr[0].getNumTuples()); write(pid,
+
-	 * Bucket.bucketsToTuples(arr)); }
+	public void write(Bucket b) {
-	 * 
+		write(b.getTuples());
-	 * public void write(GCSignal key) { write(key.bytes); }
+	}
-	 * 
+
-	 * public void write(int pid, GCSignal key) { write(pid, key.bytes); }
+	public void write(int pid, Bucket b) {
-	 * 
+		write(pid, b.getTuples());
-	 * public void write(GCSignal[] arr) { write(ComUtil.toByteArray(arr)); }
+	}
-	 * 
+
-	 * public void write(int pid, GCSignal[] arr) { write(pid,
+	public void write(Bucket[] arr) {
-	 * ComUtil.toByteArray(arr)); }
+		write(ComUtil.serialize(arr));
-	 * 
+	}
-	 * public void write(GCSignal[][] arr) { write(arr.length);
+
-	 * write(ComUtil.toByteArray(arr)); }
+	public void write(int pid, Bucket[] arr) {
-	 * 
+		write(ComUtil.serialize(arr));
-	 * public void write(int pid, GCSignal[][] arr) { write(pid, arr.length);
+	}
-	 * write(pid, ComUtil.toByteArray(arr)); }
+
-	 * 
+	public void write(GCSignal key) {
-	 * public void write(GCSignal[][][] arr) { write(arr.length);
+		write(key.bytes);
-	 * write(arr[0].length); write(ComUtil.toByteArray(arr)); }
+	}
-	 * 
+
-	 * public void write(int pid, GCSignal[][][] arr) { write(pid, arr.length);
+	public void write(int pid, GCSignal key) {
-	 * write(pid, arr[0].length); write(pid, ComUtil.toByteArray(arr)); }
+		write(pid, key.bytes);
-	 * 
+	}
-	 * public void write(GCSignal[][][][] arr) { write(arr.length);
+
-	 * write(arr[0].length); write(arr[0][0].length);
+	public void write(GCSignal[] arr) {
-	 * write(ComUtil.toByteArray(arr)); }
+		write(ComUtil.serialize(arr));
-	 * 
+	}
-	 * public void write(int pid, GCSignal[][][][] arr) { write(pid,
+
-	 * arr.length); write(pid, arr[0].length); write(pid, arr[0][0].length);
+	public void write(int pid, GCSignal[] arr) {
-	 * write(pid, ComUtil.toByteArray(arr)); }
+		write(pid, ComUtil.serialize(arr));
-	 */
+	}
+
+	public void write(GCSignal[][] arr) {
+		write(ComUtil.serialize(arr));
+	}
+
+	public void write(int pid, GCSignal[][] arr) {
+		write(pid, ComUtil.serialize(arr));
+	}
+
+	public void write(GCSignal[][][] arr) {
+		write(ComUtil.serialize(arr));
+	}
+
+	public void write(int pid, GCSignal[][][] arr) {
+		write(pid, ComUtil.serialize(arr));
+	}
+
+	public void write(GCSignal[][][][] arr) {
+		write(ComUtil.serialize(arr));
+	}
+
+	public void write(int pid, GCSignal[][][][] arr) {
+		write(pid, ComUtil.serialize(arr));
+	}
+
+	public void write(ArrayList<byte[]> arr) {
+		write(ComUtil.serialize(arr));
+	}
+
+	public void write(int pid, ArrayList<byte[]> arr) {
+		write(pid, ComUtil.serialize(arr));
+	}
 
 	public static final Charset defaultCharset = Charset.forName("ASCII");
 
@@ -537,10 +570,10 @@ public class Communication {
 		return total;
 	}
 
-	public <T> T readObject() {
+	/*
-		T object = SerializationUtils.deserialize(read());
+	 * public <T> T readObject() { T object =
-		return object;
+	 * SerializationUtils.deserialize(read()); return object; }
-	}
+	 */
 
 	public BigInteger readBigInteger() {
 		return new BigInteger(read());
@@ -554,56 +587,61 @@ public class Communication {
 		return readBigInteger().longValue();
 	}
 
-	/*
+	public byte[][] readDoubleByteArray() {
-	 * public byte[][] readDoubleByteArray() { int len = readInt(); return
+		return ComUtil.toDoubleByteArray(read());
-	 * ComUtil.toDoubleByteArray(read(), len); }
+	}
-	 * 
+
-	 * public byte[][][] readTripleByteArray() { int len1 = readInt(); int len2
+	public byte[][][] readTripleByteArray() {
-	 * = readInt(); return ComUtil.toTripleByteArray(read(), len1, len2); }
+		return ComUtil.toTripleByteArray(read());
-	 * 
+	}
-	 * public int[] readIntArray() { return ComUtil.toIntArray(read()); }
+
-	 * 
+	public int[] readIntArray() {
-	 * public int[][] readDoubleIntArray() { int len = readInt(); return
+		return ComUtil.toIntArray(read());
-	 * ComUtil.toDoubleIntArray(read(), len); }
+	}
-	 * 
+
-	 * public Tuple readTuple() { int f = readInt(); int n = readInt(); int l =
+	public int[][] readDoubleIntArray() {
-	 * readInt(); int endN = f + n; int endL = endN + l; byte[] b = read();
+		return ComUtil.toDoubleIntArray(read());
-	 * byte[] F = Arrays.copyOfRange(b, 0, f); byte[] N = Arrays.copyOfRange(b,
+	}
-	 * f, endN); byte[] L = Arrays.copyOfRange(b, endN, endL); byte[] A =
+
-	 * Arrays.copyOfRange(b, endL, b.length); return new Tuple(F, N, L, A); }
+	public Tuple readTuple() {
-	 * 
+		return ComUtil.toTuple(read());
-	 * public Tuple[] readTupleArray() { int len1 = readInt(); int f =
+	}
-	 * readInt(); int n = readInt(); int l = readInt(); byte[] b = read(); int
+
-	 * len2 = b.length / len1; int endN = f + n; int endL = endN + l; Tuple[]
+	public Tuple[] readTupleArray() {
-	 * arr = new Tuple[len1]; for (int i = 0; i < len1; i++) { byte[] F =
+		return ComUtil.toTupleArray(read());
-	 * Arrays.copyOfRange(b, i * len2, i * len2 + f); byte[] N =
+	}
-	 * Arrays.copyOfRange(b, i * len2 + f, i * len2 + endN); byte[] L =
+
-	 * Arrays.copyOfRange(b, i * len2 + endN, i * len2 + endL); byte[] A =
+	public Bucket readBucket() {
-	 * Arrays.copyOfRange(b, i * len2 + endL, (i + 1) * len2); arr[i] = new
+		return new Bucket(readTupleArray());
-	 * Tuple(F, N, L, A); } return arr; }
+	}
-	 * 
+
-	 * public Bucket readBucket() { return new Bucket(readTupleArray()); }
+	public Bucket[] readBucketArray() {
-	 * 
+		return ComUtil.toBucketArray(read());
-	 * public Bucket[] readBucketArray() { int d = readInt(); int sw =
+	}
-	 * readInt(); Tuple[] arr = readTupleArray(); int w = (arr.length - sw) / (d
+
-	 * - 1); return Bucket.tuplesToBuckets(arr, d, sw, w); }
+	public GCSignal readGCSignal() {
-	 * 
+		return new GCSignal(read());
-	 * public GCSignal readGCSignal() { return new GCSignal(read()); }
+	}
-	 * 
+
-	 * public GCSignal[] readGCSignalArray() { return
+	public GCSignal[] readGCSignalArray() {
-	 * ComUtil.toGCSignalArray(read()); }
+		return ComUtil.toGCSignalArray(read());
-	 * 
+	}
-	 * public GCSignal[][] readDoubleGCSignalArray() { int len = readInt();
+
-	 * return ComUtil.toDoubleGCSignalArray(read(), len); }
+	public GCSignal[][] readDoubleGCSignalArray() {
-	 * 
+		return ComUtil.toDoubleGCSignalArray(read());
-	 * public GCSignal[][][] readTripleGCSignalArray() { int len1 = readInt();
+	}
-	 * int len2 = readInt(); return ComUtil.toTripleGCSignalArray(read(), len1,
+
-	 * len2); }
+	public GCSignal[][][] readTripleGCSignalArray() {
-	 * 
+		return ComUtil.toTripleGCSignalArray(read());
-	 * public GCSignal[][][][] readQuadGCSignalArray() { int len1 = readInt();
+	}
-	 * int len2 = readInt(); int len3 = readInt(); return
+
-	 * ComUtil.toQuadGCSignalArray(read(), len1, len2, len3); }
+	public GCSignal[][][][] readQuadGCSignalArray() {
-	 */
+		return ComUtil.toQuadGCSignalArray(read());
+	}
+
+	public ArrayList<byte[]> readArrayList() {
+		return ComUtil.toArrayList(read());
+	}
 
 	/**
 	 * This thread runs while listening for incoming connections. It behaves

src/protocols/Access.java

@@ -158,7 +158,7 @@ public class Access extends Protocol {
 
 		// step 2
 		timer.start(pid, M.online_read);
-		Tuple[] pathTuples = con2.readObject();
+		Tuple[] pathTuples = con2.readTupleArray();
 		byte[] Ni = con2.read();
 		timer.stop(pid, M.online_read);
 
@@ -272,7 +272,7 @@ public class Access extends Protocol {
 
 		// step 2
 		timer.start(pid, M.online_read);
-		Tuple[] pathTuples = con2.readObject();
+		Tuple[] pathTuples = con2.readTupleArray();
 		timer.stop(pid, M.online_read);
 
 		// step 5
@@ -309,7 +309,7 @@ public class Access extends Protocol {
 		System.out.println();
 
 		for (int i = 0; i < records; i++) {
-			long N = Util.nextLong(numInsert, Crypto.sr);
+			long N = Metadata.cheat ? 0 : Util.nextLong(numInsert, Crypto.sr);
 
 			for (int j = 0; j < repeat; j++) {
 				System.out.println("Test: " + i + " " + j);

src/protocols/Eviction.java

@@ -124,7 +124,7 @@ public class Eviction extends Protocol {
 
 		if (firstTree) {
 			timer.start(pid, M.online_read);
-			Tuple[] originalPath = con2.readObject();
+			Tuple[] originalPath = con2.readTupleArray();
 			timer.stop(pid, M.online_read);
 
 			OTi.setBucketsOnPath(new BigInteger(1, Li).longValue(), new Bucket[] { new Bucket(originalPath) });
@@ -134,13 +134,13 @@ public class Eviction extends Protocol {
 		}
 
 		timer.start(pid, M.online_read);
-		GCSignal[] LiInputKeys = con1.readObject();
+		GCSignal[] LiInputKeys = con1.readGCSignalArray();
-		GCSignal[][] E_feInputKeys = con1.readObject();
+		GCSignal[][] E_feInputKeys = con1.readDoubleGCSignalArray();
-		GCSignal[][][] E_labelInputKeys = con1.readObject();
+		GCSignal[][][] E_labelInputKeys = con1.readTripleGCSignalArray();
-		GCSignal[][] deltaInputKeys = con1.readObject();
+		GCSignal[][] deltaInputKeys = con1.readDoubleGCSignalArray();
 
-		GCSignal[][] C_feInputKeys = con2.readObject();
+		GCSignal[][] C_feInputKeys = con2.readDoubleGCSignalArray();
-		GCSignal[][][] C_labelInputKeys = con2.readObject();
+		GCSignal[][][] C_labelInputKeys = con2.readTripleGCSignalArray();
 		timer.stop(pid, M.online_read);
 
 		int w = OTi.getW();
@@ -168,7 +168,7 @@ public class Eviction extends Protocol {
 		ssxot.runD(predata, evict, timer);
 
 		timer.start(pid, M.online_read);
-		Bucket[] pathBuckets = con2.readObject();
+		Bucket[] pathBuckets = con2.readBucketArray();
 		timer.stop(pid, M.online_read);
 
 		OTi.setBucketsOnPath(new BigInteger(1, Li).longValue(), pathBuckets);

src/protocols/PermuteIndex.java

@@ -39,7 +39,7 @@ public class PermuteIndex extends Protocol {
 		timer.stop(pid, M.online_write);
 
 		timer.start(pid, M.online_read);
-		byte[][] g = con2.readObject();
+		byte[][] g = con2.readDoubleByteArray();
 		timer.stop(pid, M.online_read);
 
 		ti = Util.xor(predata.pi_a, g);
@@ -60,7 +60,7 @@ public class PermuteIndex extends Protocol {
 		timer.start(pid, M.online_comp);
 
 		timer.start(pid, M.online_read);
-		byte[][] z = con2.readObject();
+		byte[][] z = con2.readDoubleByteArray();
 		timer.stop(pid, M.online_read);
 
 		z = Util.xor(z, predata.pi_r);
@@ -111,7 +111,7 @@ public class PermuteIndex extends Protocol {
 
 				runE();
 
-				int[] ti_pp = con1.readObject();
+				int[] ti_pp = con1.readIntArray();
 				ti = Util.permute(ti, predata.evict_pi);
 				int j = 0;
 				for (; j < d; j++) {
@@ -126,9 +126,9 @@ public class PermuteIndex extends Protocol {
 					System.out.println("PermuteIndex test passed");
 
 			} else if (party == Party.Debbie) {
-				predata.evict_pi = con1.readObject();
+				predata.evict_pi = con1.readIntArray();
-				predata.evict_rho = con1.readObject();
+				predata.evict_rho = con1.readDoubleByteArray();
-				byte[][] ti = con1.readObject();
+				byte[][] ti = con1.readDoubleByteArray();
 				int w = con1.readInt();
 
 				prepermuteindex.runD(predata, timer);
@@ -137,8 +137,8 @@ public class PermuteIndex extends Protocol {
 				con1.write(ti_pp);
 
 			} else if (party == Party.Charlie) {
-				predata.evict_pi = con1.readObject();
+				predata.evict_pi = con1.readIntArray();
-				predata.evict_rho = con1.readObject();
+				predata.evict_rho = con1.readDoubleByteArray();
 
 				prepermuteindex.runC(predata, timer);
 

src/protocols/PermuteTarget.java

@@ -61,7 +61,7 @@ public class PermuteTarget extends Protocol {
 		timer.stop(pid, M.online_write);
 
 		timer.start(pid, M.online_read);
-		byte[][] g = con2.readObject();
+		byte[][] g = con2.readDoubleByteArray();
 		timer.stop(pid, M.online_read);
 
 		target = Util.xor(predata.pt_a, g);
@@ -82,8 +82,8 @@ public class PermuteTarget extends Protocol {
 
 		// PermuteTargetII
 		timer.start(pid, M.online_read);
-		byte[][] z = con2.readObject();
+		byte[][] z = con2.readDoubleByteArray();
-		int[] I = con2.readObject();
+		int[] I = con2.readIntArray();
 		timer.stop(pid, M.online_read);
 
 		byte[][] mk = new byte[z.length][];
@@ -137,7 +137,7 @@ public class PermuteTarget extends Protocol {
 
 				runE();
 
-				int[] target_pp = con1.readObject();
+				int[] target_pp = con1.readIntArray();
 				int[] pi_ivs = Util.inversePermutation(predata.evict_pi);
 				int[] piTargetPiIvs = new int[d];
 
@@ -154,9 +154,9 @@ public class PermuteTarget extends Protocol {
 
 			} else if (party == Party.Debbie) {
 				int d = con1.readInt();
-				predata.evict_pi = con1.readObject();
+				predata.evict_pi = con1.readIntArray();
-				predata.evict_targetOutKeyPairs = con1.readObject();
+				predata.evict_targetOutKeyPairs = con1.readTripleGCSignalArray();
-				GCSignal[][] targetOutKeys = con1.readObject();
+				GCSignal[][] targetOutKeys = con1.readDoubleGCSignalArray();
 
 				prepermutetarget.runD(predata, d, timer);
 
@@ -164,7 +164,7 @@ public class PermuteTarget extends Protocol {
 				con1.write(target_pp);
 
 			} else if (party == Party.Charlie) {
-				predata.evict_pi = con1.readObject();
+				predata.evict_pi = con1.readIntArray();
 
 				prepermutetarget.runC(predata, timer);
 

src/protocols/PostProcessT.java

@@ -118,7 +118,7 @@ public class PostProcessT extends Protocol {
 		System.out.println();
 
 		for (int i = 0; i < records; i++) {
-			long N = Util.nextLong(numInsert, Crypto.sr);
+			long N = Metadata.cheat ? 0 : Util.nextLong(numInsert, Crypto.sr);
 
 			for (int j = 0; j < repeat; j++) {
 				System.out.println("Test: " + i + " " + j);
@@ -163,11 +163,11 @@ public class PostProcessT extends Protocol {
 						prepostprocesst.runE(predata, timer);
 						Tuple Ti_prime = runE(predata, outaccess.E_Ti, ti == numTrees - 1, timer);
 
-						Ti_prime.setXor(con2.readObject());
+						Ti_prime.setXor(con2.readTuple());
 						byte[] Li_prime = Util.xor(predata.ppt_Li, con2.read());
 						byte[] Lip1_prime = Util.xor(predata.ppt_Lip1, con2.read());
 						int j2 = con2.readInt();
-						Tuple Ti = outaccess.E_Ti.xor(con2.readObject());
+						Tuple Ti = outaccess.E_Ti.xor(con2.readTuple());
 
 						if (!Util.equal(Ti.getF(), Ti_prime.getF()))
 							System.err.println("PPT test failed");

src/protocols/Reshuffle.java

@@ -36,7 +36,7 @@ public class Reshuffle extends Protocol {
 
 		// step 1
 		timer.start(pid, M.online_read);
-		Tuple[] z = con2.readObject();
+		Tuple[] z = con2.readTupleArray();
 		timer.stop(pid, M.online_read);
 
 		// step 2
@@ -89,7 +89,7 @@ public class Reshuffle extends Protocol {
 		System.out.println();
 
 		for (int i = 0; i < records; i++) {
-			long N = Util.nextLong(numInsert, Crypto.sr);
+			long N = Metadata.cheat ? 0 : Util.nextLong(numInsert, Crypto.sr);
 
 			for (int j = 0; j < repeat; j++) {
 				System.out.println("Test: " + i + " " + j);
@@ -132,8 +132,8 @@ public class Reshuffle extends Protocol {
 						prereshuffle.runE(predata, timer);
 						Tuple[] E_P_prime = runE(predata, outaccess.E_P, ti == 0, timer);
 
-						Tuple[] C_P = con2.readObject();
+						Tuple[] C_P = con2.readTupleArray();
-						Tuple[] C_P_prime = con2.readObject();
+						Tuple[] C_P_prime = con2.readTupleArray();
 						Tuple[] oldPath = new Tuple[C_P.length];
 						Tuple[] newPath = new Tuple[C_P.length];
 

src/protocols/SSCOT.java

@@ -81,12 +81,12 @@ public class SSCOT extends Protocol {
 
 		// step 1
 		timer.start(pid, M.online_read);
-		byte[][] e = con1.readObject();
+		byte[][] e = con1.readDoubleByteArray();
-		byte[][] v = con1.readObject();
+		byte[][] v = con1.readDoubleByteArray();
 
 		// step 2
-		byte[][] p = con2.readObject();
+		byte[][] p = con2.readDoubleByteArray();
-		byte[][] w = con2.readObject();
+		byte[][] w = con2.readDoubleByteArray();
 		timer.stop(pid, M.online_read);
 
 		// step 3
@@ -143,12 +143,12 @@ public class SSCOT extends Protocol {
 				runE(predata, m, a, timer);
 
 			} else if (party == Party.Debbie) {
-				b = con1.readObject();
+				b = con1.readDoubleByteArray();
 				presscot.runD(predata, timer);
 				runD(predata, b, timer);
 
 			} else if (party == Party.Charlie) {
-				m = con1.readObject();
+				m = con1.readDoubleByteArray();
 				index = con1.readInt();
 				presscot.runC();
 				OutSSCOT output = runC(timer);

src/protocols/SSIOT.java

@@ -76,8 +76,8 @@ public class SSIOT extends Protocol {
 
 		// step 1
 		timer.start(pid, M.online_read);
-		byte[][] e = con1.readObject();
+		byte[][] e = con1.readDoubleByteArray();
-		byte[][] v = con1.readObject();
+		byte[][] v = con1.readDoubleByteArray();
 
 		// step 2
 		byte[] p = con2.read();
@@ -139,7 +139,7 @@ public class SSIOT extends Protocol {
 				runD(predata, sD_Nip1_pr, timer);
 
 			} else if (party == Party.Charlie) {
-				y = con1.readObject();
+				y = con1.readDoubleByteArray();
 				index = con1.readInt();
 				pressiot.runC();
 				OutSSIOT output = runC(timer);

src/protocols/SSXOT.java

@@ -45,11 +45,11 @@ public class SSXOT extends Protocol {
 		timer.stop(pid, M.online_write);
 
 		timer.start(pid, M.online_read);
-		a = con2.readObject();
+		a = con2.readTupleArray();
 
 		// step 2
-		int[] j = con1.readObject();
+		int[] j = con1.readIntArray();
-		Tuple[] p = con1.readObject();
+		Tuple[] p = con1.readTupleArray();
 		timer.stop(pid, M.online_read);
 
 		// step 3
@@ -100,11 +100,11 @@ public class SSXOT extends Protocol {
 		timer.stop(pid, M.online_write);
 
 		timer.start(pid, M.online_read);
-		a = con1.readObject();
+		a = con1.readTupleArray();
 
 		// step 2
-		int[] j = con2.readObject();
+		int[] j = con2.readIntArray();
-		Tuple[] p = con2.readObject();
+		Tuple[] p = con2.readTupleArray();
 		timer.stop(pid, M.online_read);
 
 		// step 3
@@ -153,9 +153,9 @@ public class SSXOT extends Protocol {
 				pressxot.runC(predata, timer);
 				Tuple[] C_out_m = runC(predata, C_m, timer);
 
-				index = con2.readObject();
+				index = con2.readIntArray();
-				E_m = con1.readObject();
+				E_m = con1.readTupleArray();
-				Tuple[] E_out_m = con1.readObject();
+				Tuple[] E_out_m = con1.readTupleArray();
 
 				boolean pass = true;
 				for (int i = 0; i < index.length; i++) {

src/protocols/UpdateRoot.java

@@ -66,12 +66,12 @@ public class UpdateRoot extends Protocol {
 
 		// step 1
 		timer.start(pid, M.online_read);
-		GCSignal[] j1InputKeys = con1.readObject();
+		GCSignal[] j1InputKeys = con1.readGCSignalArray();
-		GCSignal[] LiInputKeys = con1.readObject();
+		GCSignal[] LiInputKeys = con1.readGCSignalArray();
-		GCSignal[] E_feInputKeys = con1.readObject();
+		GCSignal[] E_feInputKeys = con1.readGCSignalArray();
-		GCSignal[][] E_labelInputKeys = con1.readObject();
+		GCSignal[][] E_labelInputKeys = con1.readDoubleGCSignalArray();
-		GCSignal[] C_feInputKeys = con2.readObject();
+		GCSignal[] C_feInputKeys = con2.readGCSignalArray();
-		GCSignal[][] C_labelInputKeys = con2.readObject();
+		GCSignal[][] C_labelInputKeys = con2.readDoubleGCSignalArray();
 		timer.stop(pid, M.online_read);
 
 		// step 2
@@ -151,7 +151,7 @@ public class UpdateRoot extends Protocol {
 				preupdateroot.runE(predata, false, sw, lBits, timer);
 				Tuple[] newR = runE(predata, false, Li, R, Ti, timer);
 
-				Tuple[] R_C = con2.readObject();
+				Tuple[] R_C = con2.readTupleArray();
 				int cnt = 0;
 				int[] index = new int[3];
 				for (int j = 0; j < sw; j++) {

src/protocols/precomputation/PreAccess.java

@@ -59,8 +59,8 @@ public class PreAccess extends Protocol {
 
 		// Access
 		timer.start(pid, M.offline_read);
-		predata.access_sigma = con1.readObject();
+		predata.access_sigma = con1.readIntArray();
-		predata.access_p = con1.readObject();
+		predata.access_p = con1.readTupleArray();
 		timer.stop(pid, M.offline_read);
 
 		timer.stop(pid, M.offline_comp);

src/protocols/precomputation/PreEviction.java

@@ -164,8 +164,8 @@ public class PreEviction extends Protocol {
 		eva.setEvaluate();
 
 		timer.start(pid, M.offline_read);
-		predata.evict_tiOutKeyHashes = con1.readObject();
+		predata.evict_tiOutKeyHashes = con1.readTripleByteArray();
-		predata.evict_targetOutKeyPairs = con1.readObject();
+		predata.evict_targetOutKeyPairs = con1.readTripleGCSignalArray();
 		timer.stop(pid, M.offline_read);
 
 		// PermuteTarget
@@ -193,15 +193,15 @@ public class PreEviction extends Protocol {
 
 		// GC
 		timer.start(pid, M.offline_read);
-		predata.evict_C_feKeyPairs = con1.readObject();
+		predata.evict_C_feKeyPairs = con1.readTripleGCSignalArray();
-		predata.evict_C_labelKeyPairs = con1.readObject();
+		predata.evict_C_labelKeyPairs = con1.readQuadGCSignalArray();
 
 		// Permutation
-		predata.evict_pi = con1.readObject();
+		predata.evict_pi = con1.readIntArray();
-		predata.evict_delta = con1.readObject();
+		predata.evict_delta = con1.readDoubleByteArray();
-		predata.evict_rho = con1.readObject();
+		predata.evict_rho = con1.readDoubleByteArray();
-		predata.evict_delta_p = con1.readObject();
+		predata.evict_delta_p = con1.readDoubleIntArray();
-		predata.evict_rho_p = con1.readObject();
+		predata.evict_rho_p = con1.readDoubleIntArray();
 		timer.stop(pid, M.offline_read);
 
 		// PermuteTarget

src/protocols/precomputation/PrePermuteIndex.java

@@ -46,14 +46,14 @@ public class PrePermuteIndex extends Protocol {
 
 	public void runD(PreData predata, Timer timer) {
 		timer.start(pid, M.offline_read);
-		predata.pi_p = con1.readObject();
+		predata.pi_p = con1.readDoubleByteArray();
-		predata.pi_a = con1.readObject();
+		predata.pi_a = con1.readDoubleByteArray();
 		timer.stop(pid, M.offline_read);
 	}
 
 	public void runC(PreData predata, Timer timer) {
 		timer.start(pid, M.offline_read);
-		predata.pi_r = con1.readObject();
+		predata.pi_r = con1.readDoubleByteArray();
 		timer.stop(pid, M.offline_read);
 	}
 

src/protocols/precomputation/PrePermuteTarget.java

@@ -83,22 +83,22 @@ public class PrePermuteTarget extends Protocol {
 	public void runD(PreData predata, int d, Timer timer) {
 		timer.start(pid, M.offline_read);
 		// PermuteTargetI
-		predata.pt_keyT = con1.readObject();
+		predata.pt_keyT = con1.readTripleByteArray();
-		predata.pt_targetT = con1.readObject();
+		predata.pt_targetT = con1.readTripleByteArray();
 
 		// PermuteTargetII
-		predata.pt_p = con1.readObject();
+		predata.pt_p = con1.readDoubleByteArray();
-		predata.pt_a = con1.readObject();
+		predata.pt_a = con1.readDoubleByteArray();
 		timer.stop(pid, M.offline_read);
 	}
 
 	public void runC(PreData predata, Timer timer) {
 		timer.start(pid, M.offline_read);
 		// PermuteTargetI
-		predata.pt_maskT = con1.readObject();
+		predata.pt_maskT = con1.readTripleByteArray();
 
 		// PermuteTargetII
-		predata.pt_r = con1.readObject();
+		predata.pt_r = con1.readDoubleByteArray();
 		timer.stop(pid, M.offline_read);
 	}
 

src/protocols/precomputation/PrePostProcessT.java

@@ -25,7 +25,7 @@ public class PrePostProcessT extends Protocol {
 		predata.ppt_Li = con1.read();
 		predata.ppt_Lip1 = con1.read();
 
-		predata.ppt_s = con1.readObject();
+		predata.ppt_s = con1.readDoubleByteArray();
 		timer.stop(pid, M.offline_read);
 	}
 
@@ -71,7 +71,7 @@ public class PrePostProcessT extends Protocol {
 
 		timer.start(pid, M.offline_read);
 		predata.ppt_alpha = con2.readInt();
-		predata.ppt_r = con2.readObject();
+		predata.ppt_r = con2.readDoubleByteArray();
 		timer.stop(pid, M.offline_read);
 
 		timer.stop(pid, M.offline_comp);

src/protocols/precomputation/PreReshuffle.java

@@ -27,7 +27,7 @@ public class PreReshuffle extends Protocol {
 		predata.reshuffle_pi = Util.inversePermutation(predata.access_sigma);
 
 		timer.start(pid, M.offline_read);
-		predata.reshuffle_r = con1.readObject();
+		predata.reshuffle_r = con1.readTupleArray();
 		timer.stop(pid, M.offline_read);
 
 		timer.stop(pid, M.offline_comp);
@@ -59,8 +59,8 @@ public class PreReshuffle extends Protocol {
 
 	public void runC(PreData predata, Timer timer) {
 		timer.start(pid, M.offline_read);
-		predata.reshuffle_p = con2.readObject();
+		predata.reshuffle_p = con2.readTupleArray();
-		predata.reshuffle_a_prime = con2.readObject();
+		predata.reshuffle_a_prime = con2.readTupleArray();
 		timer.stop(pid, M.offline_read);
 	}
 

src/protocols/precomputation/PreSSCOT.java

@@ -51,7 +51,7 @@ public class PreSSCOT extends Protocol {
 		timer.start(pid, M.offline_read);
 		predata.sscot_k = con1.read();
 		predata.sscot_kprime = con1.read();
-		predata.sscot_r = con1.readObject();
+		predata.sscot_r = con1.readDoubleByteArray();
 		timer.stop(pid, M.offline_read);
 
 		predata.sscot_F_k = new PRF(Crypto.secParam);

src/protocols/precomputation/PreSSXOT.java

@@ -26,8 +26,8 @@ public class PreSSXOT extends Protocol {
 
 	public void runE(PreData predata, Timer timer) {
 		timer.start(pid, M.offline_read);
-		predata.ssxot_E_pi[id] = con1.readObject();
+		predata.ssxot_E_pi[id] = con1.readIntArray();
-		predata.ssxot_E_r[id] = con1.readObject();
+		predata.ssxot_E_r[id] = con1.readTupleArray();
 		timer.stop(pid, M.offline_read);
 	}
 
@@ -63,8 +63,8 @@ public class PreSSXOT extends Protocol {
 
 	public void runC(PreData predata, Timer timer) {
 		timer.start(pid, M.offline_read);
-		predata.ssxot_C_pi[id] = con2.readObject();
+		predata.ssxot_C_pi[id] = con2.readIntArray();
-		predata.ssxot_C_r[id] = con2.readObject();
+		predata.ssxot_C_r[id] = con2.readTupleArray();
 		timer.stop(pid, M.offline_read);
 	}
 

src/protocols/precomputation/PreUpdateRoot.java

@@ -101,7 +101,7 @@ public class PreUpdateRoot extends Protocol {
 		eva.setEvaluate();
 
 		timer.start(pid, M.offline_read);
-		predata.ur_outKeyHashes = con1.readObject();
+		predata.ur_outKeyHashes = con1.readTripleByteArray();
 		timer.stop(pid, M.offline_read);
 
 		PreSSXOT pressxot = new PreSSXOT(con1, con2, 0);
@@ -118,8 +118,8 @@ public class PreUpdateRoot extends Protocol {
 		timer.start(pid, M.offline_comp);
 
 		timer.start(pid, M.offline_read);
-		predata.ur_C_feKeyPairs = con1.readObject();
+		predata.ur_C_feKeyPairs = con1.readDoubleGCSignalArray();
-		predata.ur_C_labelKeyPairs = con1.readObject();
+		predata.ur_C_labelKeyPairs = con1.readTripleGCSignalArray();
 		timer.stop(pid, M.offline_read);
 
 		PreSSXOT pressxot = new PreSSXOT(con1, con2, 0);