object-store: remove global array of cached objects

Cached objects are virtual objects that can be set up without writing
anything into the object store directly, which is used by git-blame(1)
to create fake commits for the working tree.

These cached objects are stored in a global variable, which is another
roadblock for libification of the object subsystem. Refactor the code so
that we instead store the array as part of the raw object store.

This refactoring raises the question whether virtual objects should
really be specific to a single repository (or rather a single object
store). Hypothetical usecases might for example span across submodules,
and here it may or may not be the right thing to provide virtual objects
across submodule boundaries.

The only existing usecase is git-blame(1) though, which does not know to
blame across submodule boundaries in the first place. As such, storing
these objects both globally and per-repository would achieve the same
result right now. But arguably, if we learned to blame across submodule
boundaries, we would likely want to create separate fare working tree
commits for each of the submodules so that the user can learn which
worktree a specific uncommitted change belongs to. And even if we would
want to create the same fake commit for each of the submodules we could
do that when storing separate virtual objects per object store.

While this is all rather hypothetical, the takeaway is that handling
virtual objects per-object store gives us more flexibility compared to
storing them globally. In a hypothetical future where we have achieved
full libification one might be able to handle unrelated repositories in
a single process, where the state of one repository should not have an
impact on the state of another repository. As such, storing these cached
objects per object store will enable more usecases and should lead to
less surprising outcomes overall.

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

diff --git a/blame.c b/blame.c
index 703dab43e78f8be20ced172bcd4b7040a0dd056d..b7c5bd692e62689857b573d06b51d61830eae9a7 100644 (file)
--- a/blame.c
+++ b/blame.c
@@ -277,7 +277,7 @@ static struct commit *fake_working_tree_commit(struct repository *r,
        convert_to_git(r->index, path, buf.buf, buf.len, &buf, 0);
        origin->file.ptr = buf.buf;
        origin->file.size = buf.len;
-       pretend_object_file(buf.buf, buf.len, OBJ_BLOB, &origin->blob_oid);
+       pretend_object_file(the_repository, buf.buf, buf.len, OBJ_BLOB, &origin->blob_oid);
 
        /*
         * Read the current index, replace the path entry with

diff --git a/object-store-ll.h b/object-store-ll.h
index 8bb0f33f9a88a89c837d7a27b2f01fef8a05d4b2..bb5e8798a1b5e76919e40636a7ef22fecd31698d 100644 (file)
--- a/object-store-ll.h
+++ b/object-store-ll.h
@@ -151,6 +151,8 @@ static inline int pack_map_entry_cmp(const void *cmp_data UNUSED,
        return strcmp(pg1->pack_name, key ? key : pg2->pack_name);
 }
 
+struct cached_object_entry;
+
 struct raw_object_store {
        /*
         * Set of all object directories; the main directory is first (and
@@ -203,6 +205,15 @@ struct raw_object_store {
                unsigned flags;
        } kept_pack_cache;
 
+       /*
+        * This is meant to hold a *small* number of objects that you would
+        * want repo_read_object_file() to be able to return, but yet you do not want
+        * to write them into the object store (e.g. a browse-only
+        * application).
+        */
+       struct cached_object_entry *cached_objects;
+       size_t cached_object_nr, cached_object_alloc;
+
        /*
         * A map of packfiles to packed_git structs for tracking which
         * packs have been loaded already.
@@ -272,7 +283,8 @@ void hash_object_file(const struct git_hash_algo *algo, const void *buf,
  * object in persistent storage before writing any other new objects
  * that reference it.
  */
-int pretend_object_file(void *, unsigned long, enum object_type,
+int pretend_object_file(struct repository *repo,
+                       void *buf, unsigned long len, enum object_type type,
                        struct object_id *oid);
 
 struct object_info {

diff --git a/object-store.c b/object-store.c
index 896d9ac3509f5109f95583324ba499e2e93cb03f..0f1dcc113ed7b0e89dff8aad67c6f2f202afa654 100644 (file)
--- a/object-store.c
+++ b/object-store.c
@@ -30,31 +30,31 @@
  * to write them into the object store (e.g. a browse-only
  * application).
  */
-static struct cached_object_entry {
+struct cached_object_entry {
        struct object_id oid;
        struct cached_object {
                enum object_type type;
                const void *buf;
                unsigned long size;
        } value;
-} *cached_objects;
-static int cached_object_nr, cached_object_alloc;
+};
 
-static const struct cached_object *find_cached_object(const struct object_id *oid)
+static const struct cached_object *find_cached_object(struct raw_object_store *object_store,
+                                                     const struct object_id *oid)
 {
        static const struct cached_object empty_tree = {
                .type = OBJ_TREE,
                .buf = "",
        };
-       int i;
-       const struct cached_object_entry *co = cached_objects;
+       const struct cached_object_entry *co = object_store->cached_objects;
 
-       for (i = 0; i < cached_object_nr; i++, co++) {
+       for (size_t i = 0; i < object_store->cached_object_nr; i++, co++)
                if (oideq(&co->oid, oid))
                        return &co->value;
-       }
-       if (oideq(oid, the_hash_algo->empty_tree))
+
+       if (oid->algo && oideq(oid, hash_algos[oid->algo].empty_tree))
                return &empty_tree;
+
        return NULL;
 }
 
@@ -650,7 +650,7 @@ static int do_oid_object_info_extended(struct repository *r,
        if (!oi)
                oi = &blank_oi;
 
-       co = find_cached_object(real);
+       co = find_cached_object(r->objects, real);
        if (co) {
                if (oi->typep)
                        *(oi->typep) = co->type;
@@ -853,18 +853,21 @@ int oid_object_info(struct repository *r,
        return type;
 }
 
-int pretend_object_file(void *buf, unsigned long len, enum object_type type,
+int pretend_object_file(struct repository *repo,
+                       void *buf, unsigned long len, enum object_type type,
                        struct object_id *oid)
 {
        struct cached_object_entry *co;
        char *co_buf;
 
-       hash_object_file(the_hash_algo, buf, len, type, oid);
-       if (repo_has_object_file_with_flags(the_repository, oid, OBJECT_INFO_QUICK | OBJECT_INFO_SKIP_FETCH_OBJECT) ||
-           find_cached_object(oid))
+       hash_object_file(repo->hash_algo, buf, len, type, oid);
+       if (repo_has_object_file_with_flags(repo, oid, OBJECT_INFO_QUICK | OBJECT_INFO_SKIP_FETCH_OBJECT) ||
+           find_cached_object(repo->objects, oid))
                return 0;
-       ALLOC_GROW(cached_objects, cached_object_nr + 1, cached_object_alloc);
-       co = &cached_objects[cached_object_nr++];
+
+       ALLOC_GROW(repo->objects->cached_objects,
+                  repo->objects->cached_object_nr + 1, repo->objects->cached_object_alloc);
+       co = &repo->objects->cached_objects[repo->objects->cached_object_nr++];
        co->value.size = len;
        co->value.type = type;
        co_buf = xmalloc(len);
@@ -1021,6 +1024,10 @@ void raw_object_store_clear(struct raw_object_store *o)
        o->odb_tail = NULL;
        o->loaded_alternates = 0;
 
+       for (size_t i = 0; i < o->cached_object_nr; i++)
+               free((char *) o->cached_objects[i].value.buf);
+       FREE_AND_NULL(o->cached_objects);
+
        INIT_LIST_HEAD(&o->packed_git_mru);
        close_object_store(o);