From a61035fab9299de25ef46bbaedccd08734ce66c9 Mon Sep 17 00:00:00 2001 From: Karthik Nayak Date: Wed, 7 Oct 2026 13:20:16 +0200 Subject: [PATCH] packed-refs: use `fwrite()` when passing refs verbatim MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The `write_with_updates()` function uses a `struct ref_iterator` to iterate over all refs to write to the temporary packed-refs file. It receives the iterator from `packed_ref_iterator_begin()` which takes a snapshot of the 'packed-refs' file. While writing to the new packed-refs file, writes are routed via `write_packed_entry()` which uses `fprintf()`. Even for references which haven't changed, we use the same mechanism. This is slow since we need to do string parsing and formatting. Instead, let's track the position of unchanged references in the snapshot iterator and directly write verbatim via `fwrite()`. With this, any sanitization which was happening as a side effect of reformatting is now lost. But that was never the job of this section of the code, since the main intention is to simply rewrite the remaining refs post deletion of the selective few. This removes the unnecessary formatting operation involved. We can see a consistent ~20% performance improvement when deleting from packed references. Benchmark 1: update-ref: delete ref (refcount = 100000, revision = master) Time (mean ± σ): 28.7 ms ± 1.7 ms [User: 22.5 ms, System: 5.9 ms] Range (min … max): 26.7 ms … 33.3 ms 46 runs Benchmark 2: update-ref: delete ref (refcount = 100000, revision = b4/kn-speedup-packed-refs) Time (mean ± σ): 23.8 ms ± 1.2 ms [User: 17.5 ms, System: 6.0 ms] Range (min … max): 22.1 ms … 27.7 ms 56 runs Summary update-ref: delete ref (refcount = 100000, revision = b4/kn-speedup-packed-refs) ran 1.21 ± 0.09 times faster than update-ref: delete ref (refcount = 100000, revision = master) Signed-off-by: Karthik Nayak Signed-off-by: Junio C Hamano --- refs/packed-backend.c | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) diff --git a/refs/packed-backend.c b/refs/packed-backend.c index a73fc6aca7..53511f2d91 100644 --- a/refs/packed-backend.c +++ b/refs/packed-backend.c @@ -879,6 +879,9 @@ struct packed_ref_iterator { /* The current position in the snapshot's buffer: */ const char *pos; + /* The starting position of the current ref record. */ + const char *record_start; + /* The end of the part of the buffer that will be iterated over: */ const char *eof; @@ -933,6 +936,7 @@ static int next_record(struct packed_ref_iterator *iter) if (iter->pos == iter->eof) return ITER_DONE; + iter->record_start = iter->pos; iter->base.ref.flags = REF_ISPACKED; p = iter->pos; @@ -1530,9 +1534,15 @@ static enum ref_transaction_error write_with_updates(struct packed_ref_store *re } if (cmp < 0) { - /* Pass the old reference through. */ - if (write_packed_entry(out, iter->ref.name, - iter->ref.oid, iter->ref.peeled_oid)) + const struct packed_ref_iterator *packed_iter = + (const struct packed_ref_iterator *)iter; + size_t len = packed_iter->pos - packed_iter->record_start; + + /* + * Skip any formatting and directly write to the packed-refs file + * when deleting references and writing the remaining refs verbatim. + */ + if (fwrite(packed_iter->record_start, len, 1, out) != 1) goto write_error; if ((ok = ref_iterator_advance(iter)) != ITER_OK) {