commit-slab: add a function to deep free entries on the slab

clear_##slabname() frees only the memory allocated for a commit slab
itself, but entries in the commit slab might own additional memory
outside the slab that should be freed as well.  We already have (at
least) one such commit slab, and this patch series is about to add one
more.

To free all additional memory owned by entries on the commit slab the
user of such a slab could iterate over all commits it knows about,
peek whether there is a valid entry associated with each commit, and
free the additional memory, if any.  Or it could rely on intimate
knowledge about the internals of the commit slab implementation, and
could itself iterate directly through all entries in the slab, and
free the additional memory.  Or it could just leak the additional
memory...

Introduce deep_clear_##slabname() to allow releasing memory owned by
commit slab entries by invoking the 'void free_fn(elemtype *ptr)'
function specified as parameter for each entry in the slab.

Use it in get_shallow_commits() in 'shallow.c' to replace an
open-coded iteration over a commit slab's entries.

Signed-off-by: SZEDER Gábor <szeder.dev@gmail.com>
Signed-off-by: Derrick Stolee <dstolee@microsoft.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/commit-slab-decl.h b/commit-slab-decl.h
index adc7b46c83b15f50ae2a85ce7e109fae4178f5fa..286164b7e270884fbd0735fdee0ce6839e6316e6 100644 (file)
--- a/commit-slab-decl.h
+++ b/commit-slab-decl.h
@@ -32,6 +32,7 @@ struct slabname {                                                     \
 void init_ ##slabname## _with_stride(struct slabname *s, unsigned stride); \
 void init_ ##slabname(struct slabname *s);                             \
 void clear_ ##slabname(struct slabname *s);                            \
+void deep_clear_ ##slabname(struct slabname *s, void (*free_fn)(elemtype *ptr)); \
 elemtype *slabname## _at_peek(struct slabname *s, const struct commit *c, int add_if_missing); \
 elemtype *slabname## _at(struct slabname *s, const struct commit *c);  \
 elemtype *slabname## _peek(struct slabname *s, const struct commit *c)

diff --git a/commit-slab-impl.h b/commit-slab-impl.h
index 5c0eb91a5d175ddb079459a0ba13b9be1f74b1ab..557738df271c7dd78c5ddcc65d6fe6e47c665758 100644 (file)
--- a/commit-slab-impl.h
+++ b/commit-slab-impl.h
@@ -38,6 +38,19 @@ scope void clear_ ##slabname(struct slabname *s)                     \
        FREE_AND_NULL(s->slab);                                         \
 }                                                                      \
                                                                        \
+scope void deep_clear_ ##slabname(struct slabname *s, void (*free_fn)(elemtype *)) \
+{                                                                      \
+       unsigned int i;                                                 \
+       for (i = 0; i < s->slab_count; i++) {                           \
+               unsigned int j;                                         \
+               if (!s->slab[i])                                        \
+                       continue;                                       \
+               for (j = 0; j < s->slab_size; j++)                      \
+                       free_fn(&s->slab[i][j * s->stride]);            \
+       }                                                               \
+       clear_ ##slabname(s);                                           \
+}                                                                      \
+                                                                       \
 scope elemtype *slabname## _at_peek(struct slabname *s,                        \
                                                  const struct commit *c, \
                                                  int add_if_missing)   \

diff --git a/commit-slab.h b/commit-slab.h
index 05b3f2804e74d5bb6bbcc0c735d7471d32566d88..8e72a30536541cc1064b8bd8d3cf727af03fa23c 100644 (file)
--- a/commit-slab.h
+++ b/commit-slab.h
@@ -47,6 +47,16 @@
  *
  *   Call this function before the slab falls out of scope to avoid
  *   leaking memory.
+ *
+ * - void deep_clear_indegree(struct indegree *, void (*free_fn)(int*))
+ *
+ *   Empties the slab, similar to clear_indegree(), but in addition it
+ *   calls the given 'free_fn' for each slab entry to release any
+ *   additional memory that might be owned by the entry (but not the
+ *   entry itself!).
+ *   Note that 'free_fn' might be called even for entries for which no
+ *   indegree_at() call has been made; in this case 'free_fn' is invoked
+ *   with a pointer to a zero-initialized location.
  */
 
 #define define_commit_slab(slabname, elemtype) \

diff --git a/shallow.c b/shallow.c
index 7fd04afed19af7de9dc1438b328567d0b7f2b2b4..c4ac8a732731cbad0d972369fd82e42ed6b2ed36 100644 (file)
--- a/shallow.c
+++ b/shallow.c
@@ -84,6 +84,10 @@ int is_repository_shallow(struct repository *r)
  * supports a "valid" flag.
  */
 define_commit_slab(commit_depth, int *);
+static void free_depth_in_slab(int **ptr)
+{
+       FREE_AND_NULL(*ptr);
+}
 struct commit_list *get_shallow_commits(struct object_array *heads, int depth,
                int shallow_flag, int not_shallow_flag)
 {
@@ -150,15 +154,7 @@ struct commit_list *get_shallow_commits(struct object_array *heads, int depth,
                        }
                }
        }
-       for (i = 0; i < depths.slab_count; i++) {
-               int j;
-
-               if (!depths.slab[i])
-                       continue;
-               for (j = 0; j < depths.slab_size; j++)
-                       free(depths.slab[i][j]);
-       }
-       clear_commit_depth(&depths);
+       deep_clear_commit_depth(&depths, free_depth_in_slab);
 
        return result;
 }