diff --git a/src/main/cpp/edu_stanford_ramcloud_JRamCloud.cc b/src/main/cpp/edu_stanford_ramcloud_JRamCloud.cc
index fe61007..4694c4e 100644
--- a/src/main/cpp/edu_stanford_ramcloud_JRamCloud.cc
+++ b/src/main/cpp/edu_stanford_ramcloud_JRamCloud.cc
@@ -340,12 +340,11 @@
 
     const static jmethodID methodId = env->GetMethodID(cls,
                                           "<init>",
-                                          "(L" PACKAGE_PATH "JRamCloud;[B[BJ)V");
+                                          "([B[BJ)V");
     check_null(methodId, "GetMethodID failed");
 
     return env->NewObject(cls,
                           methodId,
-                          jRamCloud,
                           jKey,
                           jValue,
                           static_cast<jlong>(version));
@@ -377,7 +376,7 @@
                                                         jobject jRamCloud,
 							jlongArray jTableId,
 							jobjectArray jKeyData,
-							jshortArray jKeyDataSize,
+							jshortArray jKeyLength,
 							jint jrequestNum){
 
     RamCloud* ramcloud = getRamCloud(env, jRamCloud);
@@ -386,22 +385,22 @@
     jbyteArray jKey[jrequestNum];
     MultiReadObject* requests[jrequestNum];
 
-    jlong TableId;
-    jshort KeyDataSize;
-    jbyte* data[jrequestNum];
+    jlong tableId;
+    jshort keyLength;
+    jbyte* keyData[jrequestNum];
 
     for (int i = 0 ; i < jrequestNum ; i++){
         jKey[i] = (jbyteArray)env->GetObjectArrayElement(jKeyData, i); 
 
-        env->GetShortArrayRegion(jKeyDataSize, i, 1, &KeyDataSize);
+        env->GetShortArrayRegion(jKeyLength, i, 1, &keyLength);
 
-        data[i] = (jbyte *) malloc(KeyDataSize);
-        env->GetByteArrayRegion(jKey[i], 0, KeyDataSize, data[i]);
+        keyData[i] = (jbyte *) malloc(keyLength);
+        env->GetByteArrayRegion(jKey[i], 0, keyLength, keyData[i]);
 
-        env->GetLongArrayRegion(jTableId, i, 1, &TableId);
-        objects[i].tableId = TableId;
-        objects[i].key = data[i];
-	objects[i].keyLength = KeyDataSize;
+        env->GetLongArrayRegion(jTableId, i, 1, &tableId);
+        objects[i].tableId = tableId;
+        objects[i].key = keyData[i];
+	objects[i].keyLength = keyLength;
         objects[i].value = &values[i];
         requests[i] = &objects[i];
     }
@@ -414,7 +413,7 @@
     check_null(jc_RcObject, "FindClass failed");
     const static jmethodID jm_init = env->GetMethodID(jc_RcObject,
                                         "<init>",
-                                        "(L" PACKAGE_PATH "JRamCloud;[B[BJ)V");
+                                        "([B[BJ)V");
 
     jobjectArray outJNIArray = env->NewObjectArray(jrequestNum, jc_RcObject , NULL);
     check_null(outJNIArray, "NewObjectArray failed");
@@ -425,11 +424,11 @@
 	    check_null(jValue, "NewByteArray failed");
 	    JByteArrayGetter value(env, jValue);
 	    values[i].get()->copy(0, values[i].get()->getTotalLength(), value.pointer);
-	    jobject obj = env->NewObject(jc_RcObject, jm_init, jRamCloud, jKey[i], jValue);
+	    jobject obj = env->NewObject(jc_RcObject, jm_init, jKey[i], jValue);
 	    check_null(obj, "NewObject failed");
 	    env->SetObjectArrayElement(outJNIArray, i, obj);
 	}
-	free(data[i]);
+	free(keyData[i]);
     }
     return outJNIArray;
 }
@@ -672,11 +671,10 @@
         check_null(cls, "FindClass failed");
         const static jmethodID methodId = env->GetMethodID(cls,
                                           "<init>",
-                                          "(L" PACKAGE_PATH "JRamCloud;[B[BJ)V");
+                                          "([B[BJ)V");
         check_null(methodId, "GetMethodID failed");
         return env->NewObject(cls,
                               methodId,
-                              jTableEnumerator,
                               jKey,
                               jValue,
                               static_cast<jlong>(version));        
