From: Karthik Nayak Date: Thu, 09 Apr 2026 09:26:50 GMT Subject: Re: [PATCH v2 01/17] odb: introduce "in-memory" source Message-ID: In-Reply-To: <20260409-b4-pks-odb-source-inmemory-v2-1-f02b4f1c0f13@pks.im> Patrick Steinhardt writes: > 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] > 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. > 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]