MVStore: auto-save (every few MBs and every 1-2 seconds)

h2/src/main/org/h2/mvstore/MVMap.java

@@ -48,6 +48,9 @@ public class MVMap<K, V> extends AbstractMap<K, V>
     private boolean closed;
     private boolean readOnly;
 
+    private volatile boolean writing;
+    private volatile int writeCount;
+
     protected MVMap(DataType keyType, DataType valueType) {
         this.keyType = keyType;
         this.valueType = valueType;
@@ -91,13 +94,17 @@ public class MVMap<K, V> extends AbstractMap<K, V>
      */
     @SuppressWarnings("unchecked")
     public V put(K key, V value) {
-        checkWrite();
+        beforeWrite();
+        try {
             long writeVersion = store.getCurrentVersion();
             Page p = copyOnWrite(root, writeVersion);
             p = splitRootIfNeeded(p, writeVersion);
             Object result = put(p, writeVersion, key, value);
             newRoot(p);
             return (V) result;
+        } finally {
+            afterWrite();
+        }
     }
 
     /**
@@ -488,9 +495,13 @@ public class MVMap<K, V> extends AbstractMap<K, V>
      * Remove all entries.
      */
     public void clear() {
-        checkWrite();
+        beforeWrite();
+        try {
             root.removeAllRecursive();
             newRoot(Page.createEmpty(this, store.getCurrentVersion()));
+        } finally {
+            afterWrite();
+        }
     }
 
     /**
@@ -498,11 +509,16 @@ public class MVMap<K, V> extends AbstractMap<K, V>
      */
     public void removeMap() {
         checkOpen();
-        if (this != store.getMetaMap()) {
-            checkWrite();
+        if (this == store.getMetaMap()) {
+            return;
+        }
+        beforeWrite();
+        try {
             root.removeAllRecursive();
             store.removeMap(id);
             close();
+        } finally {
+            afterWrite();
         }
     }
 
@@ -527,13 +543,17 @@ public class MVMap<K, V> extends AbstractMap<K, V>
      * @return the old value if the key existed, or null otherwise
      */
     public V remove(Object key) {
-        checkWrite();
+        beforeWrite();
+        try {
             long writeVersion = store.getCurrentVersion();
             Page p = copyOnWrite(root, writeVersion);
             @SuppressWarnings("unchecked")
             V result = (V) remove(p, writeVersion, key);
             newRoot(p);
             return result;
+        } finally {
+            afterWrite();
+        }
     }
 
     /**
@@ -616,7 +636,7 @@ public class MVMap<K, V> extends AbstractMap<K, V>
                 result = p.getValue(index);
                 p.remove(index);
                 if (p.getKeyCount() == 0) {
-                    removePage(p);
+                    removePage(p.getPos());
                 }
             }
             return result;
@@ -638,7 +658,7 @@ public class MVMap<K, V> extends AbstractMap<K, V>
             if (p.getKeyCount() == 0) {
                 p.setChild(index, c);
                 p.setCounts(index, c);
-                removePage(p);
+                removePage(p.getPos());
             } else {
                 p.remove(index);
             }
@@ -673,15 +693,6 @@ public class MVMap<K, V> extends AbstractMap<K, V>
         }
     }
 
-    /**
-     * Check whether this map has any unsaved changes.
-     *
-     * @return true if there are unsaved changes.
-     */
-    public boolean hasUnsavedChanges() {
-        return !oldRoots.isEmpty();
-    }
-
     /**
      * Compare two keys.
      *
@@ -819,7 +830,8 @@ public class MVMap<K, V> extends AbstractMap<K, V>
      * @param version the version
      */
     void rollbackTo(long version) {
-        checkWrite();
+        beforeWrite();
+        try {
             removeUnusedOldVersions();
             if (version <= createVersion) {
                 // the map is removed later
@@ -837,12 +849,15 @@ public class MVMap<K, V> extends AbstractMap<K, V>
                     }
                 }
             }
+        } finally {
+            afterWrite();
+        }
     }
 
     /**
      * Forget all old versions.
      */