@@ -686,24 +684,123 @@
 
 /*
  * Class:     edu_stanford_ramcloud_JRamCloud
+ * Method:    getTableObjects
+ * Signature: (JJ)Ledu/stanford/ramcloud/JRamCloud/TableEnumeratorObject;
+ */
+JNIEXPORT jobject JNICALL Java_edu_stanford_ramcloud_JRamCloud_getTableObjects(JNIEnv *env,
+                                                                               jobject jRamCloud,
+                                                                               jlong jTableId,
+                                                                               jlong jTabletNextHash){
+
+    RamCloud* ramcloud = getRamCloud(env, jRamCloud);
+
+    Buffer state;
+    Buffer objects;
+    bool done = false;
+    uint64_t version = 0;
+
+    uint32_t nextOffset = 0;
+
+    const static jclass jc_RcObject = (jclass)env->NewGlobalRef(env->FindClass(PACKAGE_PATH "JRamCloud$Object"));
+    check_null(jc_RcObject, "FindClass failed");
+    const static jmethodID jm_init = env->GetMethodID(jc_RcObject,
+                                        "<init>",
+                                        "([B[BJ)V");
+    check_null(jm_init, "GetMethodID failed");
+    
+    const static jclass jc_RcTableObject = (jclass)env->NewGlobalRef(env->FindClass(PACKAGE_PATH "JRamCloud$TableEnumeratorObject"));
+    check_null(jc_RcTableObject, "FindClass failed");
+    const static jmethodID jm_TableEnumeratorObject_init = env->GetMethodID(jc_RcTableObject,
+                                        "<init>",
+                                        "([Ledu/stanford/ramcloud/JRamCloud$Object;J)V");
+    check_null(jm_TableEnumeratorObject_init, "GetMethodID failed");
+
+    
+    while (true) {
+        jTabletNextHash = ramcloud->enumerateTable(jTableId, jTabletNextHash, state, objects);
+        if (objects.getTotalLength() > 0) {
+            break;
+        }
+        if (objects.getTotalLength() == 0 && jTabletNextHash == 0) {
+            done = true;
+            break;
+        }    
+    }
+    
+    if (done) {
+        return env->NewObject(jc_RcTableObject, jm_TableEnumeratorObject_init, env->NewObjectArray(0, jc_RcObject , NULL), 0);
+    }
+    
+    int numOfTable;
+    for (numOfTable = 0; nextOffset < objects.getTotalLength() ; numOfTable++) {
+        uint32_t objectSize = *objects.getOffset<uint32_t>(nextOffset);
+        nextOffset += downCast<uint32_t>(sizeof(uint32_t));
+        nextOffset += objectSize;
+    }
+    
+    jobjectArray outJNIArray = env->NewObjectArray(numOfTable, jc_RcObject , NULL);
+    check_null(outJNIArray, "NewObjectArray failed");
+
+    nextOffset = 0;
+    for (int i = 0; nextOffset < objects.getTotalLength() ;i++) {
+        uint32_t objectSize = *objects.getOffset<uint32_t>(nextOffset);
+        nextOffset += downCast<uint32_t>(sizeof(uint32_t));
+
+        const void* blob = objects.getRange(nextOffset, objectSize);
+        nextOffset += objectSize;
+
+        Object object(blob, objectSize);
+
+        jbyteArray jKey = env->NewByteArray(object.getKeyLength());
+        jbyteArray jValue = env->NewByteArray(object.getDataLength());
+
+        JByteArrayGetter key(env, jKey);
+        JByteArrayGetter value(env, jValue);
+
+        memcpy(key.pointer, object.getKey(), object.getKeyLength());
+        memcpy(value.pointer, object.getData(), object.getDataLength());
+
+        version = object.getVersion();
+
+        jobject obj = env->NewObject(jc_RcObject, jm_init, jKey, jValue, static_cast<jlong>(version));
+        check_null(obj, "NewObject failed");
+
+        env->SetObjectArrayElement(outJNIArray, i, obj);
+    }
+
+    return env->NewObject(jc_RcTableObject, jm_TableEnumeratorObject_init, outJNIArray, jTabletNextHash);
+
+}
+
+/*
+ * Class:     edu_stanford_ramcloud_JRamCloud
  * Method:    multiWrite
  * Signature: ([Ledu/stanford/ramcloud/JRamCloud/MultiWriteObject;)[Ledu/stanford/ramcloud/JRamCloud/MultiWriteRspObject;
  */
