[thirdparty/git.git] / pack-objects.c

#include "cache.h"
#include "object.h"
#include "delta.h"
#include "pack.h"
#include "csum-file.h"

static const char pack_usage[] = "git-pack-objects [--non-empty] [--local] [--incremental] [--window=N] [--depth=N] {--stdout | base-name} < object-list";

struct object_entry {
	unsigned char sha1[20];
	unsigned long size;
	unsigned long offset;
	unsigned int depth;
	unsigned int hash;
	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 void *delta_against(void *buf, unsigned long size, struct object_entry *entry)
{
	unsigned long othersize, delta_size;
	char type[10];
	void *otherbuf = read_sha1_file(entry->delta->sha1, type, &othersize);
	void *delta_buf;

	if (!otherbuf)
		die("unable to read %s", sha1_to_hex(entry->delta->sha1));
        delta_buf = diff_delta(otherbuf, othersize,
			       buf, size, &delta_size, 0);
        if (!delta_buf || delta_size != entry->delta_size)
        	die("delta size changed");
        free(buf);
        free(otherbuf);
	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);
	unsigned char header[10];
	unsigned hdrlen, datalen;
	enum object_type obj_type;

	if (!buf)
		die("unable to read %s", sha1_to_hex(entry->sha1));
	if (size != entry->size)
		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 zero or
	 * more bytes of length.  For deltas, the 20 bytes of delta sha1
	 * follows that.
	 */
	obj_type = entry->type;
	if (entry->delta) {
		buf = delta_against(buf, size, entry);
		size = entry->delta_size;
		obj_type = OBJ_DELTA;
	}
	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;
	unsigned long offset;
	unsigned long mb;
	struct pack_header hdr;

	if (!base_name)
		f = sha1fd(1, "<stdout>");
	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);

	sha1close(f, pack_file_sha1, 1);
	mb = offset >> 20;
	offset &= 0xfffff;
}

static void write_index_file(void)
{
	int i;
	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];

	/*
	 * Write the first-level table (the list is sorted,
	 * but we use a 256-entry lookup to be able to avoid
	 * having to do eight extra binary search iterations).
	 */
	for (i = 0; i < 256; i++) {
		struct object_entry **next = list;
		while (next < last) {
			struct object_entry *entry = *next;
			if (entry->sha1[0] != i)
				break;
			next++;
		}
		array[i] = htonl(next - sorted_by_sha);
		list = next;
	}
	sha1write(f, array, 256 * sizeof(int));

	/*
	 * Write the actual SHA1 entries..
	 */
	list = sorted_by_sha;
	for (i = 0; i < nr_objects; i++) {
		struct object_entry *entry = *list++;
		unsigned int offset = htonl(entry->offset);
		sha1write(f, &offset, 4);
		sha1write(f, entry->sha1, 20);
	}
	sha1write(f, pack_file_sha1, 20);
	sha1close(f, NULL, 1);
}

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));
		nr_alloc = needed;
	}
	entry = objects + idx;
	memset(entry, 0, sizeof(*entry));
	memcpy(entry->sha1, sha1, 20);
	entry->hash = hash;
	nr_objects = idx+1;
	return 1;
}

static void check_object(struct object_entry *entry)
{
	char type[20];

	if (!sha1_object_info(entry->sha1, type, &entry->size)) {
		if (!strcmp(type, "commit")) {
			entry->type = OBJ_COMMIT;
		} else if (!strcmp(type, "tree")) {
			entry->type = OBJ_TREE;
		} else if (!strcmp(type, "blob")) {
			entry->type = OBJ_BLOB;
		} else if (!strcmp(type, "tag")) {
			entry->type = OBJ_TAG;
		} else
			die("unable to pack object %s of type %s",
			    sha1_to_hex(entry->sha1), type);
	}
	else
		die("unable to get type of object %s",
		    sha1_to_hex(entry->sha1));
}

static void get_object_details(void)
{
	int i;
	struct object_entry *entry = objects;

	for (i = 0; i < nr_objects; i++)
		check_object(entry++);
}

