refs: expose peeled object ID via the iterator

Both the "files" and "reftable" backend are able to store peeled values
for tags in the respective formats. This allows for a more efficient
lookup of the target object of such a tag without having to manually
peel via the object database.

The infrastructure to access these peeled object IDs is somewhat funky
though. When iterating through objects, we store a pointer reference to
the current iterator in a global variable. The callbacks invoked by that
iterator are then expected to call `peel_iterated_oid()`, which checks
whether the globally-stored iterator's current reference refers to the
one handed into that function. If so, we ask the iterator to peel the
object, otherwise we manually peel the object via the object database.
Depending on global state like this is somewhat weird and also quite
fragile.

Introduce a new `struct reference::peeled_oid` field that can be
populated by the reference backends. This field can be accessed via a
new function `reference_get_peeled_oid()` that either uses that value,
if set, or alternatively peels via the ODB. With this change we don't
have to rely on global state anymore, but make the peeled object ID
available to the callback functions directly.

Adjust trivial callers that already have a `struct reference` available.
Remaining callers will be adjusted in subsequent commits.

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

diff --git a/builtin/describe.c b/builtin/describe.c
index 79545350443c6cbd3db403e473007976531ab717..443546aaac96f0371b5414013b0ee41848633622 100644 (file)
--- a/builtin/describe.c
+++ b/builtin/describe.c
@@ -208,7 +208,7 @@ static int get_name(const struct reference *ref, void *cb_data UNUSED)
        }
 
        /* Is it annotated? */
