Re: [PATCH v2 01/17] odb: introduce "in-memory" source
- From
Karthik Nayak <karthik.188@gmail.com>
- Date
- Apr 9, 2026, 09:26 UTC
- Message-ID
- <CAOLa=ZRkctXNkpTqiTSTkvskajPZTid9WTG3fKr0YV641_5qrw@mail.gmail.com>
- In-Reply-To
- <20260409-b4-pks-odb-source-inmemory-v2-1-f02b4f1c0f13@pks.im>
Patrick Steinhardt <ps@pks.im> writes:
Show 25 quoted lines
> Next to our typical object database sources, each object database also > has an implicit source of "cached" objects. These cached objects only > exist in memory and some use cases: > > - They contain evergreen objects that we expect to always exist, like > for example the empty tree. > > - They can be used to store temporary objects that we don't want to > persist to disk, which is used by git-blame(1) to create a fake > worktree commit. > > Overall, their use is somewhat restricted though. For example, we don't > provide the ability to use it as a temporary object database source that > allows the user to write objects, but discard them after Git exists. So > while these cached objects behave almost like a source, they aren't used > as one. > > This is about to change over the following commits, where we will turn > cached objects into a new "in-memory" source. This will allow us to use > it exactly the same as any other source by providing the same common > interface as the "files" source. > > For now, the in-memory source only hosts the cached objects and doesn't > provide any logic yet. This will change with subsequent commits, where > we move respective functionality into the source.
[snip]
Show 35 quoted lines
> diff --git a/odb.c b/odb.c > index 40a5e9c4e0..60e1eead25 100644 > --- a/odb.c > +++ b/odb.c > @@ -14,6 +14,7 @@ > #include "object-file.h" > #include "object-name.h" > #include "odb.h" > +#include "odb/source-inmemory.h" > #include "packfile.h" > #include "path.h" > #include "promisor-remote.h" > @@ -53,9 +54,9 @@ static const struct cached_object *find_cached_object(struct object_database *ob > .type = OBJ_TREE, > .buf = "", > }; > - const struct cached_object_entry *co = object_store->cached_objects; > + const struct cached_object_entry *co = object_store->inmemory_objects->objects; > > - for (size_t i = 0; i < object_store->cached_object_nr; i++, co++) > + for (size_t i = 0; i < object_store->inmemory_objects->objects_nr; i++, co++) > if (oideq(&co->oid, oid)) > return &co->value; > > @@ -792,9 +793,10 @@ int odb_pretend_object(struct object_database *odb, > find_cached_object(odb, oid)) > return 0; > > - ALLOC_GROW(odb->cached_objects, > - odb->cached_object_nr + 1, odb->cached_object_alloc); > - co = &odb->cached_objects[odb->cached_object_nr++]; > + ALLOC_GROW(odb->inmemory_objects->objects, > + odb->inmemory_objects->objects_nr + 1, > + odb->inmemory_objects->objects_alloc); > + co = &odb->inmemory_objects->objects[odb->inmemory_objects->objects_nr++];
Okay so we introduce the inmemory object storage and directly write objects to it. I guess in the upcoming commits, we'll swap to using the API as we implement them.
Makes sense for now.
Show 106 quoted lines
> co->value.size = len;
> co->value.type = type;
> co_buf = xmalloc(len);
> @@ -1083,6 +1085,7 @@ struct object_database *odb_new(struct repository *repo,
> o->sources = odb_source_new(o, primary_source, true);
> o->sources_tail = &o->sources->next;
> o->alternate_db = xstrdup_or_null(secondary_sources);
> + o->inmemory_objects = odb_source_inmemory_new(o);
>
> free(to_free);
>
> @@ -1123,9 +1126,11 @@ void odb_free(struct object_database *o)
> odb_close(o);
> odb_free_sources(o);
>
> - for (size_t i = 0; i < o->cached_object_nr; i++)
> - free((char *) o->cached_objects[i].value.buf);
> - free(o->cached_objects);
> + for (size_t i = 0; i < o->inmemory_objects->objects_nr; i++)
> + free((char *) o->inmemory_objects->objects[i].value.buf);
> + free(o->inmemory_objects->objects);
> + free(o->inmemory_objects->base.path);
> + free(o->inmemory_objects);
>
> string_list_clear(&o->submodule_source_paths, 0);
>
> diff --git a/odb.h b/odb.h
> index 9eb8355aca..c3a7edf9c8 100644
> --- a/odb.h
> +++ b/odb.h
> @@ -8,6 +8,7 @@
> #include "thread-utils.h"
>
> struct cached_object_entry;
> +struct odb_source_inmemory;
> struct packed_git;
> struct repository;
> struct strbuf;
> @@ -80,8 +81,7 @@ struct object_database {
> * 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;
> + struct odb_source_inmemory *inmemory_objects;
>
> /*
> * A fast, rough count of the number of objects in the repository.
> diff --git a/odb/source-inmemory.c b/odb/source-inmemory.c
> new file mode 100644
> index 0000000000..c7ac5c24f0
> --- /dev/null
> +++ b/odb/source-inmemory.c
> @@ -0,0 +1,12 @@
> +#include "git-compat-util.h"
> +#include "odb/source-inmemory.h"
> +
> +struct odb_source_inmemory *odb_source_inmemory_new(struct object_database *odb)
> +{
> + struct odb_source_inmemory *source;
> +
> + CALLOC_ARRAY(source, 1);
> + odb_source_init(&source->base, odb, ODB_SOURCE_INMEMORY, "source", false);
> +
> + return source;
> +}
> diff --git a/odb/source-inmemory.h b/odb/source-inmemory.h
> new file mode 100644
> index 0000000000..95477bf36d
> --- /dev/null
> +++ b/odb/source-inmemory.h
> @@ -0,0 +1,35 @@
> +#ifndef ODB_SOURCE_INMEMORY_H
> +#define ODB_SOURCE_INMEMORY_H
> +
> +#include "odb/source.h"
> +
> +struct cached_object_entry;
> +
> +/*
> + * An inmemory source that you can write objects to that shall be made
> + * available for reading, but that shouldn't ever be persisted to disk. Note
> + * that any objects written to this source will be stored in memory, so the
> + * number of objects you can store is limited by available system memory.
> + */
> +struct odb_source_inmemory {
> + struct odb_source base;
> +
> + struct cached_object_entry *objects;
> + size_t objects_nr, objects_alloc;
> +};
> +
> +/* Create a new in-memory object database source. */
> +struct odb_source_inmemory *odb_source_inmemory_new(struct object_database *odb);
> +
> +/*
> + * Cast the given object database source to the inmemory backend. This will
> + * cause a BUG in case the source doesn't use this backend.
> + */
> +static inline struct odb_source_inmemory *odb_source_inmemory_downcast(struct odb_source *source)
> +{
> + if (source->type != ODB_SOURCE_INMEMORY)
> + BUG("trying to downcast source of type '%d' to inmemory", source->type);
> + return container_of(source, struct odb_source_inmemory, base);
> +}
> +Interesting, in the refs namespace the downcast functions are added to the source file (.c). This works too, is there any reason though?
[snip]