typedef int (*entry_sort_t)(const struct object_entry *, const struct object_entry *);

static entry_sort_t current_sort;

static int sort_comparator(const void *_a, const void *_b)
{
	struct object_entry *a = *(struct object_entry **)_a;
	struct object_entry *b = *(struct object_entry **)_b;
	return current_sort(a,b);
}

static struct object_entry **create_sorted_list(entry_sort_t sort)
{
	struct object_entry **list = xmalloc(nr_objects * sizeof(struct object_entry *));
	int i;

	for (i = 0; i < nr_objects; i++)
		list[i] = objects + i;
	current_sort = sort;
	qsort(list, nr_objects, sizeof(struct object_entry *), sort_comparator);
	return list;
}

static int sha1_sort(const struct object_entry *a, const struct object_entry *b)
{
	return memcmp(a->sha1, b->sha1, 20);
}

static int type_size_sort(const struct object_entry *a, const struct object_entry *b)
{
	if (a->type < b->type)
		return -1;
	if (a->type > b->type)
		return 1;
	if (a->hash < b->hash)
		return -1;
	if (a->hash > b->hash)
		return 1;
	if (a->size < b->size)
		return -1;
	if (a->size > b->size)
		return 1;
	return a < b ? -1 : (a > b);
}

struct unpacked {
	struct object_entry *entry;
	void *data;
};

/*
 * We search for deltas _backwards_ in a list sorted by type and
 * by size, so that we see progressively smaller and smaller files.
 * That's because we prefer deltas to be from the bigger file
 * to the smaller - deletes are potentially cheaper, but perhaps
 * more importantly, the bigger file is likely the more recent
 * one.
 */
static int try_delta(struct unpacked *cur, struct unpacked *old, unsigned max_depth)
{
	struct object_entry *cur_entry = cur->entry;
	struct object_entry *old_entry = old->entry;
	unsigned long size, oldsize, delta_size, sizediff;
	long max_size;
	void *delta_buf;

	/* Don't bother doing diffs between different types */
	if (cur_entry->type != old_entry->type)
		return -1;

	size = cur_entry->size;
	if (size < 50)
		return -1;
	oldsize = old_entry->size;
	sizediff = oldsize > size ? oldsize - size : size - oldsize;
	if (sizediff > size / 8)
		return -1;
	if (old_entry->depth >= max_depth)
		return 0;

	/*
	 * NOTE!
	 *
	 * We always delta from the bigger to the smaller, since that's
	 * more space-efficient (deletes don't have to say _what_ they
	 * delete).
	 */
	max_size = size / 2 - 20;
	if (cur_entry->delta)
		max_size = cur_entry->delta_size-1;
	if (sizediff >= max_size)
		return -1;
	delta_buf = diff_delta(old->data, oldsize,
			       cur->data, size, &delta_size, max_size);
	if (!delta_buf)
		return 0;
	cur_entry->delta = old_entry;
	cur_entry->delta_size = delta_size;
	cur_entry->depth = old_entry->depth + 1;
	free(delta_buf);
	return 0;
}

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);

	memset(array, 0, array_size);
	i = nr_objects;
	idx = 0;
	while (--i >= 0) {
		struct object_entry *entry = list[i];
		struct unpacked *n = array + idx;
		unsigned long size;
		char type[10];
		int j;

		free(n->data);
		n->entry = entry;
		n->data = read_sha1_file(entry->sha1, type, &size);
		if (size != entry->size)
			die("object %s inconsistent object length (%lu vs %lu)", sha1_to_hex(entry->sha1), size, entry->size);
		j = window;
		while (--j > 0) {
			unsigned int other_idx = idx + j;
			struct unpacked *m;
			if (other_idx >= window)
				other_idx -= window;
			m = array + other_idx;
			if (!m->entry)
				break;
			if (try_delta(n, m, depth) < 0)
				break;
		}
		idx++;
		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();

	fprintf(stderr, "Packing %d objects\n", nr_objects);

	sorted_by_type = create_sorted_list(type_size_sort);
	if (window && depth)
		find_deltas(sorted_by_type, window+1, depth);
	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, pack_to_stdout = 0;
	struct object_entry **list;
	int i;

	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);
				if (!arg[9] || *end)
					usage(pack_usage);
				continue;
			}
			if (!strncmp("--depth=", arg, 8)) {
				char *end;
				depth = strtoul(arg+8, &end, 0);
				if (!arg[8] || *end)
					usage(pack_usage);
				continue;
			}
			if (!strcmp("--stdout", arg)) {
				pack_to_stdout = 1;
				continue;
			}
			usage(pack_usage);
		}
		if (base_name)
			usage(pack_usage);
		base_name = arg;
	}

	if (pack_to_stdout != !base_name)
		usage(pack_usage);

	prepare_packed_git();
	while (fgets(line, sizeof(line), stdin) != NULL) {
		unsigned int hash;
		char *p;
		unsigned char sha1[20];

		if (get_sha1_hex(line, sha1))
			die("expected sha1, got garbage:\n %s", line);
		hash = 0;
		p = line+40;
		while (*p) {
			unsigned char c = *p++;
			if (isspace(c))
				continue;
			hash = hash * 11 + c;
		}
		add_object_entry(sha1, hash);
	}
	if (non_empty && !nr_objects)
		return 0;

	sorted_by_sha = create_sorted_list(sha1_sort);
	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;
}
Commit	Line	Data
c323ac7d LT	1	#include "cache.h"
	2	#include "object.h"
	3	#include "delta.h"
