kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

pack-revindex: store entries directly in packed_git 

A pack_revindex struct has two elements: the revindex
entries themselves, and a pointer to the packed_git. We need
both to do lookups, because only the latter knows things
like the number of objects in the pack.

Now that packed_git contains the pack_revindex struct it's
just as easy to pass around the packed_git itself, and we do
not need the extra back-pointer.

We can instead just store the entries directly in the pack.
All functions which took a pack_revindex now just take a
packed_git. We still lazy-load in find_pack_revindex, so
most callers are unaffected.

The exception is the bitmap code, which computes the
revindex and caches the pointer when we load the bitmaps. We
can continue to load, drop the extra cache pointer, and just
access bitmap_git.pack.revindex directly.

Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
maint
Jeff King 2015-12-21 01:20:33 -05:00 committed by Junio C Hamano
parent f4015337da
commit 9d98bbf578
4 changed files with 32 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cache.h
View File

@ -1118,7 +1118,7 @@ extern struct packed_git {
pack_keep:1, pack_keep:1,
do_not_close:1; do_not_close:1;
unsigned char sha1[20]; unsigned char sha1[20];
struct pack_revindex reverse_index; struct revindex_entry *revindex;
/* something like ".git/objects/pack/xxxxx.pack" */ /* something like ".git/objects/pack/xxxxx.pack" */
char pack_name[FLEX_ARRAY]; /* more */ char pack_name[FLEX_ARRAY]; /* more */
} *packed_git; } *packed_git;

13
pack-bitmap.c
View File

