Improve cursor window performance, allow user to override window size

The JNI CursorWindow will allocate 1 MB of storage for mapping results. Under
the new default behavior, the CursorWindow will grow in size incrementally by
1 MB chunks as needed. This behavior allows for retrieving results of an
unknown size.

Alternatively, some queries may perform better with a fixed allocation of
storage. This will limit the total cursor window storage to a fixed size,
constraining the size of the fields mapped into the backing store. This causes
the cursor window to behave as a viewport into the underlying resultset, only
mapping a segement (as defined by the storage size) into memory at a given time.
To do so, the user can specify the window size prior to performing the query
as such:

long size = 1024 * 1024 * 4;
CursorWindow.setCursorWindowAllocation(new FixedCursorWindowAllocation(size));

Author: developernotes

android-database-sqlcipher/src/main/cpp/CursorWindow.cpp

@@ -33,39 +33,27 @@
 
 namespace sqlcipher {
 
-CursorWindow::CursorWindow(size_t maxSize) :
-    mMaxSize(maxSize)
+CursorWindow::CursorWindow(size_t initialSize, size_t fixedAllocationSize)
 {
+  mInitialSize = initialSize;
+  mFixedAllocationSize = fixedAllocationSize;
+  LOG_WINDOW("CursorWindow::CursorWindow initialSize:%d fixedAllocationSize:%d",
+             initialSize, fixedAllocationSize);
 }
 
-// bool CursorWindow::setMemory(const android::sp<android::IMemory>& memory)
-// {
-//     mMemory = memory;
-//     mData = (uint8_t *) memory->pointer();
-//     if (mData == NULL) {
-//         return false;
-
-//     }
-//     mHeader = (window_header_t *) mData;
-
-//     // Make the window read-only
-//     ssize_t size = memory->size();
-//     mSize = size;
-//     mMaxSize = size;
-//     mFreeOffset = size;
-// LOG_WINDOW("Created CursorWindow from existing IMemory: mFreeOffset = %d, numRows = %d, numColumns = %d, mSize = %d, mMaxSize = %d, mData = %p", mFreeOffset, mHeader->numRows, mHeader->numColumns, mSize, mMaxSize, mData);
-//     return true;
-// }
-
 bool CursorWindow::initBuffer(bool localOnly)
 {
-  void* data = malloc(mMaxSize);
+  size_t size = mFixedAllocationSize == WINDOW_ALLOCATION_UNBOUNDED
+    ? mInitialSize
+    : mFixedAllocationSize;
+  void* data = malloc(size);
   if(data){
     mData = (uint8_t *) data;
     mHeader = (window_header_t *) mData;
-    mSize = mMaxSize;
+    mSize = size;
     clear();
-    LOG_WINDOW("Created CursorWindow with new MemoryDealer: mFreeOffset = %d, mSize = %d, mMaxSize = %d, mData = %p", mFreeOffset, mSize, mMaxSize, mData);
+    LOG_WINDOW("Created CursorWindow with new MemoryDealer: mFreeOffset = %d, mSize = %d, mInitialSize = %d, mFixedAllocationSize = %d, mData = %p",
+               mFreeOffset, mSize, mInitialSize, mFixedAllocationSize, mData);
     return true;
   }
   return false;
@@ -141,15 +129,19 @@ uint32_t CursorWindow::alloc(size_t requestedSize, bool aligned)
     }
     size = requestedSize + padding;
     if (size > freeSpace()) {
-        LOGE("need to grow: mSize = %d, size = %d, freeSpace() = %d, numRows = %d",
+      LOGE("need to grow: mSize = %d, size = %d, freeSpace() = %d, numRows = %d",
              mSize, size, freeSpace(), mHeader->numRows);
+      if(mFixedAllocationSize == WINDOW_ALLOCATION_UNBOUNDED) {
         new_allocation_sz = mSize + size - freeSpace() + GROW_WINDOW_SIZE_EXTRA;
         tempData = realloc((void *)mData, new_allocation_sz);
         if(tempData == NULL) return 0;
         mData = (uint8_t *)tempData;
         mHeader = (window_header_t *)mData;
         LOGE("allocation grew to:%d", new_allocation_sz);
         mSize = new_allocation_sz;
+      } else {
+        return 0;
+      }
     }
     uint32_t offset = mFreeOffset + padding;
     mFreeOffset += size;

android-database-sqlcipher/src/main/cpp/CursorWindow.h

@@ -25,23 +25,16 @@
 #include <jni.h>
 #include "log.h"
 
-// #include <cutils/log.h>
-// #include <binder/IMemory.h>
-// #include <utils/RefBase.h>
+#define ROW_SLOT_CHUNK_NUM_ROWS 512
+#define INITIAL_WINDOW_SIZE (1024 * 1024)
+#define GROW_WINDOW_SIZE_EXTRA INITIAL_WINDOW_SIZE
+#define WINDOW_ALLOCATION_UNBOUNDED 0
 
-#define DEFAULT_WINDOW_SIZE 4096
-#define MAX_WINDOW_SIZE (1024 * 1024)
-#define WINDOW_ALLOCATION_SIZE 4096
-
-#define ROW_SLOT_CHUNK_NUM_ROWS 16
-
-#define GROW_WINDOW_SIZE_EXTRA MAX_WINDOW_SIZE / 10
 
 // Row slots are allocated in chunks of ROW_SLOT_CHUNK_NUM_ROWS,
 // with an offset after the rows that points to the next chunk
 #define ROW_SLOT_CHUNK_SIZE ((ROW_SLOT_CHUNK_NUM_ROWS * sizeof(row_slot_t)) + sizeof(uint32_t))
 
-
 #if LOG_NDEBUG
 
 #define IF_LOG_WINDOW() if (false)
@@ -58,7 +51,8 @@
 // When defined to true strings are stored as UTF8, otherwise they're UTF16
 #define WINDOW_STORAGE_UTF8 0
 
-// When defined to true numberic values are stored inline in the field_slot_t, otherwise they're allocated in the window
+// When defined to true numberic values are stored inline in the field_slot_t,
+// otherwise they're allocated in the window
 #define WINDOW_STORAGE_INLINE_NUMERICS 1
 
 namespace sqlcipher {
@@ -104,14 +98,11 @@ typedef struct
 class CursorWindow
 {
 public:
-                        CursorWindow(size_t maxSize);
+                        CursorWindow(size_t initialSize, size_t fixedAllocationSize);
                         CursorWindow(){}
-    /* bool                setMemory(const android::sp<android::IMemory>&); */
                         ~CursorWindow();
 
     bool                initBuffer(bool localOnly);
-    /* android::sp<android::IMemory>         getMemory() {return mMemory;} */
-
     size_t              size() {return mSize;}
     uint8_t *           data() {return mData;}
     uint32_t            getNumRows() {return mHeader->numRows;}
@@ -192,10 +183,9 @@ class CursorWindow
 private:
     uint8_t * mData;
     size_t mSize;
-    size_t mMaxSize;
+    size_t mInitialSize;
+    size_t mFixedAllocationSize;
     window_header_t * mHeader;
-    /* android::sp<android::IMemory> mMemory; */
-
     /**
      * Offset of the lowest unused data byte in the array.
      */

android-database-sqlcipher/src/main/cpp/net_sqlcipher_CursorWindow.cpp

@@ -50,13 +50,14 @@ namespace sqlcipher {
     return GET_WINDOW(env, javaWindow);
   }
 
-  static void native_init_empty(JNIEnv * env, jobject object, jboolean localOnly)
+  static void native_init_empty(JNIEnv * env, jobject object,
+                                jboolean localOnly, jlong fixedAllocationSize)
   {
     uint8_t * data;
     size_t size;
     CursorWindow * window;
 
-    window = new CursorWindow(MAX_WINDOW_SIZE);
+    window = new CursorWindow(INITIAL_WINDOW_SIZE, fixedAllocationSize);
     if (!window) {
       jniThrowException(env, "java/lang/RuntimeException", "No memory for native window object");
       return;
@@ -616,7 +617,7 @@ namespace sqlcipher {
   static JNINativeMethod sMethods[] =
     {
       /* name, signature, funcPtr */
-      {"native_init", "(Z)V", (void *)native_init_empty},
+      {"native_init", "(ZJ)V", (void *)native_init_empty},
       // {"native_init", "(Landroid/os/IBinder;)V", (void *)native_init_memory},
       // {"native_getBinder", "()Landroid/os/IBinder;", (void *)native_getBinder},
       {"native_clear", "()V", (void *)native_clear},

android-database-sqlcipher/src/main/java/net/sqlcipher/CursorWindow.java

@@ -31,6 +31,9 @@
 import java.io.UnsupportedEncodingException;
 import java.nio.charset.StandardCharsets;
 
+import net.sqlcipher.CursorWindowAllocation;
+import net.sqlcipher.DefaultCursorWindowAllocation;
+
 /**
  * A buffer containing multiple cursor rows.
  */
@@ -42,18 +45,30 @@ public class CursorWindow extends android.database.CursorWindow implements Parce
      * android_database_CursorWindow.cpp
      */
     private long nWindow;
-
     private int mStartPos;
 
-    /**
+    private static CursorWindowAllocation allocation = new DefaultCursorWindowAllocation();
+
+    public static void setCursorWindowAllocation(CursorWindowAllocation value){
+      allocation = value;
+    }
+
+    public static CursorWindowAllocation getCursorWindowAllocation() {
+      return allocation;
+    }
+
+  /**
      * Creates a new empty window.
      *
      * @param localWindow true if this window will be used in this process only
      */
     public CursorWindow(boolean localWindow) {
     	super(localWindow);
         mStartPos = 0;
-        native_init(localWindow);
+        if(allocation == null){
+          allocation = new DefaultCursorWindowAllocation();
+        }
+        native_init(localWindow, allocation.getAllocationSize());
     }
 
     /**
@@ -620,7 +635,7 @@ public CursorWindow(Parcel source,int foo) {
     private native IBinder native_getBinder();
 
     /** Does the native side initialization for an empty window */
-    private native void native_init(boolean localOnly);
+    private native void native_init(boolean localOnly, long fixedAllocationSize);
 
     /** Does the native side initialization with an existing binder from another process */
     private native void native_init(IBinder nativeBinder);

android-database-sqlcipher/src/main/java/net/sqlcipher/CursorWindowAllocation.java

@@ -0,0 +1,5 @@
+package net.sqlcipher;
+
+public interface CursorWindowAllocation {
+  long getAllocationSize();
+}

android-database-sqlcipher/src/main/java/net/sqlcipher/DefaultCursorWindowAllocation.java

@@ -0,0 +1,9 @@
+package net.sqlcipher;
+
+import net.sqlcipher.CursorWindowAllocation;
+
+public class DefaultCursorWindowAllocation implements CursorWindowAllocation {
+  public long getAllocationSize(){
+    return 0;
+  }
+}

android-database-sqlcipher/src/main/java/net/sqlcipher/FixedCursorWindowAllocation.java

@@ -0,0 +1,16 @@
+package net.sqlcipher;
+
+import net.sqlcipher.CursorWindowAllocation;
+
+public class FixedCursorWindowAllocation implements CursorWindowAllocation {
+
+  private long allocationSize = 0L;
+
+  public FixedCursorWindowAllocation(long size){
+    allocationSize = size;
+  }
+
+  public long getAllocationSize(){
+    return allocationSize;
+  }
+}