perobs 3.0.1 → 4.3.0

data/lib/perobs/SpaceTreeNode.rb

@@ -51,43 +51,87 @@ module PEROBS
     # Create a new SpaceTreeNode object. If node_address is not nil, the data
     # will be read from the SpaceTree file at the given node_address.
     # @param tree [SpaceTree] Tree that the object should belong to
-    # @param parent [SpaceTreeNode] Parent node in the tree
     # @param node_address [Integer] Address of the node in the file
     # @param blob_address [Integer] Address of the free space blob
     # @param size [Integer] Size of the free space blob
-    def initialize(tree, parent = nil, node_address = nil, blob_address = 0,
-                   size = 0)
+    # @param parent [SpaceTreeNode] Parent node in the tree
+    # @param smaller [SpaceTreeNode] smaller node in the tree
+    # @param equal [SpaceTreeNode] equal node in the tree
+    # @param larger [SpaceTreeNode] larger node in the tree
+    def initialize(tree, node_address, blob_address = 0, size = 0,
+                   parent = nil, smaller = nil, equal = nil, larger = nil)
       @tree = tree
-      if blob_address < 0
+      if node_address <= 0
         PEROBS.log.fatal "Node address (#{node_address}) must be larger than 0"
       end
+      @node_address = node_address
+      if blob_address < 0
+        PEROBS.log.fatal "Blob address (#{node_address}) must be larger than 0"
+      end
       @blob_address = blob_address
       @size = size
-      @smaller = @equal = @larger = nil
-      @node_address = node_address
+      @parent = parent
+      @smaller = smaller
+      @equal = equal
+      @larger = larger
+    end
 
-      unless node_address.nil? || node_address.is_a?(Integer)
-        PEROBS.log.fatal "node_address is not Integer: #{node_address.class}"
-      end
+    # Create a new SpaceTreeNode. This method should be used for the creation
+    # of new nodes instead of calling the constructor directly.
+    # @param tree [SpaceTree] The tree the node should belong to
+    # @param blob_address [Integer] Address of the free space blob
+    # @param size [Integer] Size of the free space blob
+    # @param parent [SpaceTreeNode] Parent node in the tree
+    def SpaceTreeNode::create(tree, blob_address = 0, size = 0, parent = nil)
+      node_address = tree.nodes.free_address
 
-      if node_address
-        # This must be an existing node. Try to read it and fill the instance
-        # variables.
-        if size != 0
-          PEROBS.log.fatal "If node_address is not nil size must be 0"
-        end
-        if blob_address != 0
-          PEROBS.log.fatal "If node_address is not nil blob_address must be 0"
-        end
-        unless read_node
-          PEROBS.log.fatal "SpaceTree node at address #{node_address} " +
-            "does not exist"
-        end
-      else
-        # This is a new node. Make sure the data is written to the file.
-        @node_address = @tree.nodes.free_address
-        self.parent = parent
+      node = SpaceTreeNode.new(tree, node_address, blob_address, size, parent)
+      tree.cache.insert(node)
+
+      node
+    end
+
+    # Restore a node from the backing store at the given address and tree.
+    # @param tree [SpaceTree] The tree the node belongs to
+    # @param node_address [Integer] The address in the file.
+    def SpaceTreeNode::load(tree, node_address, unused = nil)
+      unless node_address > 0
+        PEROBS.log.fatal "node_address (#{node_address}) must be larger than 0"
       end
