refs/iterator: implement seeking for ref-cache iterators

Implement seeking of ref-cache iterators. This is done by splitting most
of the logic to seek iterators out of `cache_ref_iterator_begin()` and
putting it into `cache_ref_iterator_seek()` so that we can reuse the
logic.

Note that we cannot use the optimization anymore where we return an
empty ref iterator when there aren't any references, as otherwise it
wouldn't be possible to reseek the iterator to a different prefix that
may exist. This shouldn't be much of a performance concern though as we
now start to bail out early in case `advance()` sees that there are no
more directories to be searched.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/refs/ref-cache.c b/refs/ref-cache.c
index 6457e02c1eaeea77ed3eadd39c0acbbd18813b94..c1f1bab1d502dc16356ef1b9add51d35b4e022fa 100644 (file)
--- a/refs/ref-cache.c
+++ b/refs/ref-cache.c
@@ -362,9 +362,7 @@ struct cache_ref_iterator {
        struct ref_iterator base;
 
        /*
-        * The number of levels currently on the stack. This is always
-        * at least 1, because when it becomes zero the iteration is
-        * ended and this struct is freed.
+        * The number of levels currently on the stack.
         */
        size_t levels_nr;
 
@@ -376,7 +374,7 @@ struct cache_ref_iterator {
         * The prefix is matched textually, without regard for path
         * component boundaries.
         */
-       const char *prefix;
+       char *prefix;
 
        /*
         * A stack of levels. levels[0] is the uppermost level that is
@@ -389,6 +387,9 @@ struct cache_ref_iterator {
        struct cache_ref_iterator_level *levels;
 
        struct repository *repo;
+       struct ref_cache *cache;
+
+       int prime_dir;
 };
 
 static int cache_ref_iterator_advance(struct ref_iterator *ref_iterator)
@@ -396,6 +397,9 @@ static int cache_ref_iterator_advance(struct ref_iterator *ref_iterator)
        struct cache_ref_iterator *iter =
                (struct cache_ref_iterator *)ref_iterator;
 
+       if (!iter->levels_nr)
+               return ITER_DONE;
+
        while (1) {
                struct cache_ref_iterator_level *level =
                        &iter->levels[iter->levels_nr - 1];
@@ -444,6 +448,41 @@ static int cache_ref_iterator_advance(struct ref_iterator *ref_iterator)
        }
 }
 
+static int cache_ref_iterator_seek(struct ref_iterator *ref_iterator,
+                                  const char *prefix)
+{
+       struct cache_ref_iterator *iter =
+               (struct cache_ref_iterator *)ref_iterator;
+       struct cache_ref_iterator_level *level;
+       struct ref_dir *dir;
+
+       dir = get_ref_dir(iter->cache->root);
+       if (prefix && *prefix)
+               dir = find_containing_dir(dir, prefix);
+       if (!dir) {
+               iter->levels_nr = 0;
+               return 0;
+       }
+
+       if (iter->prime_dir)
+               prime_ref_dir(dir, prefix);
+       iter->levels_nr = 1;
+       level = &iter->levels[0];
+       level->index = -1;
+       level->dir = dir;
+
+       if (prefix && *prefix) {
+               free(iter->prefix);
+               iter->prefix = xstrdup(prefix);
+               level->prefix_state = PREFIX_WITHIN_DIR;
+       } else {
+               FREE_AND_NULL(iter->prefix);
+               level->prefix_state = PREFIX_CONTAINS_DIR;
+       }
+
+       return 0;
+}
+
 static int cache_ref_iterator_peel(struct ref_iterator *ref_iterator,
                                   struct object_id *peeled)
 {
@@ -456,12 +495,13 @@ static void cache_ref_iterator_release(struct ref_iterator *ref_iterator)
 {
        struct cache_ref_iterator *iter =
                (struct cache_ref_iterator *)ref_iterator;
-       free((char *)iter->prefix);
+       free(iter->prefix);
        free(iter->levels);
 }
 
 static struct ref_iterator_vtable cache_ref_iterator_vtable = {
        .advance = cache_ref_iterator_advance,
+       .seek = cache_ref_iterator_seek,
        .peel = cache_ref_iterator_peel,
        .release = cache_ref_iterator_release,
 };
@@ -471,39 +511,22 @@ struct ref_iterator *cache_ref_iterator_begin(struct ref_cache *cache,
                                              struct repository *repo,
                                              int prime_dir)
 {
-       struct ref_dir *dir;
        struct cache_ref_iterator *iter;
        struct ref_iterator *ref_iterator;
-       struct cache_ref_iterator_level *level;
-
-       dir = get_ref_dir(cache->root);
-       if (prefix && *prefix)
-               dir = find_containing_dir(dir, prefix);
-       if (!dir)
-               /* There's nothing to iterate over. */
-               return empty_ref_iterator_begin();
-
-       if (prime_dir)
-               prime_ref_dir(dir, prefix);
 
        CALLOC_ARRAY(iter, 1);
        ref_iterator = &iter->base;
        base_ref_iterator_init(ref_iterator, &cache_ref_iterator_vtable);
        ALLOC_GROW(iter->levels, 10, iter->levels_alloc);
 
-       iter->levels_nr = 1;
-       level = &iter->levels[0];
-       level->index = -1;
-       level->dir = dir;
+       iter->repo = repo;
+       iter->cache = cache;
+       iter->prime_dir = prime_dir;
 
-       if (prefix && *prefix) {
-               iter->prefix = xstrdup(prefix);
-               level->prefix_state = PREFIX_WITHIN_DIR;
-       } else {
-               level->prefix_state = PREFIX_CONTAINS_DIR;
+       if (cache_ref_iterator_seek(&iter->base, prefix) < 0) {
+               ref_iterator_free(&iter->base);
+               return NULL;
        }
 
-       iter->repo = repo;
-
        return ref_iterator;
 }