-    void removeAllOldVersions() {
+    private void removeAllOldVersions() {
         // create a new instance
         // because another thread might iterate over it
         oldRoots = new ArrayList<Page>();
@@ -887,16 +902,44 @@ public class MVMap<K, V> extends AbstractMap<K, V>
     }
 
     /**
-     * Check whether writing is allowed.
+     * This method is called before writing to the map. The default
+     * implementation checks whether writing is allowed.
      *
-     * @throws IllegalStateException if the map is read-only
+     * @throws UnsupportedOperationException if the map is read-only
      */
-    protected void checkWrite() {
+    protected void beforeWrite() {
         if (readOnly) {
             checkOpen();
             throw DataUtils.newUnsupportedOperationException(
                     "This map is read-only");
         }
+        writing = true;
+        store.beforeWrite();
+    }
+
+    /**
+     * This method is called after writing to the map.
+     */
+    protected void afterWrite() {
+        writeCount++;
+        writing = false;
+    }
+
+    void waitUntilWritten(long version) {
+        if (root.getVersion() < version) {
+            // a write will create a new version
+            return;
+        }
+        // wait until writing is done,
+        // but only for the current write operation
+        // a bit like a spin lock
+        int w = writeCount;
+        while (writing) {
+            if (writeCount > w) {
+                return;
+            }
+            Thread.yield();
+        }
     }
 
     public int hashCode() {
@@ -926,8 +969,8 @@ public class MVMap<K, V> extends AbstractMap<K, V>
      *
      * @param p the page
      */
-    protected void removePage(Page p) {
-        store.removePage(p.getPos());
+    protected void removePage(long pos) {
+        store.removePage(this, pos);
     }
 
     /**
@@ -1051,15 +1094,18 @@ public class MVMap<K, V> extends AbstractMap<K, V>
      * @param newMapName the name name
      */
     public void renameMap(String newMapName) {
-        checkWrite();
+        beforeWrite();
+        try {
             store.renameMap(this, newMapName);
+        } finally {
+            afterWrite();
+        }
     }
 
     public String toString() {
         return asString(null);
     }
 
-
     /**
      * A builder for maps.
      *

h2/src/main/org/h2/mvstore/MVMapConcurrent.java

@@ -34,24 +34,32 @@ public class MVMapConcurrent<K, V> extends MVMap<K, V> {
 
     @SuppressWarnings("unchecked")
     public V put(K key, V value) {
-        checkWrite();
-        V result = get(key);
-        if (value.equals(result)) {
-            return result;
-        }
+        beforeWrite();
+        try {
+            // even if the result is the same, we still update the value
+            // (otherwise compact doesn't work)
+            get(key);
             long writeVersion = store.getCurrentVersion();
             synchronized (this) {
                 Page p = copyOnWrite(root, writeVersion);
                 p = splitRootIfNeeded(p, writeVersion);
-            result = (V) put(p, writeVersion, key, value);
+                V result = (V) put(p, writeVersion, key, value);
                 newRoot(p);
-        }
                 return result;
             }
+        } finally {
+            afterWrite();
+        }
+    }
+
+    void waitUntilWritten(long version) {
+        // no need to wait
+    }
 
     @SuppressWarnings("unchecked")
     public V remove(Object key) {
-        checkWrite();
+        beforeWrite();
+        try {
             V result = get(key);
             if (result == null) {
                 return null;
@@ -63,6 +71,9 @@ public class MVMapConcurrent<K, V> extends MVMap<K, V> {
                 newRoot(p);
             }
             return result;
+        } finally {
+            afterWrite();
+        }
     }
 
     /**

h2/src/main/org/h2/mvstore/Page.java

@@ -267,7 +267,7 @@ public class Page {
      * @return a page with the given version
      */
     public Page copy(long version) {
-        map.getStore().removePage(pos);
+        map.removePage(pos);
         Page newPage = create(map, version,
                 keyCount, keys, values, children, childrenPages,
                 counts, totalCount,
@@ -541,14 +541,14 @@ public class Page {
                     long c = children[i];
                     int type = DataUtils.getPageType(c);
                     if (type == DataUtils.PAGE_TYPE_LEAF) {
-                        map.getStore().removePage(c);
+                        map.removePage(c);
                     } else {
                         map.readPage(c).removeAllRecursive();
                     }
                 }
             }
         }
-        map.getStore().removePage(pos);
+        map.removePage(pos);
     }
 
     /**

h2/src/main/org/h2/mvstore/rtree/MVRTreeMap.java

@@ -150,7 +150,7 @@ public class MVRTreeMap<V> extends MVMap<SpatialKey, V> {
                     result = p.getValue(i);
                     p.remove(i);
                     if (p.getKeyCount() == 0) {
-                        removePage(p);
+                        removePage(p.getPos());
                     }
                     break;
                 }
@@ -170,7 +170,7 @@ public class MVRTreeMap<V> extends MVMap<SpatialKey, V> {
                     // this child was deleted
                     p.remove(i);
                     if (p.getKeyCount() == 0) {
-                        removePage(p);
+                        removePage(p.getPos());
                     }
                     break;
                 }
@@ -211,7 +211,8 @@ public class MVRTreeMap<V> extends MVMap<SpatialKey, V> {
     }
 
     private Object putOrAdd(SpatialKey key, V value, boolean alwaysAdd) {
-        checkWrite();
+        beforeWrite();
+        try {
             long writeVersion = store.getCurrentVersion();
             Page p = copyOnWrite(root, writeVersion);
             Object result;
@@ -239,6 +240,9 @@ public class MVRTreeMap<V> extends MVMap<SpatialKey, V> {
             }
             newRoot(p);
             return result;
+        } finally {
+            afterWrite();
+        }
     }
 
     /**

h2/src/test/org/h2/test/store/TestMVStore.java

@@ -206,7 +206,7 @@ public class TestMVStore extends TestBase {
         s.store();
         s.close();
         int[] expectedReadsForCacheSize = {
-                3412, 2590, 1924, 1440, 1102, 956, 918
+                3407, 2590, 1924, 1440, 1106, 956, 918
         };
         for (int cacheSize = 0; cacheSize <= 6; cacheSize += 4) {
             s = new MVStore.Builder().
@@ -723,17 +723,22 @@ public class TestMVStore extends TestBase {
         m.put("1", "Hello");
         assertEquals(1, s.incrementVersion());
         s.rollbackTo(1);
+        assertEquals(1, s.getCurrentVersion());
         assertEquals("Hello", m.get("1"));
+
         long v2 = s.store();
         assertEquals(2, v2);
         assertEquals(2, s.getCurrentVersion());
         assertFalse(s.hasUnsavedChanges());
+        assertEquals("Hello", m.get("1"));
         s.close();
 
         s = openStore(fileName);
         assertEquals(2, s.getCurrentVersion());
         meta = s.getMetaMap();
         m = s.openMap("data");
+        assertFalse(s.hasUnsavedChanges());
+        assertEquals("Hello", m.get("1"));
         m0 = s.openMap("data0");
         MVMap<String, String> m1 = s.openMap("data1");
         m.put("1", "Hallo");