+      unless (bytes = tree.nodes.retrieve_blob(node_address))
+        PEROBS.log.fatal "SpaceTreeNode at address #{node_address} does " +
+          "not exist"
+      end
+
+      blob_address, size, parent_node_address,
+        smaller_node_address, equal_node_address,
+        larger_node_address = bytes.unpack(NODE_BYTES_FORMAT)
+
+      parent = parent_node_address != 0 ?
+        SpaceTreeNodeLink.new(tree, parent_node_address) : nil
+      smaller = smaller_node_address != 0 ?
+        SpaceTreeNodeLink.new(tree, smaller_node_address) : nil
+      equal = equal_node_address != 0 ?
+        SpaceTreeNodeLink.new(tree, equal_node_address) : nil
+      larger = larger_node_address != 0 ?
+        SpaceTreeNodeLink.new(tree, larger_node_address) : nil
+
+      node = SpaceTreeNode.new(tree, node_address, blob_address, size,
+                               parent, smaller, equal, larger)
+
+      tree.cache.insert(node, false)
+
+      node
+    end
+
+    # Save the node into the blob file.
+    def save
+      bytes = [ @blob_address, @size,
+                @parent ? @parent.node_address : 0,
+                @smaller ? @smaller.node_address : 0,
+                @equal ? @equal.node_address : 0,
+                @larger ? @larger.node_address : 0].pack(NODE_BYTES_FORMAT)
+      @tree.nodes.store_blob(@node_address, bytes)
     end
 
     # Add a new node for the given address and size to the tree.
@@ -110,7 +154,7 @@ module PEROBS
             # There is no smaller node yet, so we create a new one as a
             # smaller child of the current node.
             node.set_link('@smaller',
-                          @tree.new_node(node, address, size))
+                          SpaceTreeNode::create(@tree, address, size, node))
             break
           end
         elsif size > node.size
@@ -122,13 +166,13 @@ module PEROBS
             # There is no larger node yet, so we create a new one as a larger
             # child of the current node.
             node.set_link('@larger',
-                          @tree.new_node(node, address, size))
+                          SpaceTreeNode::create(@tree, address, size, node))
             break
           end
         else
           # Same size as current node. Insert new node as equal child at top of
           # equal list.
-          new_node = @tree.new_node(node, address, size)
+          new_node = SpaceTreeNode::create(@tree, address, size, node)
           new_node.set_link('@equal', node.equal)
 
           node.set_link('@equal', new_node)
@@ -147,7 +191,7 @@ module PEROBS
       node = self
       loop do
         if node.blob_address == address
-          return true
+          return size == node.size
         elsif size < node.size && node.smaller
           node = node.smaller
         elsif size > node.size && node.larger
@@ -242,7 +286,13 @@ module PEROBS
         PEROBS.log.fatal "Cannot unlink unknown child node with address " +
           "#{child_node.node_address} from #{to_s}"
       end
-      write_node
+      @tree.cache.insert(self)
+    end
+
+    # @return [Integer] The node address since it uniquely identifies the
+    #         Node.
+    def uid
+      @node_address
     end
 
     # Depth-first iterator for all nodes. The iterator yields the given block
@@ -339,7 +389,7 @@ module PEROBS
           @parent.set_link('@larger', node)
         else
           PEROBS.log.fatal "Cannot relink unknown child node with address " +
-            "#{node.node_address} from #{to_s}"
+            "#{node.node_address} from #{parent.to_s}"
         end
       else
         if node
@@ -382,7 +432,7 @@ module PEROBS
     def set_size_and_address(size, address)
       @size = size
       @blob_address = address
-      write_node
+      @tree.cache.insert(self)
     end
 
     def set_link(name, node_or_address)
@@ -398,12 +448,12 @@ module PEROBS
         # Clear the node link.
         instance_variable_set(name, nil)
       end
-      write_node
+      @tree.cache.insert(self)
     end
 
     def parent=(p)
       @parent = p ? SpaceTreeNodeLink.new(@tree, p) : nil
-      write_node
+      @tree.cache.insert(self)
     end
     # Compare this node to another node.
     # @return [Boolean] true if node address is identical, false otherwise
@@ -468,62 +518,65 @@ module PEROBS
     # errors.
     # @param flat_file [FlatFile] If given, check that the space is also
     #        present in the given flat file.
+    # @param count [Integer] The total number of entries in the tree
     # @return [false,true] True if OK, false otherwise
-    def check(flat_file)
+    def check(flat_file, count)
       node_counter = 0
       max_depth = 0
 