a733cb60	4	#include "pack.h"
c38138cd	5	#include "csum-file.h"
c323ac7d	6
63ae26f8	7	static const char pack_usage[] = "git-pack-objects [--non-empty] [--local] [--incremental] [--window=N] [--depth=N] {--stdout \| base-name} < object-list";
c323ac7d	8
c323ac7d LT	9	struct object_entry {
	10	unsigned char sha1[20];
	11	unsigned long size;
	12	unsigned long offset;
	13	unsigned int depth;
27225f2e	14	unsigned int hash;
a733cb60	15	enum object_type type;
c323ac7d LT	16	unsigned long delta_size;
	17	struct object_entry *delta;
	18	};
	19
5f3de58f	20	static unsigned char object_list_sha1[20];
1c4a2912	21	static int non_empty = 0;
64560374	22	static int local = 0;
eb019375	23	static int incremental = 0;
c323ac7d LT	24	static struct object_entry sorted_by_sha, sorted_by_type;
	25	static struct object_entry *objects = NULL;
	26	static int nr_objects = 0, nr_alloc = 0;
c323ac7d	27	static const char *base_name;
e1808845	28	static unsigned char pack_file_sha1[20];
c323ac7d	29
c323ac7d LT	30	static void delta_against(void buf, unsigned long size, struct object_entry *entry)
	31	{
	32	unsigned long othersize, delta_size;
	33	char type[10];
	34	void *otherbuf = read_sha1_file(entry->delta->sha1, type, &othersize);
	35	void *delta_buf;
	36
	37	if (!otherbuf)
	38	die("unable to read %s", sha1_to_hex(entry->delta->sha1));
8ee378a0	39	delta_buf = diff_delta(otherbuf, othersize,
dcde55bc	40	buf, size, &delta_size, 0);
75c42d8c	41	if (!delta_buf \|\| delta_size != entry->delta_size)
c323ac7d LT	42	die("delta size changed");
	43	free(buf);
	44	free(otherbuf);
	45	return delta_buf;
	46	}
	47
a733cb60 LT	48	/*
	49	* The per-object header is a pretty dense thing, which is
	50	* - first byte: low four bits are "size", then three bits of "type",
	51	* and the high bit is "size continues".
	52	* - each byte afterwards: low seven bits are size continuation,
	53	* with the high bit being "size continues"
	54	*/
	55	static int encode_header(enum object_type type, unsigned long size, unsigned char *hdr)
	56	{
01247d87	57	int n = 1;
a733cb60 LT	58	unsigned char c;
	59
	60	if (type < OBJ_COMMIT \|\| type > OBJ_DELTA)
	61	die("bad type %d", type);
	62
01247d87 LT	63	c = (type << 4) \| (size & 15);
	64	size >>= 4;
	65	while (size) {
a733cb60	66	*hdr++ = c \| 0x80;
01247d87 LT	67	c = size & 0x7f;
	68	size >>= 7;
	69	n++;
a733cb60 LT	70	}
	71	*hdr = c;
	72	return n;
	73	}
	74
