X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=pack-objects.c;h=2135e9a92e9289eb01e605888040f7d2b8bc9779;hb=070879ca93a7d358086f4c8aff4553493dcb9210;hp=90b27c60c3a889d7534e17af51b3e8b79b1d2b24;hpb=a69d09436687746a898f86f32c180083f323b616;p=git.git diff --git a/pack-objects.c b/pack-objects.c index 90b27c60..2135e9a9 100644 --- a/pack-objects.c +++ b/pack-objects.c @@ -1,35 +1,33 @@ -#include #include "cache.h" #include "object.h" #include "delta.h" +#include "pack.h" #include "csum-file.h" +#include -static const char pack_usage[] = "git-pack-objects [--window=N] [--depth=N] base-name < object-list"; +static const char pack_usage[] = "git-pack-objects [--non-empty] [--local] [--incremental] [--window=N] [--depth=N] {--stdout | base-name} < object-list"; -/* - * The object type is a single-character shorthand: - * - 'C' for "Commit" - * - 'T' for "Tree" - * - 'B' for "Blob" - * - 'G' for "taG" - * - 'D' for "Delta" - */ struct object_entry { unsigned char sha1[20]; unsigned long size; unsigned long offset; unsigned int depth; unsigned int hash; - unsigned char type; + enum object_type type; unsigned long delta_size; struct object_entry *delta; }; +static unsigned char object_list_sha1[20]; +static int non_empty = 0; +static int local = 0; +static int incremental = 0; static struct object_entry **sorted_by_sha, **sorted_by_type; static struct object_entry *objects = NULL; static int nr_objects = 0, nr_alloc = 0; static const char *base_name; static unsigned char pack_file_sha1[20]; +static int progress = 0; static void *delta_against(void *buf, unsigned long size, struct object_entry *entry) { @@ -41,7 +39,7 @@ static void *delta_against(void *buf, unsigned long size, struct object_entry *e if (!otherbuf) die("unable to read %s", sha1_to_hex(entry->delta->sha1)); delta_buf = diff_delta(otherbuf, othersize, - buf, size, &delta_size, ~0UL); + buf, size, &delta_size, 0); if (!delta_buf || delta_size != entry->delta_size) die("delta size changed"); free(buf); @@ -49,13 +47,41 @@ static void *delta_against(void *buf, unsigned long size, struct object_entry *e return delta_buf; } +/* + * The per-object header is a pretty dense thing, which is + * - first byte: low four bits are "size", then three bits of "type", + * and the high bit is "size continues". + * - each byte afterwards: low seven bits are size continuation, + * with the high bit being "size continues" + */ +static int encode_header(enum object_type type, unsigned long size, unsigned char *hdr) +{ + int n = 1; + unsigned char c; + + if (type < OBJ_COMMIT || type > OBJ_DELTA) + die("bad type %d", type); + + c = (type << 4) | (size & 15); + size >>= 4; + while (size) { + *hdr++ = c | 0x80; + c = size & 0x7f; + size >>= 7; + n++; + } + *hdr = c; + return n; +} + static unsigned long write_object(struct sha1file *f, struct object_entry *entry) { unsigned long size; char type[10]; void *buf = read_sha1_file(entry->sha1, type, &size); - char header[25]; + unsigned char header[10]; unsigned hdrlen, datalen; + enum object_type obj_type; if (!buf) die("unable to read %s", sha1_to_hex(entry->sha1)); @@ -63,39 +89,64 @@ static unsigned long write_object(struct sha1file *f, struct object_entry *entry die("object %s size inconsistency (%lu vs %lu)", sha1_to_hex(entry->sha1), size, entry->size); /* - * The object header is a byte of 'type' followed by four bytes of - * length, except for deltas that has the 20 bytes of delta sha - * instead. + * The object header is a byte of 'type' followed by zero or + * more bytes of length. For deltas, the 20 bytes of delta sha1 + * follows that. */ - header[0] = entry->type; - hdrlen = 5; + obj_type = entry->type; if (entry->delta) { - header[0] = 'D'; - memcpy(header+5, entry->delta, 20); buf = delta_against(buf, size, entry); size = entry->delta_size; - hdrlen = 25; + obj_type = OBJ_DELTA; } - datalen = htonl(size); - memcpy(header+1, &datalen, 4); + hdrlen = encode_header(obj_type, size, header); sha1write(f, header, hdrlen); + if (entry->delta) { + sha1write(f, entry->delta, 20); + hdrlen += 20; + } datalen = sha1write_compressed(f, buf, size); free(buf); return hdrlen + datalen; } +static unsigned long write_one(struct sha1file *f, + struct object_entry *e, + unsigned long offset) +{ + if (e->offset) + /* offset starts from header size and cannot be zero + * if it is written already. + */ + return offset; + e->offset = offset; + offset += write_object(f, e); + /* if we are deltified, write out its base object. */ + if (e->delta) + offset = write_one(f, e->delta, offset); + return offset; +} + static void write_pack_file(void) { int i; - struct sha1file *f = sha1create("%s.%s", base_name, "pack"); - unsigned long offset = 0; + struct sha1file *f; + unsigned long offset; unsigned long mb; + struct pack_header hdr; + + if (!base_name) + f = sha1fd(1, ""); + else + f = sha1create("%s-%s.%s", base_name, sha1_to_hex(object_list_sha1), "pack"); + hdr.hdr_signature = htonl(PACK_SIGNATURE); + hdr.hdr_version = htonl(PACK_VERSION); + hdr.hdr_entries = htonl(nr_objects); + sha1write(f, &hdr, sizeof(hdr)); + offset = sizeof(hdr); + for (i = 0; i < nr_objects; i++) + offset = write_one(f, objects + i, offset); - for (i = 0; i < nr_objects; i++) { - struct object_entry *entry = objects + i; - entry->offset = offset; - offset += write_object(f, entry); - } sha1close(f, pack_file_sha1, 1); mb = offset >> 20; offset &= 0xfffff; @@ -104,7 +155,7 @@ static void write_pack_file(void) static void write_index_file(void) { int i; - struct sha1file *f = sha1create("%s.%s", base_name, "idx"); + struct sha1file *f = sha1create("%s-%s.%s", base_name, sha1_to_hex(object_list_sha1), "idx"); struct object_entry **list = sorted_by_sha; struct object_entry **last = list + nr_objects; unsigned int array[256]; @@ -141,11 +192,26 @@ static void write_index_file(void) sha1close(f, NULL, 1); } -static void add_object_entry(unsigned char *sha1, unsigned int hash) +static int add_object_entry(unsigned char *sha1, unsigned int hash) { unsigned int idx = nr_objects; struct object_entry *entry; + if (incremental || local) { + struct packed_git *p; + + for (p = packed_git; p; p = p->next) { + struct pack_entry e; + + if (find_pack_entry_one(sha1, &e, p)) { + if (incremental) + return 0; + if (local && !p->pack_local) + return 0; + } + } + } + if (idx >= nr_alloc) { unsigned int needed = (idx + 1024) * 3 / 2; objects = xrealloc(objects, needed * sizeof(*entry)); @@ -156,6 +222,7 @@ static void add_object_entry(unsigned char *sha1, unsigned int hash) memcpy(entry->sha1, sha1, 20); entry->hash = hash; nr_objects = idx+1; + return 1; } static void check_object(struct object_entry *entry) @@ -164,13 +231,13 @@ static void check_object(struct object_entry *entry) if (!sha1_object_info(entry->sha1, type, &entry->size)) { if (!strcmp(type, "commit")) { - entry->type = 'C'; + entry->type = OBJ_COMMIT; } else if (!strcmp(type, "tree")) { - entry->type = 'T'; + entry->type = OBJ_TREE; } else if (!strcmp(type, "blob")) { - entry->type = 'B'; + entry->type = OBJ_BLOB; } else if (!strcmp(type, "tag")) { - entry->type = 'G'; + entry->type = OBJ_TAG; } else die("unable to pack object %s of type %s", sha1_to_hex(entry->sha1), type); @@ -297,10 +364,13 @@ static void find_deltas(struct object_entry **list, int window, int depth) int i, idx; unsigned int array_size = window * sizeof(struct unpacked); struct unpacked *array = xmalloc(array_size); + int eye_candy; memset(array, 0, array_size); i = nr_objects; idx = 0; + eye_candy = i - (nr_objects / 20); + while (--i >= 0) { struct object_entry *entry = list[i]; struct unpacked *n = array + idx; @@ -308,6 +378,10 @@ static void find_deltas(struct object_entry **list, int window, int depth) char type[10]; int j; + if (progress && i <= eye_candy) { + eye_candy -= nr_objects / 20; + fputc('.', stderr); + } free(n->data); n->entry = entry; n->data = read_sha1_file(entry->sha1, type, &size); @@ -329,18 +403,109 @@ static void find_deltas(struct object_entry **list, int window, int depth) if (idx >= window) idx = 0; } + + for (i = 0; i < window; ++i) + free(array[i].data); + free(array); +} + +static void prepare_pack(int window, int depth) +{ + get_object_details(); + + if (progress) + fprintf(stderr, "Packing %d objects", nr_objects); + sorted_by_type = create_sorted_list(type_size_sort); + if (window && depth) + find_deltas(sorted_by_type, window+1, depth); + if (progress) + fputc('\n', stderr); + write_pack_file(); +} + +static int reuse_cached_pack(unsigned char *sha1, int pack_to_stdout) +{ + static const char cache[] = "pack-cache/pack-%s.%s"; + char *cached_pack, *cached_idx; + int ifd, ofd, ifd_ix = -1; + + cached_pack = git_path(cache, sha1_to_hex(sha1), "pack"); + ifd = open(cached_pack, O_RDONLY); + if (ifd < 0) + return 0; + + if (!pack_to_stdout) { + cached_idx = git_path(cache, sha1_to_hex(sha1), "idx"); + ifd_ix = open(cached_idx, O_RDONLY); + if (ifd_ix < 0) { + close(ifd); + return 0; + } + } + + fprintf(stderr, "Reusing %d objects pack %s\n", nr_objects, + sha1_to_hex(sha1)); + + if (pack_to_stdout) { + if (copy_fd(ifd, 1)) + exit(1); + close(ifd); + } + else { + char name[PATH_MAX]; + snprintf(name, sizeof(name), + "%s-%s.%s", base_name, sha1_to_hex(sha1), "pack"); + ofd = open(name, O_CREAT | O_EXCL | O_WRONLY, 0666); + if (ofd < 0) + die("unable to open %s (%s)", name, strerror(errno)); + if (copy_fd(ifd, ofd)) + exit(1); + close(ifd); + + snprintf(name, sizeof(name), + "%s-%s.%s", base_name, sha1_to_hex(sha1), "idx"); + ofd = open(name, O_CREAT | O_EXCL | O_WRONLY, 0666); + if (ofd < 0) + die("unable to open %s (%s)", name, strerror(errno)); + if (copy_fd(ifd_ix, ofd)) + exit(1); + close(ifd_ix); + puts(sha1_to_hex(sha1)); + } + + return 1; } int main(int argc, char **argv) { + SHA_CTX ctx; char line[PATH_MAX + 20]; - int window = 10, depth = 10; + int window = 10, depth = 10, pack_to_stdout = 0; + struct object_entry **list; int i; + struct timeval prev_tv; + int eye_candy = 0; + int eye_candy_incr = 500; + + + setup_git_directory(); for (i = 1; i < argc; i++) { const char *arg = argv[i]; if (*arg == '-') { + if (!strcmp("--non-empty", arg)) { + non_empty = 1; + continue; + } + if (!strcmp("--local", arg)) { + local = 1; + continue; + } + if (!strcmp("--incremental", arg)) { + incremental = 1; + continue; + } if (!strncmp("--window=", arg, 9)) { char *end; window = strtoul(arg+9, &end, 0); @@ -355,6 +520,10 @@ int main(int argc, char **argv) usage(pack_usage); continue; } + if (!strcmp("--stdout", arg)) { + pack_to_stdout = 1; + continue; + } usage(pack_usage); } if (base_name) @@ -362,16 +531,39 @@ int main(int argc, char **argv) base_name = arg; } - if (!base_name) + if (pack_to_stdout != !base_name) usage(pack_usage); + progress = isatty(2); + + prepare_packed_git(); + if (progress) { + fprintf(stderr, "Generating pack...\n"); + gettimeofday(&prev_tv, NULL); + } while (fgets(line, sizeof(line), stdin) != NULL) { unsigned int hash; char *p; unsigned char sha1[20]; + if (progress && (eye_candy <= nr_objects)) { + fprintf(stderr, "Counting objects...%d\r", nr_objects); + if (eye_candy && (50 <= eye_candy_incr)) { + struct timeval tv; + int time_diff; + gettimeofday(&tv, NULL); + time_diff = (tv.tv_sec - prev_tv.tv_sec); + time_diff <<= 10; + time_diff += (tv.tv_usec - prev_tv.tv_usec); + if ((1 << 9) < time_diff) + eye_candy_incr += 50; + else if (50 < eye_candy_incr) + eye_candy_incr -= 50; + } + eye_candy += eye_candy_incr; + } if (get_sha1_hex(line, sha1)) - die("expected sha1, got garbage"); + die("expected sha1, got garbage:\n %s", line); hash = 0; p = line+40; while (*p) { @@ -382,16 +574,28 @@ int main(int argc, char **argv) } add_object_entry(sha1, hash); } - get_object_details(); - - printf("Packing %d objects\n", nr_objects); + if (progress) + fprintf(stderr, "Done counting %d objects.\n", nr_objects); + if (non_empty && !nr_objects) + return 0; sorted_by_sha = create_sorted_list(sha1_sort); - sorted_by_type = create_sorted_list(type_size_sort); - if (window && depth) - find_deltas(sorted_by_type, window+1, depth); - - write_pack_file(); - write_index_file(); + SHA1_Init(&ctx); + list = sorted_by_sha; + for (i = 0; i < nr_objects; i++) { + struct object_entry *entry = *list++; + SHA1_Update(&ctx, entry->sha1, 20); + } + SHA1_Final(object_list_sha1, &ctx); + + if (reuse_cached_pack(object_list_sha1, pack_to_stdout)) + ; + else { + prepare_pack(window, depth); + if (!pack_to_stdout) { + write_index_file(); + puts(sha1_to_hex(object_list_sha1)); + } + } return 0; }