-      each do |node, mode, stack|
-        max_depth = stack.size if stack.size > max_depth
-
-        case mode
-        when :smaller
-          if node.smaller
-            return false unless node.check_node_link('smaller', stack)
-            smaller_node = node.smaller
-            if smaller_node.size >= node.size
-              PEROBS.log.error "Smaller SpaceTreeNode size " +
-                "(#{smaller_node}) is not smaller than #{node}"
-              return false
+      @tree.progressmeter.start('Checking space list entries', count) do |pm|
+        each do |node, mode, stack|
+          max_depth = stack.size if stack.size > max_depth
+
+          case mode
+          when :smaller
+            if node.smaller
+              return false unless node.check_node_link('smaller', stack)
+              smaller_node = node.smaller
+              if smaller_node.size >= node.size
+                PEROBS.log.error "Smaller SpaceTreeNode size " +
+                  "(#{smaller_node}) is not smaller than #{node}"
+                return false
+              end
             end
-          end
-        when :equal
-          if node.equal
-            return false unless node.check_node_link('equal', stack)
-            equal_node = node.equal
-
-            if equal_node.smaller || equal_node.larger
-              PEROBS.log.error "Equal node #{equal_node} must not have " +
-                "smaller/larger childs"
-              return false
+          when :equal
+            if node.equal
+              return false unless node.check_node_link('equal', stack)
+              equal_node = node.equal
+
+              if equal_node.smaller || equal_node.larger
+                PEROBS.log.error "Equal node #{equal_node} must not have " +
+                  "smaller/larger childs"
+                return false
+              end
+
+              if node.size != equal_node.size
+                PEROBS.log.error "Equal SpaceTreeNode size (#{equal_node}) " +
+                  "is not equal parent node #{node}"
+                  return false
+              end
             end
-
-            if node.size != equal_node.size
-              PEROBS.log.error "Equal SpaceTreeNode size (#{equal_node}) is " +
-                "not equal parent node #{node}"
-              return false
+          when :larger
+            if node.larger
+              return false unless node.check_node_link('larger', stack)
+              larger_node = node.larger
+              if larger_node.size <= node.size
+                PEROBS.log.error "Larger SpaceTreeNode size " +
+                  "(#{larger_node}) is not larger than #{node}"
+                return false
+              end
             end
-          end
-        when :larger
-          if node.larger
-            return false unless node.check_node_link('larger', stack)
-            larger_node = node.larger
-            if larger_node.size <= node.size
-              PEROBS.log.error "Larger SpaceTreeNode size " +
-                "(#{larger_node}) is not larger than #{node}"
+          when :on_exit
+            if flat_file &&
+              !flat_file.has_space?(node.blob_address, node.size)
+              PEROBS.log.error "SpaceTreeNode has space at offset " +
+                "#{node.blob_address} of size #{node.size} that isn't " +
+                "available in the FlatFile."
               return false
             end
-          end
-        when :on_exit
-          if flat_file &&
-             !flat_file.has_space?(node.blob_address, node.size)
-            PEROBS.log.error "SpaceTreeNode has space at offset " +
-              "#{node.blob_address} of size #{node.size} that isn't " +
-              "available in the FlatFile."
-            return false
-          end
 
-          node_counter += 1
+            pm.update(node_counter += 1)
+          end
         end
       end
       PEROBS.log.debug "#{node_counter} SpaceTree nodes checked"
@@ -633,40 +686,6 @@ module PEROBS
       str
     end
 
-    private
-
-    def write_node
-      bytes = [ @blob_address, @size,
-                @parent ? @parent.node_address : 0,
-                @smaller ? @smaller.node_address : 0,
-                @equal ? @equal.node_address : 0,
-                @larger ? @larger.node_address : 0].pack(NODE_BYTES_FORMAT)
-      @tree.nodes.store_blob(@node_address, bytes)
-    end
-
-    def read_node
-      unless @node_address > 0
-        PEROBS.log.fatal "@node_address must be larger than 0"
-      end
-      return false unless (bytes = @tree.nodes.retrieve_blob(@node_address))
-
-      @blob_address, @size, parent_node_address,
-        smaller_node_address, equal_node_address,
-        larger_node_address = bytes.unpack(NODE_BYTES_FORMAT)
-      # The parent address can also be 0 as the parent can rightly point back
-      # to the root node which always has the address 0.
-      @parent = parent_node_address != 0 ?
-        SpaceTreeNodeLink.new(@tree, parent_node_address) : nil
-      @smaller = smaller_node_address != 0 ?
-        SpaceTreeNodeLink.new(@tree, smaller_node_address) : nil
-      @equal = equal_node_address != 0 ?
-        SpaceTreeNodeLink.new(@tree, equal_node_address) : nil
-      @larger = larger_node_address != 0 ?
-        SpaceTreeNodeLink.new(@tree, larger_node_address) : nil
-
-      true
-    end
-
   end
 
 end