c38138cd	75	static unsigned long write_object(struct sha1file f, struct object_entry entry)
c323ac7d LT	76	{
	77	unsigned long size;
	78	char type[10];
	79	void *buf = read_sha1_file(entry->sha1, type, &size);
a733cb60	80	unsigned char header[10];
c323ac7d	81	unsigned hdrlen, datalen;
a733cb60	82	enum object_type obj_type;
c323ac7d LT	83
	84	if (!buf)
	85	die("unable to read %s", sha1_to_hex(entry->sha1));
	86	if (size != entry->size)
	87	die("object %s size inconsistency (%lu vs %lu)", sha1_to_hex(entry->sha1), size, entry->size);
	88
	89	/*
e1ddc976 JH	90	* The object header is a byte of 'type' followed by zero or
	91	* more bytes of length. For deltas, the 20 bytes of delta sha1
	92	* follows that.
c323ac7d	93	*/
a733cb60	94	obj_type = entry->type;
c323ac7d	95	if (entry->delta) {
c323ac7d LT	96	buf = delta_against(buf, size, entry);
c323ac7d LT	97	size = entry->delta_size;
a733cb60	98	obj_type = OBJ_DELTA;
c323ac7d	99	}
a733cb60	100	hdrlen = encode_header(obj_type, size, header);
c38138cd	101	sha1write(f, header, hdrlen);
a733cb60 LT	102	if (entry->delta) {
	103	sha1write(f, entry->delta, 20);
	104	hdrlen += 20;
	105	}
c38138cd	106	datalen = sha1write_compressed(f, buf, size);
c323ac7d LT	107	free(buf);
	108	return hdrlen + datalen;
	109	}
	110
9d5ab962 JH	111	static unsigned long write_one(struct sha1file *f,
	112	struct object_entry *e,
	113	unsigned long offset)
	114	{
	115	if (e->offset)
	116	/* offset starts from header size and cannot be zero
	117	* if it is written already.
	118	*/
	119	return offset;
	120	e->offset = offset;
	121	offset += write_object(f, e);
82f9d58a	122	/* if we are deltified, write out its base object. */
9d5ab962 JH	123	if (e->delta)
	124	offset = write_one(f, e->delta, offset);
	125	return offset;
	126	}
	127