@ -33,9 +33,6 @@ static struct bitmap_index {
/* Packfile to which this bitmap index belongs to */ /* Packfile to which this bitmap index belongs to */
struct packed_git *pack; struct packed_git *pack;


/* reverse index for the packfile */
struct pack_revindex *reverse_index;

/* /*
* Mark the first `reuse_objects` in the packfile as reused: * Mark the first `reuse_objects` in the packfile as reused:
* they will be sent as-is without using them for repacking * they will be sent as-is without using them for repacking
@ -293,7 +290,7 @@ static int load_pack_bitmap(void)


bitmap_git.bitmaps = kh_init_sha1(); bitmap_git.bitmaps = kh_init_sha1();
bitmap_git.ext_index.positions = kh_init_sha1_pos(); bitmap_git.ext_index.positions = kh_init_sha1_pos();
bitmap_git.reverse_index = revindex_for_pack(bitmap_git.pack); load_pack_revindex(bitmap_git.pack);


if (!(bitmap_git.commits = read_bitmap_1(&bitmap_git)) || if (!(bitmap_git.commits = read_bitmap_1(&bitmap_git)) ||
!(bitmap_git.trees = read_bitmap_1(&bitmap_git)) || !(bitmap_git.trees = read_bitmap_1(&bitmap_git)) ||
@ -379,7 +376,7 @@ static inline int bitmap_position_packfile(const unsigned char *sha1)
if (!offset) if (!offset)
return -1; return -1;


return find_revindex_position(bitmap_git.reverse_index, offset); return find_revindex_position(bitmap_git.pack, offset);
} }


static int bitmap_position(const unsigned char *sha1) static int bitmap_position(const unsigned char *sha1)
@ -631,7 +628,7 @@ static void show_objects_for_type(
if (pos + offset < bitmap_git.reuse_objects) if (pos + offset < bitmap_git.reuse_objects)
continue; continue;


entry = &bitmap_git.reverse_index->revindex[pos + offset]; entry = &bitmap_git.pack->revindex[pos + offset];
sha1 = nth_packed_object_sha1(bitmap_git.pack, entry->nr); sha1 = nth_packed_object_sha1(bitmap_git.pack, entry->nr);


if (bitmap_git.hashes) if (bitmap_git.hashes)
@ -805,7 +802,7 @@ int reuse_partial_packfile_from_bitmap(struct packed_git **packfile,
return -1; return -1;


bitmap_git.reuse_objects = *entries = reuse_objects; bitmap_git.reuse_objects = *entries = reuse_objects;
*up_to = bitmap_git.reverse_index->revindex[reuse_objects].offset; *up_to = bitmap_git.pack->revindex[reuse_objects].offset;
*packfile = bitmap_git.pack; *packfile = bitmap_git.pack;


return 0; return 0;
@ -1037,7 +1034,7 @@ int rebuild_existing_bitmaps(struct packing_data *mapping,
struct revindex_entry *entry; struct revindex_entry *entry;
struct object_entry *oe; struct object_entry *oe;


entry = &bitmap_git.reverse_index->revindex[i]; entry = &bitmap_git.pack->revindex[i];
sha1 = nth_packed_object_sha1(bitmap_git.pack, entry->nr); sha1 = nth_packed_object_sha1(bitmap_git.pack, entry->nr);
oe = packlist_find(mapping, sha1, NULL); oe = packlist_find(mapping, sha1, NULL);



47
pack-revindex.c
View File

@ -115,14 +115,13 @@ static void sort_revindex(struct revindex_entry *entries, unsigned n, off_t max)
/* /*
* Ordered list of offsets of objects in the pack. * Ordered list of offsets of objects in the pack.
*/ */
static void create_pack_revindex(struct pack_revindex *rix) static void create_pack_revindex(struct packed_git *p)
{ {
struct packed_git *p = rix->p;
unsigned num_ent = p->num_objects; unsigned num_ent = p->num_objects;
unsigned i; unsigned i;
const char *index = p->index_data; const char *index = p->index_data;


rix->revindex = xmalloc(sizeof(*rix->revindex) * (num_ent + 1)); p->revindex = xmalloc(sizeof(*p->revindex) * (num_ent + 1));
index += 4 * 256; index += 4 * 256;


if (p->index_version > 1) { if (p->index_version > 1) {
@ -132,46 +131,42 @@ static void create_pack_revindex(struct pack_revindex *rix)
for (i = 0; i < num_ent; i++) { for (i = 0; i < num_ent; i++) {
uint32_t off = ntohl(*off_32++); uint32_t off = ntohl(*off_32++);
if (!(off & 0x80000000)) { if (!(off & 0x80000000)) {
rix->revindex[i].offset = off; p->revindex[i].offset = off;
} else { } else {
rix->revindex[i].offset = p->revindex[i].offset =
((uint64_t)ntohl(*off_64++)) << 32; ((uint64_t)ntohl(*off_64++)) << 32;
rix->revindex[i].offset |= p->revindex[i].offset |=
ntohl(*off_64++); ntohl(*off_64++);
} }
rix->revindex[i].nr = i; p->revindex[i].nr = i;
} }
} else { } else {
for (i = 0; i < num_ent; i++) { for (i = 0; i < num_ent; i++) {
uint32_t hl = *((uint32_t *)(index + 24 * i)); uint32_t hl = *((uint32_t *)(index + 24 * i));
rix->revindex[i].offset = ntohl(hl); p->revindex[i].offset = ntohl(hl);
rix->revindex[i].nr = i; p->revindex[i].nr = i;
} }
} }


/* This knows the pack format -- the 20-byte trailer /* This knows the pack format -- the 20-byte trailer
* follows immediately after the last object data. * follows immediately after the last object data.
*/ */
rix->revindex[num_ent].offset = p->pack_size - 20; p->revindex[num_ent].offset = p->pack_size - 20;
rix->revindex[num_ent].nr = -1; p->revindex[num_ent].nr = -1;
sort_revindex(rix->revindex, num_ent, p->pack_size); sort_revindex(p->revindex, num_ent, p->pack_size);
} }


struct pack_revindex *revindex_for_pack(struct packed_git *p) void load_pack_revindex(struct packed_git *p)
{ {
struct pack_revindex *rix = &p->reverse_index; if (!p->revindex)
if (!rix->revindex) { create_pack_revindex(p);
rix->p = p;
create_pack_revindex(rix);
}
return rix;
} }


int find_revindex_position(struct pack_revindex *pridx, off_t ofs) int find_revindex_position(struct packed_git *p, off_t ofs)
{ {
int lo = 0; int lo = 0;
int hi = pridx->p->num_objects + 1; int hi = p->num_objects + 1;
struct revindex_entry *revindex = pridx->revindex; struct revindex_entry *revindex = p->revindex;


do { do {
unsigned mi = lo + (hi - lo) / 2; unsigned mi = lo + (hi - lo) / 2;
@ -189,11 +184,13 @@ int find_revindex_position(struct pack_revindex *pridx, off_t ofs)


struct revindex_entry *find_pack_revindex(struct packed_git *p, off_t ofs) struct revindex_entry *find_pack_revindex(struct packed_git *p, off_t ofs)
{ {
struct pack_revindex *pridx = revindex_for_pack(p); int pos;
int pos = find_revindex_position(pridx, ofs);
load_pack_revindex(p);
pos = find_revindex_position(p, ofs);


if (pos < 0) if (pos < 0)
return NULL; return NULL;


return pridx->revindex + pos; return p->revindex + pos;
} }

11
pack-revindex.h
View File

@ -1,18 +1,15 @@
#ifndef PACK_REVINDEX_H #ifndef PACK_REVINDEX_H
#define PACK_REVINDEX_H #define PACK_REVINDEX_H


struct packed_git;

struct revindex_entry { struct revindex_entry {
off_t offset; off_t offset;
unsigned int nr; unsigned int nr;
}; };


struct pack_revindex { void load_pack_revindex(struct packed_git *p);
struct packed_git *p; int find_revindex_position(struct packed_git *p, off_t ofs);
struct revindex_entry *revindex;
};

struct pack_revindex *revindex_for_pack(struct packed_git *p);
int find_revindex_position(struct pack_revindex *pridx, off_t ofs);


struct revindex_entry *find_pack_revindex(struct packed_git *p, off_t ofs); struct revindex_entry *find_pack_revindex(struct packed_git *p, off_t ofs);