data/lib/perobs/SpaceTreeNodeLink.rb

@@ -94,7 +94,7 @@ module PEROBS
     private
 
     def get_node
-      @tree.get_node(@node_address)
+      @tree.cache.get(@node_address)
     end
 
   end

data/lib/perobs/StackFile.rb

@@ -36,7 +36,7 @@ module PEROBS
     # Create a new stack file in the given directory with the given file name.
     # @param dir [String] Directory
     # @param name [String] File name
-    # @param entry_bytes [Fixnum] Number of bytes each entry must have
+    # @param entry_bytes [Integer] Number of bytes each entry must have
     def initialize(dir, name, entry_bytes)
       @file_name = File.join(dir, name + '.stack')
       @entry_bytes = entry_bytes

data/lib/perobs/Store.rb

@@ -2,7 +2,8 @@
 #
 # = Store.rb -- Persistent Ruby Object Store
 #
-# Copyright (c) 2015, 2016 by Chris Schlaeger <chris@taskjuggler.org>
+# Copyright (c) 2015, 2016, 2017, 2018, 2019
+# by Chris Schlaeger <chris@taskjuggler.org>
 #
 # MIT License
 #
@@ -26,7 +27,6 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 require 'set'
-require 'weakref'
 
 require 'perobs/Log'
 require 'perobs/Handle'
@@ -37,12 +37,18 @@ require 'perobs/FlatFileDB'
 require 'perobs/Object'
 require 'perobs/Hash'
 require 'perobs/Array'
+require 'perobs/BigTree'
+require 'perobs/BigHash'
+require 'perobs/BigArray'
+require 'perobs/ProgressMeter'
+require 'perobs/ConsoleProgressMeter'
 
 # PErsistent Ruby OBject Store
 module PEROBS
 
-  Statistics = Struct.new(:in_memory_objects, :root_objects,
-                          :marked_objects, :swept_objects)
+  Statistics = Struct.new(:in_memory_objects, :root_objects, :zombie_objects,
+                          :marked_objects, :swept_objects,
+                          :created_objects, :collected_objects)
 
   # PEROBS::Store is a persistent storage system for Ruby objects. Regular
   # Ruby objects are transparently stored in a back-end storage and retrieved
@@ -68,12 +74,20 @@ module PEROBS
   #
   # class Person < PEROBS::Object
   #
-  #   po_attr :name, :mother, :father, :kids
+  #   attr_persist :name, :mother, :father, :kids
   #
+  #   # The contructor is only called for the creation of a new object. It is
+  #   # not called when the object is restored from the database. In that case
+  #   # only restore() is called.
   #   def initialize(cf, name)
   #     super(cf)
-  #     attr_init(:name, name)
-  #     attr_init(:kids, @store.new(PEROBS::Array))
+  #     self.name = name
+  #     self.kids = @store.new(PEROBS::Array)
+  #   end
+  #
+  #   def restore
+  #     # In case you need to do any checks or massaging (e. g. for additional
+  #     # attributes) you can provide this method.
   #   end
   #
   #   def to_s
@@ -91,11 +105,12 @@ module PEROBS
   # joe.kids << jim
   # jim.mother = jane
   # jane.kids << jim
-  # store.sync
+  # store.exit
   #
   class Store
 
     attr_reader :db, :cache, :class_map
