← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/btree_index.py

  • Committer: Andrew Bennetts
  • Date: 2009-10-13 05:20:50 UTC
  • mfrom: (4634.52.16 2.0)
  • mto: This revision was merged to the branch mainline in revision 4738.
  • Revision ID: andrew.bennetts@canonical.com-20091013052050-u1w6tv0z7kqhn8d0
Merge 2.0 into lp:bzr, resolving conflicts in NEWS and releasing.txt.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/btree_index.py
636
636
    memory except when very large walks are done.
637
637
    """
638
638
 
639
 
    def __init__(self, transport, name, size):
 
639
    def __init__(self, transport, name, size, unlimited_cache=False):
640
640
        """Create a B+Tree index object on the index name.
641
641
 
642
642
        :param transport: The transport to read data for the index from.
646
646
            the initial read (to read the root node header) can be done
647
647
            without over-reading even on empty indices, and on small indices
648
648
            allows single-IO to read the entire index.
 
649
        :param unlimited_cache: If set to True, then instead of using an
 
650
            LRUCache with size _NODE_CACHE_SIZE, we will use a dict and always
 
651
            cache all leaf nodes.
649
652
        """
650
653
        self._transport = transport
651
654
        self._name = name
655
658
        self._root_node = None
656
659
        # Default max size is 100,000 leave values
657
660
        self._leaf_value_cache = None # lru_cache.LRUCache(100*1000)
658
 
        self._leaf_node_cache = lru_cache.LRUCache(_NODE_CACHE_SIZE)
659
 
        # We could limit this, but even a 300k record btree has only 3k leaf
660
 
        # nodes, and only 20 internal nodes. So the default of 100 nodes in an
661
 
        # LRU would mean we always cache everything anyway, no need to pay the
662
 
        # overhead of LRU
663
 
        self._internal_node_cache = fifo_cache.FIFOCache(100)
 
661
        if unlimited_cache:
 
662
            self._leaf_node_cache = {}
 
663
            self._internal_node_cache = {}
 
664
        else:
 
665
            self._leaf_node_cache = lru_cache.LRUCache(_NODE_CACHE_SIZE)
 
666
            # We use a FIFO here just to prevent possible blowout. However, a
 
667
            # 300k record btree has only 3k leaf nodes, and only 20 internal
 
668
            # nodes. A value of 100 scales to ~100*100*100 = 1M records.
 
669
            self._internal_node_cache = fifo_cache.FIFOCache(100)
664
670
        self._key_count = None
665
671
        self._row_lengths = None
666
672
        self._row_offsets = None # Start of each row, [-1] is the end
698
704
                if start_of_leaves is None:
699
705
                    start_of_leaves = self._row_offsets[-2]
700
706
                if node_pos < start_of_leaves:
701
 
                    self._internal_node_cache.add(node_pos, node)
 
707
                    self._internal_node_cache[node_pos] = node
702
708
                else:
703
 
                    self._leaf_node_cache.add(node_pos, node)
 
709
                    self._leaf_node_cache[node_pos] = node
704
710
            found[node_pos] = node
705
711
        return found
706
712