mirror of
https://github.com/git/git
synced 2024-08-27 11:39:22 +00:00
![Vicent Marti](/assets/img/avatar_default.png)
When we use pack bitmaps rather than walking the object graph, we end up with the list of objects to include in the packfile, but we do not know the path at which any tree or blob objects would be found. In a recently packed repository, this is fine. A fetch would use the paths only as a heuristic in the delta compression phase, and a fully packed repository should not need to do much delta compression. As time passes, though, we may acquire more objects on top of our large bitmapped pack. If clients fetch frequently, then they never even look at the bitmapped history, and all works as usual. However, a client who has not fetched since the last bitmap repack will have "have" tips in the bitmapped history, but "want" newer objects. The bitmaps themselves degrade gracefully in this circumstance. We manually walk the more recent bits of history, and then use bitmaps when we hit them. But we would also like to perform delta compression between the newer objects and the bitmapped objects (both to delta against what we know the user already has, but also between "new" and "old" objects that the user is fetching). The lack of pathnames makes our delta heuristics much less effective. This patch adds an optional cache of the 32-bit name_hash values to the end of the bitmap file. If present, a reader can use it to match bitmapped and non-bitmapped names during delta compression. Here are perf results for p5310: Test origin/master HEAD^ HEAD ------------------------------------------------------------------------------------------------- 5310.2: repack to disk 36.81(37.82+1.43) 47.70(48.74+1.41) +29.6% 47.75(48.70+1.51) +29.7% 5310.3: simulated clone 30.78(29.70+2.14) 1.08(0.97+0.10) -96.5% 1.07(0.94+0.12) -96.5% 5310.4: simulated fetch 3.16(6.10+0.08) 3.54(10.65+0.06) +12.0% 1.70(3.07+0.06) -46.2% 5310.6: partial bitmap 36.76(43.19+1.81) 6.71(11.25+0.76) -81.7% 4.08(6.26+0.46) -88.9% You can see that the time spent on an incremental fetch goes down, as our delta heuristics are able to do their work. And we save time on the partial bitmap clone for the same reason. Signed-off-by: Vicent Marti <tanoku@gmail.com> Signed-off-by: Jeff King <peff@peff.net> Signed-off-by: Junio C Hamano <gitster@pobox.com>
165 lines
5.4 KiB
Plaintext
165 lines
5.4 KiB
Plaintext
GIT bitmap v1 format
|
|
====================
|
|
|
|
- A header appears at the beginning:
|
|
|
|
4-byte signature: {'B', 'I', 'T', 'M'}
|
|
|
|
2-byte version number (network byte order)
|
|
The current implementation only supports version 1
|
|
of the bitmap index (the same one as JGit).
|
|
|
|
2-byte flags (network byte order)
|
|
|
|
The following flags are supported:
|
|
|
|
- BITMAP_OPT_FULL_DAG (0x1) REQUIRED
|
|
This flag must always be present. It implies that the bitmap
|
|
index has been generated for a packfile with full closure
|
|
(i.e. where every single object in the packfile can find
|
|
its parent links inside the same packfile). This is a
|
|
requirement for the bitmap index format, also present in JGit,
|
|
that greatly reduces the complexity of the implementation.
|
|
|
|
- BITMAP_OPT_HASH_CACHE (0x4)
|
|
If present, the end of the bitmap file contains
|
|
`N` 32-bit name-hash values, one per object in the
|
|
pack. The format and meaning of the name-hash is
|
|
described below.
|
|
|
|
4-byte entry count (network byte order)
|
|
|
|
The total count of entries (bitmapped commits) in this bitmap index.
|
|
|
|
20-byte checksum
|
|
|
|
The SHA1 checksum of the pack this bitmap index belongs to.
|
|
|
|
- 4 EWAH bitmaps that act as type indexes
|
|
|
|
Type indexes are serialized after the hash cache in the shape
|
|
of four EWAH bitmaps stored consecutively (see Appendix A for
|
|
the serialization format of an EWAH bitmap).
|
|
|
|
There is a bitmap for each Git object type, stored in the following
|
|
order:
|
|
|
|
- Commits
|
|
- Trees
|
|
- Blobs
|
|
- Tags
|
|
|
|
In each bitmap, the `n`th bit is set to true if the `n`th object
|
|
in the packfile is of that type.
|
|
|
|
The obvious consequence is that the OR of all 4 bitmaps will result
|
|
in a full set (all bits set), and the AND of all 4 bitmaps will
|
|
result in an empty bitmap (no bits set).
|
|
|
|
- N entries with compressed bitmaps, one for each indexed commit
|
|
|
|
Where `N` is the total amount of entries in this bitmap index.
|
|
Each entry contains the following:
|
|
|
|
- 4-byte object position (network byte order)
|
|
The position **in the index for the packfile** where the
|
|
bitmap for this commit is found.
|
|
|
|
- 1-byte XOR-offset
|
|
The xor offset used to compress this bitmap. For an entry
|
|
in position `x`, a XOR offset of `y` means that the actual
|
|
bitmap representing this commit is composed by XORing the
|
|
bitmap for this entry with the bitmap in entry `x-y` (i.e.
|
|
the bitmap `y` entries before this one).
|
|
|
|
Note that this compression can be recursive. In order to
|
|
XOR this entry with a previous one, the previous entry needs
|
|
to be decompressed first, and so on.
|
|
|
|
The hard-limit for this offset is 160 (an entry can only be
|
|
xor'ed against one of the 160 entries preceding it). This
|
|
number is always positive, and hence entries are always xor'ed
|
|
with **previous** bitmaps, not bitmaps that will come afterwards
|
|
in the index.
|
|
|
|
- 1-byte flags for this bitmap
|
|
At the moment the only available flag is `0x1`, which hints
|
|
that this bitmap can be re-used when rebuilding bitmap indexes
|
|
for the repository.
|
|
|
|
- The compressed bitmap itself, see Appendix A.
|
|
|
|
== Appendix A: Serialization format for an EWAH bitmap
|
|
|
|
Ewah bitmaps are serialized in the same protocol as the JAVAEWAH
|
|
library, making them backwards compatible with the JGit
|
|
implementation:
|
|
|
|
- 4-byte number of bits of the resulting UNCOMPRESSED bitmap
|
|
|
|
- 4-byte number of words of the COMPRESSED bitmap, when stored
|
|
|
|
- N x 8-byte words, as specified by the previous field
|
|
|
|
This is the actual content of the compressed bitmap.
|
|
|
|
- 4-byte position of the current RLW for the compressed
|
|
bitmap
|
|
|
|
All words are stored in network byte order for their corresponding
|
|
sizes.
|
|
|
|
The compressed bitmap is stored in a form of run-length encoding, as
|
|
follows. It consists of a concatenation of an arbitrary number of
|
|
chunks. Each chunk consists of one or more 64-bit words
|
|
|
|
H L_1 L_2 L_3 .... L_M
|
|
|
|
H is called RLW (run length word). It consists of (from lower to higher
|
|
order bits):
|
|
|
|
- 1 bit: the repeated bit B
|
|
|
|
- 32 bits: repetition count K (unsigned)
|
|
|
|
- 31 bits: literal word count M (unsigned)
|
|
|
|
The bitstream represented by the above chunk is then:
|
|
|
|
- K repetitions of B
|
|
|
|
- The bits stored in `L_1` through `L_M`. Within a word, bits at
|
|
lower order come earlier in the stream than those at higher
|
|
order.
|
|
|
|
The next word after `L_M` (if any) must again be a RLW, for the next
|
|
chunk. For efficient appending to the bitstream, the EWAH stores a
|
|
pointer to the last RLW in the stream.
|
|
|
|
|
|
== Appendix B: Optional Bitmap Sections
|
|
|
|
These sections may or may not be present in the `.bitmap` file; their
|
|
presence is indicated by the header flags section described above.
|
|
|
|
Name-hash cache
|
|
---------------
|
|
|
|
If the BITMAP_OPT_HASH_CACHE flag is set, the end of the bitmap contains
|
|
a cache of 32-bit values, one per object in the pack. The value at
|
|
position `i` is the hash of the pathname at which the `i`th object
|
|
(counting in index order) in the pack can be found. This can be fed
|
|
into the delta heuristics to compare objects with similar pathnames.
|
|
|
|
The hash algorithm used is:
|
|
|
|
hash = 0;
|
|
while ((c = *name++))
|
|
if (!isspace(c))
|
|
hash = (hash >> 2) + (c << 24);
|
|
|
|
Note that this hashing scheme is tied to the BITMAP_OPT_HASH_CACHE flag.
|
|
If implementations want to choose a different hashing scheme, they are
|
|
free to do so, but MUST allocate a new header flag (because comparing
|
|
hashes made under two different schemes would be pointless).
|