+    attr_writer :root_objects
 
     # Create a new Store.
     # @param data_base [String] the name of the database
@@ -120,14 +135,23 @@ module PEROBS
     #                      :json : About half as fast as marshal, but the
     #                      format is rock solid and portable between
     #                      languages. It only supports basic Ruby data types
-    #                      like String, Fixnum, Float, Array, Hash. This is
+    #                      like String, Integer, Float, Array, Hash. This is
     #                      the default option.
     #                      :yaml : Can also handle most Ruby data types and is
     #                      portable between Ruby versions (1.9 and later).
     #                      Unfortunately, it is 10x slower than marshal.
+    #     :progressmeter : reference to a ProgressMeter object that receives
+    #                      progress information during longer running tasks.
+    #                      It defaults to ProgressMeter which only logs into
+    #                      the log. Use ConsoleProgressMeter or a derived
+    #                      class for more fancy progress reporting.
+    #   :no_root_objects : Create a new store without root objects. This only
+    #                      makes sense if you want to copy the objects of
+    #                      another store into this store.
     def initialize(data_base, options = {})
       # Create a backing store handler
-      @db = (options[:engine] || BTreeDB).new(data_base, options)
+      @progressmeter = (options[:progressmeter] ||= ProgressMeter.new)
+      @db = (options[:engine] || FlatFileDB).new(data_base, options)
       @db.open
       # Create a map that can translate classes to numerical IDs and vice
       # versa.
@@ -136,25 +160,32 @@ module PEROBS
       # List of PEROBS objects that are currently available as Ruby objects
       # hashed by their ID.
       @in_memory_objects = {}
+      # List of objects that were destroyed already but were still found in
+      # the in_memory_objects list. _collect has not yet been called for them.
+      @zombie_objects = {}
 
       # This objects keeps some counters of interest.
       @stats = Statistics.new
+      @stats[:created_objects] = 0
+      @stats[:collected_objects] = 0
 
       # The Cache reduces read and write latencies by keeping a subset of the
       # objects in memory.
       @cache = Cache.new(options[:cache_bits] || 16)
 
       # The named (global) objects IDs hashed by their name
-      unless (@root_objects = object_by_id(0))
-        PEROBS.log.debug "Initializing the PEROBS store"
-        # The root object hash always has the object ID 0.
-        @root_objects = _construct_po(Hash, 0)
-        # Mark the root_objects object as modified.
-        @cache.cache_write(@root_objects)
-      end
-      unless @root_objects.is_a?(Hash)
-        PEROBS.log.fatal "Database corrupted: Root objects must be a Hash " +
-          "but is a #{@root_objects.class}"
+      unless options[:no_root_objects]
+        unless (@root_objects = object_by_id(0))
+          PEROBS.log.debug "Initializing the PEROBS store"
+          # The root object hash always has the object ID 0.
+          @root_objects = _construct_po(Hash, 0)
+          # Mark the root_objects object as modified.
+          @cache.cache_write(@root_objects)
+        end
+        unless @root_objects.is_a?(Hash)
+          PEROBS.log.fatal "Database corrupted: Root objects must be a Hash " +
+            "but is a #{@root_objects.class}"
+        end
       end
     end
 
@@ -166,7 +197,9 @@ module PEROBS
       sync
 
       # Create a new store with the specified directory and options.
-      new_db = Store.new(dir, options)
+      new_options = options.clone
+      new_options[:no_root_objects] = true
+      new_db = Store.new(dir, new_options)
       # Clear the cache.
       new_db.sync
       # Copy all objects of the existing store to the new store.
@@ -177,6 +210,7 @@ module PEROBS
         obj._sync
         i += 1
       end
+      new_db.root_objects = new_db.object_by_id(0)
       PEROBS.log.debug "Copied #{i} objects into new database at #{dir}"
       # Flush the new store and close it.
       new_db.exit
@@ -184,20 +218,34 @@ module PEROBS
       true
     end
 
-
     # Close the store and ensure that all in-memory objects are written out to
     # the storage backend. The Store object is no longer usable after this
     # method was called.
     def exit
       if @cache && @cache.in_transaction?