-       if (!peel_iterated_oid(the_repository, ref->oid, &peeled)) {
+       if (!reference_get_peeled_oid(the_repository, ref, &peeled)) {
                is_annotated = !oideq(ref->oid, &peeled);
        } else {
                oidcpy(&peeled, ref->oid);

diff --git a/builtin/gc.c b/builtin/gc.c
index 9de5de175f6a409a776e8ec5604539d0f8824f16..f0cf20d42389fee52f22143e336365b6ad8ac517 100644 (file)
--- a/builtin/gc.c
+++ b/builtin/gc.c
@@ -1109,7 +1109,7 @@ static int dfs_on_ref(const struct reference *ref, void *cb_data)
        struct commit_list *stack = NULL;
        struct commit *commit;
 
-       if (!peel_iterated_oid(the_repository, ref->oid, &peeled))
+       if (!reference_get_peeled_oid(the_repository, ref, &peeled))
                maybe_peeled = &peeled;
        if (odb_read_object_info(the_repository->objects, maybe_peeled, NULL) != OBJ_COMMIT)
                return 0;

diff --git a/builtin/pack-objects.c b/builtin/pack-objects.c
index 39633a0158e095e96c6fe000a68a91078532367d..1613fecb669830adebe58645c923145b36603260 100644 (file)
--- a/builtin/pack-objects.c
+++ b/builtin/pack-objects.c
@@ -838,7 +838,7 @@ static int mark_tagged(const struct reference *ref, void *cb_data UNUSED)
 
        if (entry)
                entry->tagged = 1;
-       if (!peel_iterated_oid(the_repository, ref->oid, &peeled)) {
+       if (!reference_get_peeled_oid(the_repository, ref, &peeled)) {
                entry = packlist_find(&to_pack, &peeled);
                if (entry)
                        entry->tagged = 1;
@@ -3309,7 +3309,8 @@ static int add_ref_tag(const struct reference *ref, void *cb_data UNUSED)
 {
        struct object_id peeled;
 
-       if (!peel_iterated_oid(the_repository, ref->oid, &peeled) && obj_is_packed(&peeled))
+       if (!reference_get_peeled_oid(the_repository, ref, &peeled) &&
+           obj_is_packed(&peeled))
                add_tag_chain(ref->oid);
        return 0;
 }
@@ -4537,7 +4538,7 @@ static int mark_bitmap_preferred_tip(const struct reference *ref, void *data UNU
        struct object_id peeled;
        struct object *object;
 
-       if (!peel_iterated_oid(the_repository, ref->oid, &peeled))
+       if (!reference_get_peeled_oid(the_repository, ref, &peeled))
                maybe_peeled = &peeled;
 
        object = parse_object_or_die(the_repository, maybe_peeled, ref->name);

diff --git a/commit-graph.c b/commit-graph.c
index f91af416259c8400f4c4b78234537da2f339f842..80be2ff2c39842675c962d262021a993e6b00cc5 100644 (file)
--- a/commit-graph.c
+++ b/commit-graph.c
@@ -1857,7 +1857,7 @@ static int add_ref_to_set(const struct reference *ref, void *cb_data)
        struct object_id peeled;
        struct refs_cb_data *data = (struct refs_cb_data *)cb_data;
 
-       if (!peel_iterated_oid(data->repo, ref->oid, &peeled))
+       if (!reference_get_peeled_oid(data->repo, ref, &peeled))
                maybe_peeled = &peeled;
        if (odb_read_object_info(data->repo->objects, maybe_peeled, NULL) == OBJ_COMMIT)
                oidset_insert(data->commits, maybe_peeled);

diff --git a/ls-refs.c b/ls-refs.c
index 64d0272369146658e52b49cc40a15e20761465fd..8641281b86c55af82de185c4867f63f372ffa933 100644 (file)
--- a/ls-refs.c
+++ b/ls-refs.c
@@ -110,7 +110,7 @@ static int send_ref(const struct reference *ref, void *cb_data)
 
        if (data->peel && ref->oid) {
                struct object_id peeled;
-               if (!peel_iterated_oid(the_repository, ref->oid, &peeled))
+               if (!reference_get_peeled_oid(the_repository, ref, &peeled))
                        strbuf_addf(&data->buf, " peeled:%s", oid_to_hex(&peeled));
        }
 

diff --git a/midx-write.c b/midx-write.c
index f4dd875747a4b6b1481735af175c99327561022c..23e61cb00014282faadf6b5c29636139ad54b082 100644 (file)
--- a/midx-write.c
+++ b/midx-write.c
@@ -709,7 +709,7 @@ static int add_ref_to_pending(const struct reference *ref, void *cb_data)
                return 0;
        }
 
-       if (!peel_iterated_oid(revs->repo, ref->oid, &peeled))
+       if (!reference_get_peeled_oid(revs->repo, ref, &peeled))
                maybe_peeled = &peeled;
 
        object = parse_object_or_die(revs->repo, maybe_peeled, ref->name);

diff --git a/pseudo-merge.c b/pseudo-merge.c
index 0abd51b42c185a5f31a631a42395a68900ed1722..a2d5bd85f95ebf269a3887698110d2af08258462 100644 (file)
--- a/pseudo-merge.c
+++ b/pseudo-merge.c
@@ -230,7 +230,7 @@ static int find_pseudo_merge_group_for_ref(const struct reference *ref, void *_d
        uint32_t i;
        int has_bitmap;
 
-       if (!peel_iterated_oid(the_repository, ref->oid, &peeled))
+       if (!reference_get_peeled_oid(the_repository, ref, &peeled))
                maybe_peeled = &peeled;
 
        c = lookup_commit(the_repository, maybe_peeled);

diff --git a/refs.c b/refs.c
index f96cf43b128a276f701083509a204bd3fe6c9fe9..1b1551f9814394e76fd9d6e45cea9d84d4a86c1b 100644 (file)
--- a/refs.c
+++ b/refs.c
@@ -2334,6 +2334,18 @@ int peel_iterated_oid(struct repository *r, const struct object_id *base, struct
        return peel_object(r, base, peeled) ? -1 : 0;
 }
 
+int reference_get_peeled_oid(struct repository *repo,
+                            const struct reference *ref,
+                            struct object_id *peeled_oid)
+{
+       if (ref->peeled_oid) {
+               oidcpy(peeled_oid, ref->peeled_oid);
+               return 0;
+       }
+
+       return peel_object(repo, ref->oid, peeled_oid) ? -1 : 0;
+}
+
 int refs_update_symref(struct ref_store *refs, const char *ref,
                       const char *target, const char *logmsg)
 {

diff --git a/refs.h b/refs.h
index 4f0a685714fa3af2dfc5c9c0d8e4291f03049587..886ed2c0f43b048765d22a67f4a6509080d74018 100644 (file)
--- a/refs.h
+++ b/refs.h
@@ -371,10 +371,29 @@ struct reference {
         */
        const struct object_id *oid;
 
+       /*
+        * An optional peeled object ID. This field _may_ be set for tags in
+        * case the peeled value is present in the backend. Please refer to
+        * `reference_get_peeled_oid()`.
+        */
+       const struct object_id *peeled_oid;
+
        /* A bitfield of `enum reference_status` flags. */
        unsigned flags;
 };
 
+/*
+ * Peel the tag to a non-tag commit. If present, this uses the peeled object ID
+ * exposed by the reference backend. Otherwise, the object is peeled via the
+ * object database, which is less efficient.
+ *
+ * Return `0` if the reference could be peeled, a negative error code
+ * otherwise.
+ */
+int reference_get_peeled_oid(struct repository *repo,
+                            const struct reference *ref,
+                            struct object_id *peeled_oid);
+
 /*
  * The signature for the callback function for the for_each_*()
  * functions below.  The memory pointed to by the `struct reference`

diff --git a/refs/packed-backend.c b/refs/packed-backend.c
index 711e07f8326c6bdb89ff40fd20816c2508570c37..1fefefd54ed0e72cde699ddaad7e16bbb6a74787 100644 (file)
--- a/refs/packed-backend.c
+++ b/refs/packed-backend.c
@@ -963,6 +963,7 @@ static int next_record(struct packed_ref_iterator *iter)
                        iter->base.ref.flags &= ~REF_KNOWS_PEELED;
                } else {
                        iter->base.ref.flags |= REF_KNOWS_PEELED;
+                       iter->base.ref.peeled_oid = &iter->peeled;
                }
        } else {
                oidclr(&iter->peeled, iter->repo->hash_algo);

diff --git a/refs/reftable-backend.c b/refs/reftable-backend.c
index 728886eafd33bd9aa8138f47e5803ff360a054ba..e214e120d77a5c1e1c1d0788859591bdca1ab784 100644 (file)
--- a/refs/reftable-backend.c
+++ b/refs/reftable-backend.c
@@ -547,6 +547,7 @@ struct reftable_ref_iterator {
        struct reftable_iterator iter;
        struct reftable_ref_record ref;
        struct object_id oid;
+       struct object_id peeled_oid;
 
        char *prefix;
        size_t prefix_len;
@@ -671,6 +672,8 @@ static int reftable_ref_iterator_advance(struct ref_iterator *ref_iterator)
                case REFTABLE_REF_VAL2:
                        oidread(&iter->oid, iter->ref.value.val2.value,
                                refs->base.repo->hash_algo);
+                       oidread(&iter->peeled_oid, iter->ref.value.val2.target_value,
+                               refs->base.repo->hash_algo);
                        break;
                case REFTABLE_REF_SYMREF:
                        referent = refs_resolve_ref_unsafe(&iter->refs->base,
@@ -708,6 +711,8 @@ static int reftable_ref_iterator_advance(struct ref_iterator *ref_iterator)
                iter->base.ref.name = iter->ref.refname;
                iter->base.ref.target = referent;
                iter->base.ref.oid = &iter->oid;
+               if (iter->ref.value_type == REFTABLE_REF_VAL2)
+                       iter->base.ref.peeled_oid = &iter->peeled_oid;
                iter->base.ref.flags = flags;
 
                break;

diff --git a/repack-midx.c b/repack-midx.c
index 349f7e20b53f25bd25c2d8180d5df3932534f03d..74bdfa3a6e913f65679076689f723d64e351584d 100644 (file)
--- a/repack-midx.c
+++ b/repack-midx.c
@@ -22,7 +22,7 @@ static int midx_snapshot_ref_one(const struct reference *ref, void *_data)
        const struct object_id *maybe_peeled = ref->oid;
        struct object_id peeled;
 
-       if (!peel_iterated_oid(data->repo, ref->oid, &peeled))
+       if (!reference_get_peeled_oid(data->repo, ref, &peeled))
                maybe_peeled = &peeled;
 
        if (oidset_insert(&data->seen, maybe_peeled))