-JNIEXPORT jobjectArray JNICALL Java_edu_stanford_ramcloud_JRamCloud_multiWrite(JNIEnv *env, jobject jRamCloud, jobjectArray jmultiWriteArray) {
-    jint requestNum = env->GetArrayLength(jmultiWriteArray);
-    RamCloud* ramcloud = getRamCloud(env, jRamCloud);
-    Tub<MultiWriteObject> objects[requestNum];
-    MultiWriteObject *requests[requestNum];
-    RejectRules rules[requestNum];
-    jbyteArray jKey[requestNum];
-    jbyteArray jValue[requestNum];
+JNIEXPORT jobjectArray JNICALL Java_edu_stanford_ramcloud_JRamCloud_multiWrite(JNIEnv *env, 
+	                                                                       jobject jRamCloud,
+	                                                                       jlongArray jTableId,
+	                                                                       jobjectArray jKeyData,
+	                                                                       jshortArray jKeyLength,
+	                                                                       jobjectArray jValueData,
+	                                                                       jshortArray jValueLength,
+	                                                                       jint jrequestNum,
+	                                                                       jobjectArray jRules ) {
     
-    const static jclass jc_multiWriteObject = (jclass)env->NewGlobalRef(env->FindClass(PACKAGE_PATH "JRamCloud$MultiWriteObject"));
+    RamCloud* ramcloud = getRamCloud(env, jRamCloud);
+    Tub<MultiWriteObject> objects[jrequestNum];
+    MultiWriteObject *requests[jrequestNum];
+    RejectRules rules[jrequestNum];
+    jbyteArray jKey[jrequestNum];
+    jbyteArray jValue[jrequestNum];
+    
+    jlong tableId;
+    jshort keyLength;
+    jshort valueLength;
+    jbyte* keyData[jrequestNum];
+    jbyte* valueData[jrequestNum];
+    
     const static jclass jc_RejectRules = (jclass)env->NewGlobalRef(env->FindClass(PACKAGE_PATH "JRamCloud$RejectRules"));
-    const static jfieldID jf_tableId = env->GetFieldID(jc_multiWriteObject, "tableId", "J");
-    const static jfieldID jf_key = env->GetFieldID(jc_multiWriteObject, "key", "[B");
-    const static jfieldID jf_value = env->GetFieldID(jc_multiWriteObject, "value", "[B");
-    const static jfieldID jf_reject_rules = env->GetFieldID(jc_multiWriteObject, "rules", "L" PACKAGE_PATH "JRamCloud$RejectRules;");
 
     const static jfieldID jf_doesntExist = env->GetFieldID(jc_RejectRules, "doesntExist", "Z");
     check_null(jf_doesntExist, "doesentExist field id is null");
@@ -716,21 +813,20 @@
     const static jfieldID jf_versionNeGiven = env->GetFieldID(jc_RejectRules, "versionNeGiven", "Z");
     check_null(jf_versionNeGiven, "versionNeGiven field id is null");
 
-    for (int i = 0; i < requestNum; i++) {
-        jobject obj = env->GetObjectArrayElement(jmultiWriteArray, i);
-        check_null(obj, "multi write GetObjectArrayElement failed");
+    for (int i = 0; i < jrequestNum; i++) {
+	env->GetLongArrayRegion(jTableId, i, 1, &tableId);
 
-        uint64_t tableId = env->GetLongField(obj, jf_tableId);
-
-        jKey[i] = (jbyteArray)env->GetObjectField(obj, jf_key);
-        jbyte* keyData = env->GetByteArrayElements(jKey[i], NULL);
-        uint16_t keyLength = env->GetArrayLength(jKey[i]);
-
-        jValue[i] = (jbyteArray)env->GetObjectField(obj, jf_value);
-        jbyte* valueData = env->GetByteArrayElements(jValue[i], NULL);
-        uint32_t valueLength = env->GetArrayLength(jValue[i]);
-
-        jobject jRejectRules = env->GetObjectField(obj, jf_reject_rules);
+	env->GetShortArrayRegion(jKeyLength, i, 1, &keyLength);
+	jKey[i] = (jbyteArray)env->GetObjectArrayElement(jKeyData, i);
+	keyData[i] = (jbyte *) malloc(keyLength);
+	env->GetByteArrayRegion(jKey[i], 0, keyLength, keyData[i]);
+	
+	env->GetShortArrayRegion(jValueLength, i, 1, &valueLength);
+        jValue[i] = (jbyteArray)env->GetObjectArrayElement(jValueData, i);
+	valueData[i] = (jbyte *) malloc(valueLength);
+	env->GetByteArrayRegion(jValue[i], 0, valueLength, valueData[i]);
+	
+	jobject jRejectRules = (jbyteArray)env->GetObjectArrayElement(jRules, i);
         rules[i] = {};
 
         if (jRejectRules != NULL) {
@@ -750,28 +846,28 @@
             ruleBool = env->GetBooleanField(jRejectRules, jf_versionNeGiven);
             rules[i].versionNeGiven = ruleBool ? 1 : 0;
         }
-        objects[i].construct(tableId, keyData, keyLength, valueData, valueLength, &rules[i]);
+        objects[i].construct(tableId, keyData[i], keyLength, valueData[i], valueLength, &rules[i]);
         requests[i] = objects[i].get();
     }
     try {
-        ramcloud->multiWrite(requests, requestNum);
+        ramcloud->multiWrite(requests, jrequestNum);
     } EXCEPTION_CATCHER(NULL);
  
     const static jclass jc_RcObject = (jclass)env->NewGlobalRef(env->FindClass(PACKAGE_PATH "JRamCloud$MultiWriteRspObject"));
     check_null(jc_RcObject, "FindClass failed");
     const static jmethodID jm_init = env->GetMethodID(jc_RcObject,
                                         "<init>",
-                                        "(L" PACKAGE_PATH "JRamCloud;IJ)V");
+                                        "(IJ)V");
 
-    jobjectArray outJNIArray = env->NewObjectArray(requestNum, jc_RcObject , NULL);
+    jobjectArray outJNIArray = env->NewObjectArray(jrequestNum, jc_RcObject , NULL);
     check_null(outJNIArray, "NewObjectArray failed");
     
-    for (int i = 0 ; i < requestNum ; i++) {
-        jobject obj = env->NewObject(jc_RcObject, jm_init, jRamCloud, objects[i]->status, objects[i]->version);
+    for (int i = 0 ; i < jrequestNum ; i++) {
+        jobject obj = env->NewObject(jc_RcObject, jm_init, objects[i]->status, objects[i]->version);
         check_null(obj, "NewObject failed");
         env->SetObjectArrayElement(outJNIArray, i, obj);
-        env->ReleaseByteArrayElements(jKey[i], (jbyte *)requests[i]->key, JNI_ABORT);
-        env->ReleaseByteArrayElements(jValue[i], (jbyte *)requests[i]->value, JNI_ABORT);
+	free(keyData[i]);
+	free(valueData[i]);
         objects[i].destroy();
     }
     return outJNIArray;
diff --git a/src/main/java/com/tinkerpop/blueprints/impls/ramcloud/RamCloudGraph.java b/src/main/java/com/tinkerpop/blueprints/impls/ramcloud/RamCloudGraph.java
index 26f1418..ad519c8 100644
--- a/src/main/java/com/tinkerpop/blueprints/impls/ramcloud/RamCloudGraph.java
+++ b/src/main/java/com/tinkerpop/blueprints/impls/ramcloud/RamCloudGraph.java
@@ -247,16 +247,18 @@
 	    }
 	    vertices.add(v);
 	}
-	MultiWriteObject multiWriteObjects[] = new MultiWriteObject[vertices.size() * 2];
+	
+	MultiWriteObject mwo = new MultiWriteObject(vertices.size()*2);
+		
 	for (int i=0; i < vertices.size(); i++) {
 	    RamCloudVertex v = vertices.get(i);
-	    multiWriteObjects[i*2] = new MultiWriteObject(vertTableId, v.rcKey, ByteBuffer.allocate(0).array(), null);
-	    multiWriteObjects[i*2+1] = new MultiWriteObject(vertPropTableId, v.rcKey, ByteBuffer.allocate(0).array(), null);
+	    mwo.setObject(i*2, vertTableId, v.rcKey, ByteBuffer.allocate(0).array(), null);
+	    mwo.setObject(i*2+1, vertTableId, v.rcKey, ByteBuffer.allocate(0).array(), null);
 	}
 	try {
 		PerfMon pm = PerfMon.getInstance();
 		pm.multiwrite_start("RamCloudVertex create()");
-	    getRcClient().multiWrite(multiWriteObjects);
+		getRcClient().multiWrite(mwo.tableId, mwo.key, mwo.keyLength, mwo.value, mwo.valueLength, vertices.size()*2, mwo.rules);
 		pm.multiwrite_end("RamCloudVertex create()");
 	    log.info("ramcloud vertices are created");
 	} catch (Exception e) {
diff --git a/src/main/java/com/tinkerpop/blueprints/impls/ramcloud/RamCloudVertex.java b/src/main/java/com/tinkerpop/blueprints/impls/ramcloud/RamCloudVertex.java
index b41dca8..03c4ba3 100644
--- a/src/main/java/com/tinkerpop/blueprints/impls/ramcloud/RamCloudVertex.java
+++ b/src/main/java/com/tinkerpop/blueprints/impls/ramcloud/RamCloudVertex.java
@@ -490,12 +490,12 @@
 		// TODO: Existence check costs extra (presently 2 reads), could use option to turn on/off
 		if (!exists()) {
 			PerfMon pm = PerfMon.getInstance();
-			JRamCloud vertTable = graph.getRcClient();
-			MultiWriteObject[] mwo = new MultiWriteObject[2];
-			mwo[0] = new MultiWriteObject(graph.vertTableId, rcKey, ByteBuffer.allocate(0).array(), null);
-			mwo[1] = new MultiWriteObject(graph.vertPropTableId, rcKey, ByteBuffer.allocate(0).array(), null);
+			JRamCloud vertTable = graph.getRcClient();			
+			MultiWriteObject mwo = new MultiWriteObject(2);
+			mwo.setObject(1, graph.vertTableId, rcKey, ByteBuffer.allocate(0).array(), null);
+			mwo.setObject(2, graph.vertPropTableId, rcKey, ByteBuffer.allocate(0).array(), null);
 			pm.multiwrite_start("RamCloudVertex create()");
-			vertTable.multiWrite(mwo);
+			vertTable.multiWrite(mwo.tableId, mwo.key, mwo.keyLength, mwo.value, mwo.valueLength, 2, mwo.rules);
 			pm.multiwrite_end("RamCloudVertex create()");
 		} else {
 			throw ExceptionFactory.vertexWithIdAlreadyExists(id);
diff --git a/src/main/java/edu/stanford/ramcloud/JRamCloud.java b/src/main/java/edu/stanford/ramcloud/JRamCloud.java
index dfb4b6a..63b0748 100644
--- a/src/main/java/edu/stanford/ramcloud/JRamCloud.java
+++ b/src/main/java/edu/stanford/ramcloud/JRamCloud.java
@@ -14,9 +14,8 @@
  */
 
 package edu.stanford.ramcloud;
-import java.util.ArrayList;
 import java.util.Arrays;
-import java.lang.Integer;
+import java.util.LinkedList;
 
 /*
  * This class provides Java bindings for RAMCloud. Right now it is a rather
@@ -78,31 +77,53 @@
         }	
     }
     
-    public static class multiReadObject {
-        long tableId;
-        byte[] key;
+    public static class MultiReadObject {
+        public long[] tableId;
+        public byte[] key[];
+	public short[] keyLength;
         
-        public multiReadObject(long _tableId, byte[] _key){
-            tableId = _tableId;
-            key = _key;
+        public MultiReadObject(int size){
+            this.tableId = new long[size];
+            this.key = new byte[size][];
+	    this.keyLength = new short[size];
         }
+	
+	public void setObject(int num, long tableId, byte key[]){
+            this.tableId[num] = tableId;
+            this.key[num] = key;
+	    this.keyLength[num] = (short) this.key[num].length;
+	}
     }
     
     public static class MultiWriteObject {
-        long tableId;
-        byte[] key;
-        byte[] value;
-        RejectRules rules;
+        public long[] tableId;
+        public byte[] key[];
+	public short[] keyLength;
+        public byte[] value[];
+	public short[] valueLength;
+        public RejectRules[] rules;
 
-        public MultiWriteObject(long tableId, byte[] key, byte[] value, RejectRules rules) {
-            this.tableId = tableId;
-            this.key = key;
-            this.value = value;
-            this.rules = rules;
+        public MultiWriteObject(int size) {
+            this.tableId = new long[size];
+            this.key = new byte[size][];
+	    this.keyLength = new short[size];
+            this.value = new byte[size][];
+	    this.valueLength = new short[size];
+            this.rules = new RejectRules[size];
         }
+	
+	public void setObject(int num, long tableId, byte key[], byte value[], RejectRules rules){
+	    this.tableId[num] = tableId;
+	    this.key[num] = key;
+	    this.keyLength[num] = (short) key.length;
+	    this.value[num] = value;
+	    this.valueLength[num] = (short) value.length;
+	    this.rules[num] = rules;
+	}
+	
     }
 
-    public class MultiWriteRspObject {
+    public static class MultiWriteRspObject {
         private int status;
         private long version;
 
@@ -127,7 +148,7 @@
      * or multiple return values, and we don't know the object's size ahead of
      * time, so passing in a fixed-length array would be problematic.
      */
-    public class Object {
+    public static class Object {
         Object(byte[] _key, byte[] _value, long _version)
         {
             key = _key;
@@ -151,6 +172,17 @@
         final public byte[] value;
         final public long version;
     }
+    
+    public static class TableEnumeratorObject {
+	TableEnumeratorObject(Object[] _object, long _nextHash)
+        {
+	    object = _object;
+	    nextHash = _nextHash;
+	}
+	
+	final public Object[] object;
+	final public long nextHash;
+    }
 
     public class TableEnumerator {
         private long tableEnumeratorObjectPointer = 0;
@@ -167,6 +199,43 @@
         public native Object next();
     }
 
+    public class TableEnumerator2 {
+        
+	protected long tableId;
+	protected LinkedList<JRamCloud.Object> rcobjs = null;
+	protected long nextHash = 0;
+	protected boolean done = false;
+	
+        public TableEnumerator2(long tableId)
+        {
+	    this.tableId = tableId;
+	    rcobjs = new LinkedList<>();
+        }
+        public boolean hasNext() {
+	    if (rcobjs.isEmpty()) 
+	    {
+		if (done) {
+		    return false;
+		}
+		JRamCloud.TableEnumeratorObject o = getTableObjects(this.tableId, this.nextHash);
+		if (o.nextHash == 0L) {
+		    done = true;
+		}
+		this.nextHash = o.nextHash;
+		rcobjs.addAll(Arrays.asList(o.object));
+		if (rcobjs.isEmpty()) {
+		    return false;
+		}
+	    }
+	    return true;
+	}
+	
+	public Object next() 
+	{
+	    return rcobjs.pop();
+	}
+    }
+    
     /**
      * Connect to the RAMCloud cluster specified by the given coordinator's
      * service locator string. This causes the JNI code to instantiate the
@@ -294,7 +363,8 @@
     public native long write(long tableId, byte[] key, byte[] value);
     public native long write(long tableId, byte[] key, byte[] value, RejectRules rules);
     public native long writeRule(long tableId, byte[] key, byte[] value, RejectRules rules);
-    public native MultiWriteRspObject[] multiWrite(MultiWriteObject[] mwrite);
+    public native MultiWriteRspObject[] multiWrite(long[] tableId, byte[] key[], short[] keyDataSize, byte[] value[], short[] valueDataSize, int requestNum, RejectRules[] rules);
+    public native TableEnumeratorObject getTableObjects(long tableId, long nextHash);
 
     /*
      * The following exceptions may be thrown by the JNI functions:
@@ -339,7 +409,60 @@
             super(message);
         }
     }
+    
+    public static void tableEnumeratorTest(JRamCloud ramcloud) {
+        long startTime = 0;
+        for (int x = 0 ; x < 2 ; x ++){
+        for(int N = 1000; N < 10000; N += 1000) {
+            long EnumerateTesttable = ramcloud.createTable("EnumerateTest");
+            for(int i = 0 ; i < N ; ++i) {
+                String key = new Integer(i).toString();
+                ramcloud.write(EnumerateTesttable, key.getBytes(), "Hello, World!".getBytes());
+            }
 
+            MultiReadObject mread[] = new MultiReadObject[N];
+            long tableIdList[] = new long[N];
+            byte[] keydata[] = new byte[N][];
+            short keydataSize[] = new short[N];
+	    startTime = System.nanoTime();
+            for (int j = 0 ; j < N ; ++j) {
+                tableIdList[j] = EnumerateTesttable;
+                String key = new Integer(j).toString();
+                keydata[j] = key.getBytes();
+                keydataSize[j] = (short) keydata[j].length;
+            }
+            JRamCloud.Object out[] = ramcloud.multiRead(tableIdList, keydata, keydataSize, N);
+            for (int i = 0; i < N; ++i) {
+                if(out[i].version == 0) {
+                        System.out.println("Verify fail " + out[i].getKey() + " V:" + out[i].getValue());
+                }
+            }
+
+            System.out.println("multiRead           : " + N + " Time : " + (System.nanoTime()-startTime));
+
+            startTime = System.nanoTime();
+            JRamCloud.TableEnumerator tableEnum = ramcloud.new TableEnumerator(EnumerateTesttable);
+            while (tableEnum.hasNext()) {
+                Object tableEntry = tableEnum.next();
+                if (tableEntry != null) {
+                    System.out.println("tableEnumerator object: key = [" + tableEntry.getKey() + "], value = [" + tableEntry.getValue() + "]");
+                }
+            }
+	    System.out.println("old TableEnumerator : " + N + " Time : " + (System.nanoTime()-startTime));
+
+            startTime = System.nanoTime();
+            JRamCloud.TableEnumerator2 tableEnum2 = ramcloud.new TableEnumerator2(EnumerateTesttable);
+	    while (tableEnum2.hasNext()) {
+		Object tableEntry2 = tableEnum2.next();
+		if (tableEntry2 != null) {
+                    System.out.println("tableEnumerator2 object: key = [" + tableEntry2.getKey() + "], value = [" + tableEntry2.getValue() + "]");
+                }
+            }
+            System.out.println("new TableEnumerator : " + N + " Time : " + (System.nanoTime()-startTime));
+            ramcloud.dropTable("EnumerateTest");
+        }
+        }
+    }
     /**
      * A simple end-to-end test of the java bindings.
      */
@@ -391,30 +514,26 @@
         ramcloud.write(tableId6, "object3-1", "value:3-1");
         ramcloud.write(tableId6, "object3-2", "value:3-2");
 
-	long tableIdList[] = new long[2];
-        byte[] keydata[] = new byte[2][];
-        short keydataSize[] = new short[2];
-        tableIdList[0] = tableId4;
-        keydata[0] = "object1-1".getBytes();
-        keydataSize[0] = (short) keydata[0].length;
-        tableIdList[1] = tableId5;
-        keydata[1] = "object2-1".getBytes();
-	keydataSize[1] = (short) keydata[1].length;
+	MultiReadObject mr = new MultiReadObject(2);
+	MultiWriteObject mw = new MultiWriteObject(2);
+	
+	mr.setObject(0, tableId4, "object1-1".getBytes());
+	mr.setObject(1, tableId5, "object2-1".getBytes());
 
-        JRamCloud.Object out[] = ramcloud.multiRead(tableIdList, keydata, keydataSize, 2);
+        JRamCloud.Object out[] = ramcloud.multiRead(mr.tableId, mr.key, mr.keyLength, 2);
         for (int i = 0 ; i < 2 ; i++){
             System.out.println("multi read object: key = [" + out[i].getKey() + "], value = ["
                     + out[i].getValue() + "]");
         }
 
-        MultiWriteObject mwrite[] = new MultiWriteObject[2];
         for (int i = 0; i < 1000; i++) {
             String key1 = "key1" + new Integer(i).toString();
             String key2 = "key2" + new Integer(i).toString();
-      
-            mwrite[0] = new MultiWriteObject(tableId4, key1.getBytes(), "v0-value".getBytes(), null);
-            mwrite[1] = new MultiWriteObject(tableId5, key2.getBytes(), "v1".getBytes(), null);
-            MultiWriteRspObject[] rsp = ramcloud.multiWrite(mwrite);
+	    
+	    mw.setObject(0, tableId4, key1.getBytes(), "v0-value".getBytes(), null);
+	    mw.setObject(1, tableId5, key2.getBytes(), "v1".getBytes(), null);
+      	    
+            MultiWriteRspObject[] rsp = ramcloud.multiWrite(mw.tableId, mw.key, mw.keyLength, mw.value, mw.valueLength, 2, mw.rules);
             if (rsp != null) {
                 for (int j = 0; j < rsp.length; j++) {
                     System.out.println("multi write rsp(" + j + ") status:version " + rsp[j].getStatus() + ":" + rsp[j].getVersion());
@@ -424,19 +543,18 @@
         for (int i = 0; i < 1000; i++) {
             String key1 = "key1" + new Integer(i).toString();
             String key2 = "key2" + new Integer(i).toString();
-            tableIdList[0] = tableId4;
-            keydata[0] = key1.getBytes();
-            keydataSize[0] = (short) keydata[0].length;
-            tableIdList[1] = tableId5;
-            keydata[1] = key2.getBytes();
-            keydataSize[1] = (short) keydata[1].length;
 
-            out = ramcloud.multiRead(tableIdList, keydata, keydataSize, 2);
+	    mr.setObject(0, tableId4, key1.getBytes());
+	    mr.setObject(1, tableId5, key2.getBytes());
+	    
+            out = ramcloud.multiRead(mr.tableId, mr.key, mr.keyLength, 2);
             for (int j = 0; j < 2; j++) {
                 System.out.println("multi read object: key = [" + out[j].getKey() + "], value = [" + out[j].getValue() + "]");
             }
         }
 
+	tableEnumeratorTest(ramcloud);
+	
         ramcloud.dropTable("table4");
         ramcloud.dropTable("table5");
         ramcloud.dropTable("table6");
diff --git a/src/main/java/net/onrc/onos/datastore/RCObject.java b/src/main/java/net/onrc/onos/datastore/RCObject.java
index a990978..a2d8c6e 100644
--- a/src/main/java/net/onrc/onos/datastore/RCObject.java
+++ b/src/main/java/net/onrc/onos/datastore/RCObject.java
@@ -18,12 +18,14 @@
 import com.esotericsoftware.kryo.io.Output;
 
 import edu.stanford.ramcloud.JRamCloud;
+import edu.stanford.ramcloud.JRamCloud.MultiReadObject;
 import edu.stanford.ramcloud.JRamCloud.MultiWriteObject;
 import edu.stanford.ramcloud.JRamCloud.MultiWriteRspObject;
 import edu.stanford.ramcloud.JRamCloud.ObjectDoesntExistException;
 import edu.stanford.ramcloud.JRamCloud.ObjectExistsException;
 import edu.stanford.ramcloud.JRamCloud.RejectRules;
 import edu.stanford.ramcloud.JRamCloud.TableEnumerator;
+import edu.stanford.ramcloud.JRamCloud.TableEnumerator2;
 import edu.stanford.ramcloud.JRamCloud.WrongVersionException;
 
 /**
@@ -304,21 +306,17 @@
 	JRamCloud rcClient = RCClient.getClient();
 
 	final int reqs = req.size();
-
-        long tableId[] = new long[reqs];
-        byte[] key[] = new byte[reqs][];
-        short keySize[] = new short[reqs];
+	
+	MultiReadObject multiReadObjects = new MultiReadObject(req.size());
 
 	// setup multi-read operation
 	for (int i = 0; i < reqs; ++i) {
 	    RCObject obj = req.get(i);
-            tableId[i] = obj.getTableId();
-            key[i] = obj.getKey();
-            keySize[i] = (short) key[i].length;
+            multiReadObjects.setObject(i, obj.getTableId(), obj.getKey());
 	}
 
 	// execute
-	JRamCloud.Object results[] = rcClient.multiRead(tableId, key, keySize, reqs);
+	JRamCloud.Object results[] = rcClient.multiRead(multiReadObjects.tableId, multiReadObjects.key, multiReadObjects.keyLength, reqs);
 	assert (results.length <= req.size());
 
 	// reflect changes to RCObject
@@ -420,10 +418,10 @@
     private static boolean multiWriteInternal(ArrayList<WriteOp> ops) {
 
 	boolean fail_exists = false;
-	MultiWriteObject multiWriteObjects[] = new MultiWriteObject[ops.size()];
+	MultiWriteObject multiWriteObjects = new MultiWriteObject(ops.size());
 	JRamCloud rcClient = RCClient.getClient();
 
-	for (int i = 0; i < multiWriteObjects.length; ++i) {
+	for (int i = 0; i < ops.size(); ++i) {
 	    WriteOp op = ops.get(i);
 	    RCObject obj = op.getObject();
 
@@ -442,12 +440,11 @@
 		rules.setNeVersion(obj.getVersion());
 		break;
 	    }
-	    multiWriteObjects[i] = new MultiWriteObject(obj.getTableId(),
-		    obj.getKey(), obj.getValue(), rules);
+	    multiWriteObjects.setObject(i, obj.getTableId(), obj.getKey(), obj.getValue(), rules);
 	}
 
-	MultiWriteRspObject[] results = rcClient.multiWrite(multiWriteObjects);
-	assert (results.length == multiWriteObjects.length);
+	MultiWriteRspObject[] results = rcClient.multiWrite(multiWriteObjects.tableId, multiWriteObjects.key, multiWriteObjects.keyLength, multiWriteObjects.value, multiWriteObjects.valueLength, ops.size(), multiWriteObjects.rules);
+	assert (results.length == ops.size());
 
 	for (int i = 0; i < results.length; ++i) {
 	    WriteOp op = ops.get(i);
@@ -467,17 +464,17 @@
 
 	return fail_exists;
     }
-
+   
     public static abstract class ObjectIterator<E extends RCObject> implements
 	    Iterator<E> {
 
-	protected TableEnumerator enumerator;
+	protected TableEnumerator2 enumerator;
 
 	public ObjectIterator(RCTable table) {
 	    // FIXME workaround for JRamCloud bug. It should have been declared
 	    // as static class
 	    JRamCloud c = RCClient.getClient();
-	    this.enumerator = c.new TableEnumerator(table.getTableId());
+	    this.enumerator = c.new TableEnumerator2(table.getTableId());
 	}
 
 	@Override
@@ -493,7 +490,7 @@
 //	    obj.setValueAndDeserialize(o.value, o.version);
 //	    return obj;
 //	}
-
+	
 	@Deprecated
 	@Override
 	public void remove() {