-        PEROBS.log.fatal 'You cannot call exit() during a transaction'
+        @cache.abort_transaction
+        @cache.flush
+        @db.close if @db
+        PEROBS.log.fatal "You cannot call exit() during a transaction: #{Kernel.caller}"
       end
       @cache.flush if @cache
       @db.close if @db
-      @db = @class_map = @in_memory_objects = @stats = @cache = @root_objects =
-        nil
-    end
 
+      GC.start
+      if @stats
+        unless @stats[:created_objects] == @stats[:collected_objects] +
+            @in_memory_objects.length
+          PEROGS.log.fatal "Created objects count " +
+            "(#{@stats[:created_objects]})" +
+            " is not equal to the collected count " +
+            "(#{@stats[:collected_objects]}) + in_memory_objects count " +
+            "(#{@in_memory_objects.length})"
+        end
+      end
+
+      @db = @class_map = @in_memory_objects = @zombie_objects =
+        @stats = @cache = @root_objects = nil
+    end
 
     # You need to call this method to create new PEROBS objects that belong to
     # this Store.
@@ -221,7 +269,7 @@ module PEROBS
     # For library internal use only!
     # This method will create a new PEROBS object.
     # @param klass [BasicObject] Class of the object to create
-    # @param id [Fixnum, Bignum] Requested object ID
+    # @param id [Integer] Requested object ID
     # @param args [Array] Arguments to pass to the object constructor.
     # @return [BasicObject] Newly constructed PEROBS object
     def _construct_po(klass, id, *args)
@@ -229,10 +277,12 @@ module PEROBS
     end
 
     # Delete the entire store. The store is no longer usable after this
-    # method was called.
+    # method was called. This is an alternative to exit() that additionaly
+    # deletes the entire database.
     def delete_store
       @db.delete_database
-      @db = @class_map = @cache = @root_objects = nil
+      @db = @class_map = @in_memory_objects = @zombie_objects =
+        @stats = @cache = @root_objects = nil
     end
 
     # Store the provided object under the given name. Use this to make the
@@ -288,20 +338,30 @@ module PEROBS
     # needed.
     def sync
       if @cache.in_transaction?
-        PEROBS.log.fatal 'You cannot call sync() during a transaction'
+        @cache.abort_transaction
+        @cache.flush
+        PEROBS.log.fatal "You cannot call sync() during a transaction: \n" +
+          Kernel.caller.join("\n")
       end
       @cache.flush
     end
 
+    # Return the number of object stored in the store. CAVEAT: This method
+    # will only return correct values when it is separated from any mutating
+    # call by a call to sync().
+    # @return [Integer] Number of persistently stored objects in the Store.
+    def size
+      # We don't include the Hash that stores the root objects into the object
+      # count.
+      @db.item_counter - 1
+    end
+
     # Discard all objects that are not somehow connected to the root objects
     # from the back-end storage. The garbage collector is not invoked
     # automatically. Depending on your usage pattern, you need to call this
     # method periodically.
-    # @return [Fixnum] The number of collected objects
+    # @return [Integer] The number of collected objects
     def gc
-      if @cache.in_transaction?
-        PEROBS.log.fatal 'You cannot call gc() during a transaction'
-      end
       sync
       mark
       sweep
@@ -311,17 +371,30 @@ module PEROBS
     # public API and should never be called by outside users. It's purely
     # intended for internal use.
     def object_by_id(id)
-      if (obj = @in_memory_objects[id])
+      if (ruby_object_id = @in_memory_objects[id])
         # We have the object in memory so we can just return it.
         begin
-          return obj.__getobj__
-        rescue WeakRef::RefError
+          object = ObjectSpace._id2ref(ruby_object_id)
+          # Let's make sure the object is really the object we are looking
+          # for. The GC might have recycled it already and the Ruby object ID
+          # could now be used for another object.
+          if object.is_a?(ObjectBase) && object._id == id
+            return object
+          end
+        rescue RangeError => e
           # Due to a race condition the object can still be in the
           # @in_memory_objects list but has been collected already by the Ruby