c323ac7d LT	128	static void write_pack_file(void)
	129	{
	130	int i;
d22b9290	131	struct sha1file *f;
a733cb60	132	unsigned long offset;
c323ac7d	133	unsigned long mb;
a733cb60	134	struct pack_header hdr;
c323ac7d	135
d22b9290 LT	136	if (!base_name)
	137	f = sha1fd(1, "<stdout>");
	138	else
5f3de58f	139	f = sha1create("%s-%s.%s", base_name, sha1_to_hex(object_list_sha1), "pack");
a733cb60	140	hdr.hdr_signature = htonl(PACK_SIGNATURE);
01247d87	141	hdr.hdr_version = htonl(PACK_VERSION);
a733cb60 LT	142	hdr.hdr_entries = htonl(nr_objects);
	143	sha1write(f, &hdr, sizeof(hdr));
	144	offset = sizeof(hdr);
9d5ab962 JH	145	for (i = 0; i < nr_objects; i++)
	146	offset = write_one(f, objects + i, offset);
	147
e1808845	148	sha1close(f, pack_file_sha1, 1);
c323ac7d LT	149	mb = offset >> 20;
	150	offset &= 0xfffff;
	151	}
	152
	153	static void write_index_file(void)
	154	{
	155	int i;
5f3de58f	156	struct sha1file *f = sha1create("%s-%s.%s", base_name, sha1_to_hex(object_list_sha1), "idx");
c323ac7d LT	157	struct object_entry **list = sorted_by_sha;
	158	struct object_entry **last = list + nr_objects;
	159	unsigned int array[256];
	160
	161	/*
	162	* Write the first-level table (the list is sorted,
	163	* but we use a 256-entry lookup to be able to avoid
e1808845	164	* having to do eight extra binary search iterations).
c323ac7d LT	165	*/
	166	for (i = 0; i < 256; i++) {
	167	struct object_entry **next = list;
	168	while (next < last) {
	169	struct object_entry entry = next;
	170	if (entry->sha1[0] != i)
	171	break;
	172	next++;
	173	}
	174	array[i] = htonl(next - sorted_by_sha);
	175	list = next;
	176	}
c38138cd	177	sha1write(f, array, 256 * sizeof(int));
c323ac7d LT	178
	179	/*
	180	* Write the actual SHA1 entries..
	181	*/
	182	list = sorted_by_sha;
49397104	183	for (i = 0; i < nr_objects; i++) {
c323ac7d LT	184	struct object_entry entry = list++;
c323ac7d LT	185	unsigned int offset = htonl(entry->offset);
c38138cd LT	186	sha1write(f, &offset, 4);
c38138cd LT	187	sha1write(f, entry->sha1, 20);
c323ac7d	188	}
e1808845 LT	189	sha1write(f, pack_file_sha1, 20);
e1808845 LT	190	sha1close(f, NULL, 1);
c323ac7d LT	191	}
c323ac7d LT	192
5f3de58f	193	static int add_object_entry(unsigned char *sha1, unsigned int hash)
c323ac7d LT	194	{
	195	unsigned int idx = nr_objects;
	196	struct object_entry *entry;
	197
64560374 LT	198	if (incremental \|\| local) {
	199	struct packed_git *p;
	200
	201	for (p = packed_git; p; p = p->next) {
	202	struct pack_entry e;
	203
	204	if (find_pack_entry_one(sha1, &e, p)) {
	205	if (incremental)
	206	return 0;
	207	if (local && !p->pack_local)
	208	return 0;
	209	}
	210	}
	211	}
eb019375	212
c323ac7d LT	213	if (idx >= nr_alloc) {
	214	unsigned int needed = (idx + 1024) * 3 / 2;
	215	objects = xrealloc(objects, needed * sizeof(*entry));
	216	nr_alloc = needed;
	217	}
	218	entry = objects + idx;
	219	memset(entry, 0, sizeof(*entry));
	220	memcpy(entry->sha1, sha1, 20);
27225f2e	221	entry->hash = hash;
c323ac7d	222	nr_objects = idx+1;
5f3de58f	223	return 1;
c323ac7d LT	224	}
	225
	226	static void check_object(struct object_entry *entry)
	227	{
36e4d74a JH	228	char type[20];
	229
	230	if (!sha1_object_info(entry->sha1, type, &entry->size)) {
	231	if (!strcmp(type, "commit")) {
a733cb60	232	entry->type = OBJ_COMMIT;
36e4d74a	233	} else if (!strcmp(type, "tree")) {
a733cb60	234	entry->type = OBJ_TREE;
36e4d74a	235	} else if (!strcmp(type, "blob")) {
a733cb60	236	entry->type = OBJ_BLOB;
a69d0943	237	} else if (!strcmp(type, "tag")) {
a733cb60	238	entry->type = OBJ_TAG;
36e4d74a JH	239	} else
	240	die("unable to pack object %s of type %s",
	241	sha1_to_hex(entry->sha1), type);
	242	}
	243	else
	244	die("unable to get type of object %s",
	245	sha1_to_hex(entry->sha1));
c323ac7d LT	246	}
	247
	248	static void get_object_details(void)
	249	{
	250	int i;
	251	struct object_entry *entry = objects;
	252
	253	for (i = 0; i < nr_objects; i++)
	254	check_object(entry++);
	255	}
	256
	257	typedef int (entry_sort_t)(const struct object_entry , const struct object_entry *);
	258
	259	static entry_sort_t current_sort;
	260
	261	static int sort_comparator(const void _a, const void _b)
	262	{
	263	struct object_entry a = (struct object_entry **)_a;
	264	struct object_entry b = (struct object_entry **)_b;
	265	return current_sort(a,b);
	266	}
	267
	268	static struct object_entry **create_sorted_list(entry_sort_t sort)
	269	{
	270	struct object_entry *list = xmalloc(nr_objects sizeof(struct object_entry *));
	271	int i;
	272
	273	for (i = 0; i < nr_objects; i++)
	274	list[i] = objects + i;
	275	current_sort = sort;
	276	qsort(list, nr_objects, sizeof(struct object_entry *), sort_comparator);
	277	return list;
	278	}
	279
	280	static int sha1_sort(const struct object_entry a, const struct object_entry b)
	281	{
	282	return memcmp(a->sha1, b->sha1, 20);
	283	}
	284
	285	static int type_size_sort(const struct object_entry a, const struct object_entry b)
	286	{
	287	if (a->type < b->type)
	288	return -1;
	289	if (a->type > b->type)
	290	return 1;
27225f2e LT	291	if (a->hash < b->hash)
	292	return -1;
	293	if (a->hash > b->hash)
	294	return 1;
c323ac7d LT	295	if (a->size < b->size)
	296	return -1;
	297	if (a->size > b->size)
	298	return 1;
	299	return a < b ? -1 : (a > b);
	300	}
	301
	302	struct unpacked {
	303	struct object_entry *entry;
	304	void *data;
	305	};
	306
	307	/*
521a4f4c LT	308	* We search for deltas _backwards_ in a list sorted by type and
	309	* by size, so that we see progressively smaller and smaller files.
	310	* That's because we prefer deltas to be from the bigger file
	311	* to the smaller - deletes are potentially cheaper, but perhaps
	312	* more importantly, the bigger file is likely the more recent
	313	* one.
c323ac7d	314	*/
d116a45a	315	static int try_delta(struct unpacked cur, struct unpacked old, unsigned max_depth)
c323ac7d LT	316	{
	317	struct object_entry *cur_entry = cur->entry;
	318	struct object_entry *old_entry = old->entry;
521a4f4c	319	unsigned long size, oldsize, delta_size, sizediff;
75c42d8c	320	long max_size;
c323ac7d LT	321	void *delta_buf;
	322
	323	/* Don't bother doing diffs between different types */
	324	if (cur_entry->type != old_entry->type)
	325	return -1;
	326
c323ac7d	327	size = cur_entry->size;
75c42d8c LT	328	if (size < 50)
75c42d8c LT	329	return -1;
c323ac7d	330	oldsize = old_entry->size;
521a4f4c LT	331	sizediff = oldsize > size ? oldsize - size : size - oldsize;
521a4f4c LT	332	if (sizediff > size / 8)
c323ac7d	333	return -1;
d116a45a LT	334	if (old_entry->depth >= max_depth)
d116a45a LT	335	return 0;
c323ac7d LT	336
	337	/*
	338	* NOTE!
	339	*
	340	* We always delta from the bigger to the smaller, since that's
	341	* more space-efficient (deletes don't have to say _what_ they
	342	* delete).
	343	*/
75c42d8c LT	344	max_size = size / 2 - 20;
	345	if (cur_entry->delta)
	346	max_size = cur_entry->delta_size-1;
27225f2e LT	347	if (sizediff >= max_size)
27225f2e LT	348	return -1;
8ee378a0 JH	349	delta_buf = diff_delta(old->data, oldsize,
8ee378a0 JH	350	cur->data, size, &delta_size, max_size);
c323ac7d	351	if (!delta_buf)
75c42d8c LT	352	return 0;
	353	cur_entry->delta = old_entry;
	354	cur_entry->delta_size = delta_size;
d116a45a	355	cur_entry->depth = old_entry->depth + 1;
c323ac7d	356	free(delta_buf);
eb41ab11	357	return 0;
c323ac7d LT	358	}
c323ac7d LT	359
d116a45a	360	static void find_deltas(struct object_entry **list, int window, int depth)
c323ac7d	361	{
521a4f4c	362	int i, idx;
c323ac7d LT	363	unsigned int array_size = window * sizeof(struct unpacked);
	364	struct unpacked *array = xmalloc(array_size);
	365
	366	memset(array, 0, array_size);
521a4f4c LT	367	i = nr_objects;
	368	idx = 0;
	369	while (--i >= 0) {
c323ac7d LT	370	struct object_entry *entry = list[i];
	371	struct unpacked *n = array + idx;
	372	unsigned long size;
	373	char type[10];
	374	int j;
	375
	376	free(n->data);
	377	n->entry = entry;
	378	n->data = read_sha1_file(entry->sha1, type, &size);
	379	if (size != entry->size)
	380	die("object %s inconsistent object length (%lu vs %lu)", sha1_to_hex(entry->sha1), size, entry->size);
78817c15 LT	381	j = window;
	382	while (--j > 0) {
	383	unsigned int other_idx = idx + j;
c323ac7d	384	struct unpacked *m;
78817c15 LT	385	if (other_idx >= window)
78817c15 LT	386	other_idx -= window;
c323ac7d LT	387	m = array + other_idx;
	388	if (!m->entry)
	389	break;
d116a45a	390	if (try_delta(n, m, depth) < 0)
c323ac7d LT	391	break;
c323ac7d LT	392	}
521a4f4c LT	393	idx++;
	394	if (idx >= window)
	395	idx = 0;
c323ac7d	396	}
adee7bdf SV	397
	398	for (i = 0; i < window; ++i)
	399	free(array[i].data);
	400	free(array);
c323ac7d LT	401	}
c323ac7d LT	402
f3123c4a JH	403	static void prepare_pack(int window, int depth)
	404	{
	405	get_object_details();
	406
	407	fprintf(stderr, "Packing %d objects\n", nr_objects);
	408
	409	sorted_by_type = create_sorted_list(type_size_sort);
	410	if (window && depth)
	411	find_deltas(sorted_by_type, window+1, depth);
	412	write_pack_file();
	413	}
	414
	415	static int reuse_cached_pack(unsigned char *sha1, int pack_to_stdout)
	416	{
	417	static const char cache[] = "pack-cache/pack-%s.%s";
	418	char cached_pack, cached_idx;
	419	int ifd, ofd, ifd_ix = -1;
	420
	421	cached_pack = git_path(cache, sha1_to_hex(sha1), "pack");
	422	ifd = open(cached_pack, O_RDONLY);
	423	if (ifd < 0)
	424	return 0;
	425
	426	if (!pack_to_stdout) {
	427	cached_idx = git_path(cache, sha1_to_hex(sha1), "idx");
	428	ifd_ix = open(cached_idx, O_RDONLY);
	429	if (ifd_ix < 0) {
	430	close(ifd);
	431	return 0;
	432	}
	433	}
	434
	435	fprintf(stderr, "Reusing %d objects pack %s\n", nr_objects,
	436	sha1_to_hex(sha1));
	437
	438	if (pack_to_stdout) {
	439	if (copy_fd(ifd, 1))
	440	exit(1);
	441	close(ifd);
	442	}
	443	else {
	444	char name[PATH_MAX];
	445	snprintf(name, sizeof(name),
	446	"%s-%s.%s", base_name, sha1_to_hex(sha1), "pack");
	447	ofd = open(name, O_CREAT \| O_EXCL \| O_WRONLY, 0666);
	448	if (ofd < 0)
	449	die("unable to open %s (%s)", name, strerror(errno));
	450	if (copy_fd(ifd, ofd))
	451	exit(1);
	452	close(ifd);
	453
	454	snprintf(name, sizeof(name),
	455	"%s-%s.%s", base_name, sha1_to_hex(sha1), "idx");
	456	ofd = open(name, O_CREAT \| O_EXCL \| O_WRONLY, 0666);
	457	if (ofd < 0)
	458	die("unable to open %s (%s)", name, strerror(errno));
	459	if (copy_fd(ifd_ix, ofd))
	460	exit(1);
	461	close(ifd_ix);
	462	puts(sha1_to_hex(sha1));
	463	}
	464
	465	return 1;
	466	}
