Merge pull request #1035 from h2database/free_space_bs

Minor free space accointing changes

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

@@ -54,12 +54,12 @@ public class FileStore {
     /**
      * The file name.
      */
-    protected String fileName;
+    private String fileName;
 
     /**
      * Whether this store is read-only.
      */
-    protected boolean readOnly;
+    private boolean readOnly;
 
     /**
      * The file size (cached).
@@ -69,17 +69,17 @@ public class FileStore {
     /**
      * The file.
      */
-    protected FileChannel file;
+    private FileChannel file;
 
     /**
      * The encrypted file (if encryption is used).
      */
-    protected FileChannel encryptedFile;
+    private FileChannel encryptedFile;
 
     /**
      * The file lock.
      */
-    protected FileLock fileLock;
+    private FileLock fileLock;
 
     @Override
     public String toString() {
@@ -337,6 +337,16 @@ public class FileStore {
         return freeSpace.allocate(length);
     }
 
+    /**
+     * Calculate starting position of the prospective allocation.
+     *
+     * @param length the number of bytes to allocate
+     * @return the start position in bytes
+     */
+    public long predictAllocation(int length) {
+        return freeSpace.predictAllocation(length);
+    }
+
     /**
      * Mark the space as free.
      *

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

@@ -94,12 +94,30 @@ public class FreeSpaceBitSet {
      * @return the start position in bytes
      */
     public long allocate(int length) {
+        return allocate(length, true);
+    }
+
+    /**
+     * Calculate starting position of the prospective allocation.
+     *
+     * @param length the number of bytes to allocate
+     * @return the start position in bytes
+     */
+    public long predictAllocation(int length) {
+        return allocate(length, false);
+    }
+
+    private long allocate(int length, boolean allocate) {
         int blocks = getBlockCount(length);
         for (int i = 0;;) {
             int start = set.nextClearBit(i);
             int end = set.nextSetBit(start + 1);
             if (end < 0 || end - start >= blocks) {
-                set.set(start, start + blocks);
+                assert set.nextSetBit(start) == -1 || set.nextSetBit(start) >= start + blocks :
+                        "Double alloc: " + Integer.toHexString(start) + "/" + Integer.toHexString(blocks) + " " + this;
+                if (allocate) {
+                    set.set(start, start + blocks);
+                }
                 return getPos(start);
             }
             i = end;
@@ -115,6 +133,8 @@ public class FreeSpaceBitSet {
     public void markUsed(long pos, int length) {
         int start = getBlock(pos);
         int blocks = getBlockCount(length);
+        assert set.nextSetBit(start) == -1 || set.nextSetBit(start) >= start + blocks :
+                "Double mark: " + Integer.toHexString(start) + "/" + Integer.toHexString(blocks) + " " + this;
         set.set(start, start + blocks);
     }
 
@@ -127,6 +147,8 @@ public class FreeSpaceBitSet {
     public void free(long pos, int length) {
         int start = getBlock(pos);
         int blocks = getBlockCount(length);
+        assert set.nextClearBit(start) >= start + blocks :
+                "Double free: " + Integer.toHexString(start) + "/" + Integer.toHexString(blocks) + " " + this;
         set.clear(start, start + blocks);
     }
 
@@ -149,16 +171,11 @@ public class FreeSpaceBitSet {
      * @return the fill rate (0 - 100)
      */
     public int getFillRate() {
-        int total = set.length(), count = 0;
-        for (int i = 0; i < total; i++) {
-            if (set.get(i)) {
-                count++;
-            }
-        }
-        if (count == 0) {
+        int cardinality = set.cardinality();
+        if (cardinality == 0) {
             return 0;
         }
-        return Math.max(1, (int) (100L * count / total));
+        return Math.max(1, (int)(100L * cardinality / set.length()));
     }
 
     /**

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

@@ -662,10 +662,8 @@ public final class MVStore {
         }
         setLastChunk(newest);
         loadChunkMeta();
-        // read all chunk headers and footers within the retention time,
-        // to detect unwritten data after a power failure
-        verifyLastChunks();
         // build the free space list
+        fileStore.clear();
         for (Chunk c : chunks.values()) {
             if (c.pageCountLive == 0) {
                 // remove this chunk in the next save operation
@@ -675,6 +673,11 @@ public final class MVStore {
             int length = c.len * BLOCK_SIZE;
             fileStore.markUsed(start, length);
         }
+        assert fileStore.getFileLengthInUse() == measureFileLengthInUse() :
+                fileStore.getFileLengthInUse() + " != " + measureFileLengthInUse();
+        // read all chunk headers and footers within the retention time,
+        // to detect unwritten data after a power failure
+        verifyLastChunks();
     }
 
     private void loadChunkMeta() {
@@ -1143,14 +1146,12 @@ public final class MVStore {
 
         c.block = filePos / BLOCK_SIZE;
         c.len = length / BLOCK_SIZE;
+        assert fileStore.getFileLengthInUse() == measureFileLengthInUse() :
+                fileStore.getFileLengthInUse() + " != " + measureFileLengthInUse() + " " + c;
         c.metaRootPos = metaRoot.getPos();
         // calculate and set the likely next position
         if (reuseSpace) {
-            int predictBlocks = c.len;
-            long predictedNextStart = fileStore.allocate(
-                    predictBlocks * BLOCK_SIZE);
-            fileStore.free(predictedNextStart, predictBlocks * BLOCK_SIZE);
-            c.next = predictedNextStart / BLOCK_SIZE;
+            c.next = fileStore.predictAllocation(c.len * BLOCK_SIZE) / BLOCK_SIZE;
         } else {
             // just after this chunk
             c.next = 0;
@@ -1257,6 +1258,8 @@ public final class MVStore {
                     long start = c.block * BLOCK_SIZE;
                     int length = c.len * BLOCK_SIZE;
                     fileStore.free(start, length);
+                    assert fileStore.getFileLengthInUse() == measureFileLengthInUse() :
+                            fileStore.getFileLengthInUse() + " != " + measureFileLengthInUse();
                 } else {
                     if (c.unused == 0) {
                         c.unused = time;
@@ -2304,6 +2307,8 @@ public final class MVStore {
                 long start = c.block * BLOCK_SIZE;
                 int length = c.len * BLOCK_SIZE;
                 fileStore.free(start, length);
+                assert fileStore.getFileLengthInUse() == measureFileLengthInUse() :
+                        fileStore.getFileLengthInUse() + " != " + measureFileLengthInUse();
                 // overwrite the chunk,
                 // so it is not be used later on
                 WriteBuffer buff = getWriteBuffer();