-          # GC. In that case we need to load it again.
+          # GC. In that case we need to load it again. The _collect() call
+          # will happen much later, potentially after we have registered a new
+          # object with the same ID.
+          @zombie_objects[id] = @in_memory_objects.delete(id)
         end
       end
 
+      if (obj = @cache.object_by_id(id))
+        PEROBS.log.fatal "Object #{id} with Ruby #{obj.object_id} is in cache but not in_memory"
+      end
+
       # We don't have the object in memory. Let's find it in the storage.
       if @db.include?(id)
         # Great, object found. Read it into memory and return it.
@@ -342,40 +415,44 @@ module PEROBS
     # unreadable object is found, the reference will simply be deleted.
     # @param repair [TrueClass/FalseClass] true if a repair attempt should be
     #        made.
-    # @return [Fixnum] The number of references to bad objects found.
+    # @return [Integer] The number of references to bad objects found.
     def check(repair = false)
+      stats = { :errors => 0, :object_cnt => 0 }
+
       # All objects must have in-db version.
       sync
       # Run basic consistency checks first.
-      errors = @db.check_db(repair)
+      stats[:errors] += @db.check_db(repair)
 
       # We will use the mark to mark all objects that we have checked already.
       # Before we start, we need to clear all marks.
       @db.clear_marks
 
-      objects = 0
-      @root_objects.each do |name, id|
-        objects += 1
-        errors += check_object(id, repair)
+      @progressmeter.start("Checking object link structure",
+                           @db.item_counter) do
+        @root_objects.each do |name, id|
+          check_object(id, repair, stats)
+        end
       end
 
       # Delete all broken root objects.
       if repair
         @root_objects.delete_if do |name, id|
-          unless (res = @db.check(id, repair))
+          unless @db.check(id, repair)
             PEROBS.log.error "Discarding broken root object '#{name}' " +
               "with ID #{id}"
-            errors += 1
+            stats[:errors] += 1
           end
-          !res
         end
       end
 
-      if errors > 0
+      if stats[:errors] > 0
         if repair
-          PEROBS.log.error "#{errors} errors found in #{objects} objects"
+          PEROBS.log.error "#{stats[:errors]} errors found in " +
+            "#{stats[:object_cnt]} objects"
         else
-          PEROBS.log.fatal "#{errors} errors found in #{objects} objects"
+          PEROBS.log.fatal "#{stats[:errors]} errors found in " +
+            "#{stats[:object_cnt]} objects"
         end
       else
         PEROBS.log.debug "No errors found"
@@ -384,7 +461,7 @@ module PEROBS
       # Ensure that any fixes are written into the DB.
       sync if repair
 
-      errors
+      stats[:errors]
     end
 
     # This method will execute the provided block as an atomic transaction
@@ -413,7 +490,10 @@ module PEROBS
       stack = [ 0 ] + @root_objects.values
       while !stack.empty?
         # Get an object index from the stack.
-        unless (obj = object_by_id(id = stack.pop))
+        id = stack.pop
+        next if @db.is_marked?(id)
+
+        unless (obj = object_by_id(id))
           PEROBS.log.fatal "Database is corrupted. Object with ID #{id} " +
             "not found."
         end
@@ -436,7 +516,7 @@ module PEROBS
     # Internal method. Don't use this outside of this library!
     # Generate a new unique ID that is not used by any other object. It uses
     # random numbers between 0 and 2**64 - 1.
-    # @return [Fixnum or Bignum]
+    # @return [Integer]
     def _new_id
       begin
         # Generate a random number. It's recommended to not store more than
@@ -454,23 +534,39 @@ module PEROBS
     # happens the object finalizer is triggered and calls _forget() to
     # remove the object from this hash again.
     # @param obj [BasicObject] Object to register
-    # @param id [Fixnum or Bignum] object ID
+    # @param id [Integer] object ID
     def _register_in_memory(obj, id)