467
c323ac7d LT	468	int main(int argc, char **argv)
c323ac7d LT	469	{
5f3de58f	470	SHA_CTX ctx;
27225f2e	471	char line[PATH_MAX + 20];
d22b9290	472	int window = 10, depth = 10, pack_to_stdout = 0;
84c8d8ae	473	struct object_entry **list;
c323ac7d LT	474	int i;
c323ac7d LT	475
53228a5f JH	476	setup_git_directory();
53228a5f JH	477
c323ac7d LT	478	for (i = 1; i < argc; i++) {
	479	const char *arg = argv[i];
	480
	481	if (*arg == '-') {
1c4a2912 LT	482	if (!strcmp("--non-empty", arg)) {
	483	non_empty = 1;
	484	continue;
	485	}
64560374 LT	486	if (!strcmp("--local", arg)) {
	487	local = 1;
	488	continue;
	489	}
eb019375 LT	490	if (!strcmp("--incremental", arg)) {
	491	incremental = 1;
	492	continue;
	493	}
c323ac7d LT	494	if (!strncmp("--window=", arg, 9)) {
c323ac7d LT	495	char *end;
f846bbff	496	window = strtoul(arg+9, &end, 0);
c323ac7d LT	497	if (!arg[9] \|\| *end)
	498	usage(pack_usage);
	499	continue;
	500	}
d116a45a LT	501	if (!strncmp("--depth=", arg, 8)) {
	502	char *end;
	503	depth = strtoul(arg+8, &end, 0);
	504	if (!arg[8] \|\| *end)
	505	usage(pack_usage);
	506	continue;
	507	}
d22b9290 LT	508	if (!strcmp("--stdout", arg)) {
	509	pack_to_stdout = 1;
	510	continue;
	511	}
c323ac7d LT	512	usage(pack_usage);
	513	}
	514	if (base_name)
	515	usage(pack_usage);
	516	base_name = arg;
	517	}
	518
d22b9290	519	if (pack_to_stdout != !base_name)
c323ac7d LT	520	usage(pack_usage);
c323ac7d LT	521
64560374	522	prepare_packed_git();
c323ac7d	523	while (fgets(line, sizeof(line), stdin) != NULL) {
27225f2e LT	524	unsigned int hash;
27225f2e LT	525	char *p;
c323ac7d	526	unsigned char sha1[20];
27225f2e	527
c323ac7d	528	if (get_sha1_hex(line, sha1))
ef07618f	529	die("expected sha1, got garbage:\n %s", line);
27225f2e LT	530	hash = 0;
	531	p = line+40;
	532	while (*p) {
	533	unsigned char c = *p++;
	534	if (isspace(c))
	535	continue;
	536	hash = hash * 11 + c;
	537	}
84c8d8ae	538	add_object_entry(sha1, hash);
c323ac7d	539	}
1c4a2912 LT	540	if (non_empty && !nr_objects)
1c4a2912 LT	541	return 0;
c323ac7d LT	542
c323ac7d LT	543	sorted_by_sha = create_sorted_list(sha1_sort);
84c8d8ae JH	544	SHA1_Init(&ctx);
	545	list = sorted_by_sha;
	546	for (i = 0; i < nr_objects; i++) {
	547	struct object_entry entry = list++;
	548	SHA1_Update(&ctx, entry->sha1, 20);
	549	}
	550	SHA1_Final(object_list_sha1, &ctx);
	551
f3123c4a JH	552	if (reuse_cached_pack(object_list_sha1, pack_to_stdout))
	553	;
	554	else {
	555	prepare_pack(window, depth);
	556	if (!pack_to_stdout) {
	557	write_index_file();
	558	puts(sha1_to_hex(object_list_sha1));
	559	}
5f3de58f	560	}
c323ac7d LT	561	return 0;
c323ac7d LT	562	}