@matheusbsbs / matheus-bagliano / commits / 694b7a1999

repack_without_ref(): write peeled refs in the rewritten file

When a reference that existed in the packed-refs file is deleted, the packed-refs file must be rewritten. Previously, the file was rewritten without any peeled refs, even if the file contained peeled refs when it was read. This was not a bug, because the packed-refs file header didn't claim that the file contained peeled values. But it had a performance cost, because the repository would lose the benefit of having precomputed peeled references until pack-refs was run again. Teach repack_without_ref() to write peeled refs to the packed-refs file (regardless of whether they were present in the old version of the file). This means that if the old version of the packed-refs file was not fully peeled, then repack_without_ref() will have to peel references. To avoid the expense of reading lots of loose references, we take two shortcuts relative to pack-refs: * If the peeled value of a reference is already known (i.e., because it was read from the old version of the packed-refs file), then output that peeled value again without any checks. This is the usual code path and should avoid any noticeable overhead. (This is different than pack-refs, which always re-peels references.) * We don't verify that the packed ref is still current. It could be that a packed references is overridden by a loose reference, in which case the packed ref is no longer needed and might even refer to an object that has been garbage collected. But we don't check; instead, we just try to peel all references. If peeling is successful, the peeled value is written out (even though it might not be needed any more); if not, then the reference is silently omitted from the output. The extra overhead of peeling references in repack_without_ref() should only be incurred the first time the packed-refs file is written by a version of Git that knows about the "fully-peeled" attribute. Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu> Signed-off-by: Junio C Hamano <gitster@pobox.com>

Michael Haggerty committed Apr 22, 2013 at 21:52 UTC 694b7a1999fa331e00ed9297f3b6b01f7da7a104

2 files changed +24 -1

refs.c

+23

@@ -876,6 +876,13 @@ void invalidate_ref_cache(const char *submodule)

876 /* The length of a peeled reference line in packed-refs, including EOL: */

877 #define PEELED_LINE_LENGTH 42

878

879 +/*

880 + * The packed-refs header line that we write out. Perhaps other

881 + * traits will be added later. The trailing space is required.

882 + */

883 +static const char PACKED_REFS_HEADER[] =

884 + "# pack-refs with: peeled fully-peeled \n";

885 +

886 /*

887 * Parse one line from a packed-refs file. Write the SHA1 to sha1.

888 * Return a pointer to the refname within the line (null-terminated),

@@ -1391,6 +1398,12 @@ static enum peel_status peel_object(const unsigned char *name, unsigned char *sh

1398

1399 /*

1400 * Peel the entry (if possible) and return its new peel_status.

1401 + *

1402 + * It is OK to call this function with a packed reference entry that

1403 + * might be stale and might even refer to an object that has since

1404 + * been garbage-collected. In such a case, if the entry has

1405 + * REF_KNOWS_PEELED then leave the status unchanged and return

1406 + * PEEL_PEELED or PEEL_NON_TAG; otherwise, return PEEL_INVALID.

1407 */

1408 static enum peel_status peel_entry(struct ref_entry *entry)

1409 {

@@ -1993,6 +2006,15 @@ static int repack_ref_fn(struct ref_entry *entry, void *cb_data)

2006 if (len > sizeof(line))

2007 die("too long a refname '%s'", entry->name);

2008 write_or_die(*fd, line, len);

2009 + if (!peel_entry(entry)) {

2010 + /* This reference could be peeled; write the peeled value: */

2011 + if (snprintf(line, sizeof(line), "^%s\n",

2012 + sha1_to_hex(entry->u.value.peeled)) !=

2013 + PEELED_LINE_LENGTH)

2014 + die("internal error");

2015 + write_or_die(*fd, line, PEELED_LINE_LENGTH);

2016 + }

2017 +

2018 return 0;

2019 }

2020

@@ -2023,6 +2045,7 @@ static int repack_without_ref(const char *refname)

2045 rollback_lock_file(&packlock);

2046 return 0;

2047 }

2048 + write_or_die(fd, PACKED_REFS_HEADER, strlen(PACKED_REFS_HEADER));

2049 do_for_each_entry_in_dir(packed, 0, repack_ref_fn, &fd);

2050 return commit_lock_file(&packlock);

2051 }

t/t3211-peel-ref.sh

+1 -1

@@ -61,7 +61,7 @@ test_expect_success 'refs are peeled outside of refs/tags (old packed)' '

61 test_cmp expect actual

62 '

64 -test_expect_failure 'peeled refs survive deletion of packed ref' '

64 +test_expect_success 'peeled refs survive deletion of packed ref' '

65 git pack-refs --all &&

66 cp .git/packed-refs fully-peeled &&

67 git branch yadda &&