-      @in_memory_objects[id] = WeakRef.new(obj)
+      unless obj.is_a?(ObjectBase)
+        PEROBS.log.fatal "You can only register ObjectBase objects"
+      end
+      if @in_memory_objects.include?(id)
+        PEROBS.log.fatal "The Store::_in_memory_objects list already " +
+          "contains an object for ID #{id}"
+      end
+
+      @in_memory_objects[id] = obj.object_id
+      @stats[:created_objects] += 1
     end
 
     # Remove the object from the in-memory list. This is an internal method
     # and should never be called from user code. It will be called from a
     # finalizer, so many restrictions apply!
-    # @param id [Fixnum or Bignum] Object ID of object to remove from the list
-    def _collect(id, ignore_errors = false)
-      @in_memory_objects.delete(id)
+    # @param id [Integer] Object ID of object to remove from the list
+    def _collect(id, ruby_object_id)
+      if @in_memory_objects[id] == ruby_object_id
+        @in_memory_objects.delete(id)
+        @stats[:collected_objects] += 1
+      elsif @zombie_objects[id] == ruby_object_id
+        @zombie_objects.delete(id)
+        @stats[:collected_objects] += 1
+      end
     end
 
     # This method returns a Hash with some statistics about this store.
     def statistics
       @stats.in_memory_objects = @in_memory_objects.length
       @stats.root_objects = @root_objects.length
+      @stats.zombie_objects = @zombie_objects.length
 
       @stats
     end
@@ -482,32 +578,40 @@ module PEROBS
     def mark
       classes = Set.new
       marked_objects = 0
-      each { |obj| classes.add(obj.class); marked_objects += 1 }
+      @progressmeter.start("Marking linked objects", @db.item_counter) do
+        each do |obj|
+          classes.add(obj.class)
+          @progressmeter.update(marked_objects += 1)
+        end
+      end
       @class_map.keep(classes.map { |c| c.to_s })
 
       # The root_objects object is included in the count, but we only want to
       # count user objects here.
-      PEROBS.log.debug "#{marked_objects - 1} objects marked"
+      PEROBS.log.debug "#{marked_objects - 1} of #{@db.item_counter} " +
+        "objects marked"
       @stats.marked_objects = marked_objects - 1
     end
 
     # Sweep phase of a mark-and-sweep garbage collector. It will remove all
     # unmarked objects from the store.
     def sweep
-      @stats.swept_objects = @db.delete_unmarked_objects.length
-      @cache.reset
+      @stats.swept_objects = @db.delete_unmarked_objects do |id|
+        @cache.evict(id)
+      end
+      @db.clear_marks
+      GC.start
       PEROBS.log.debug "#{@stats.swept_objects} objects collected"
       @stats.swept_objects
     end
 
     # Check the object with the given start_id and all other objects that are
     # somehow reachable from the start object.
-    # @param start_id [Fixnum or Bignum] ID of the top-level object to start
+    # @param start_id [Integer] ID of the top-level object to start
     #        with
     # @param repair [Boolean] Delete refernces to broken objects if true
-    # @return [Fixnum] The number of references to bad objects.
-    def check_object(start_id, repair)
-      errors = 0
+    # @return [Integer] The number of references to bad objects.
+    def check_object(start_id, repair, stats)
       @db.mark(start_id)
       # The todo list holds a touple for each object that still needs to be
       # checked. The first item is the referring object and the second is the
@@ -518,7 +622,13 @@ module PEROBS
         # Get the next PEROBS object to check
         ref_obj, id = todo_list.pop
 
-        if (obj = object_by_id(id)) && (obj_ok = @db.check(id, repair))
+        begin
+          obj = object_by_id(id)
+        rescue PEROBS::FatalError
+          obj = nil
+        end
+
+        if obj
           # The object exists and is OK. Mark is as checked.
           @db.mark(id)
           # Now look at all other objects referenced by this object.
@@ -541,11 +651,11 @@ module PEROBS
                 ref_obj.inspect
             end
           end
-          errors += 1
+          stats[:errors] += 1
         end
-      end
 
-      errors
+        @progressmeter.update(stats[:object_cnt] += 1)
+      end
     end
 
   end