Commit f6c7081a authored by Nicolas Pitre's avatar Nicolas Pitre Committed by Junio C Hamano

use delta index data when finding best delta matches

This patch allows for computing the delta index for each base object
only once and reuse it when trying to find the best delta match.

This should set the mark and pave the way for possibly better delta
generator algorithms.
Signed-off-by: default avatarNicolas Pitre <nico@cam.org>
Signed-off-by: default avatarJunio C Hamano <junkio@cox.net>
parent 08abe669
......@@ -994,6 +994,7 @@ static int type_size_sort(const struct object_entry *a, const struct object_entr
struct unpacked {
struct object_entry *entry;
void *data;
struct delta_index *index;
};
/*
......@@ -1004,64 +1005,56 @@ struct unpacked {
* more importantly, the bigger file is likely the more recent
* one.
*/
static int try_delta(struct unpacked *cur, struct unpacked *old, unsigned max_depth)
static int try_delta(struct unpacked *trg, struct unpacked *src,
struct delta_index *src_index, 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;
struct object_entry *trg_entry = trg->entry;
struct object_entry *src_entry = src->entry;
unsigned long size, src_size, delta_size, sizediff, max_size;
void *delta_buf;
/* Don't bother doing diffs between different types */
if (cur_entry->type != old_entry->type)
if (trg_entry->type != src_entry->type)
return -1;
/* We do not compute delta to *create* objects we are not
* going to pack.
*/
if (cur_entry->preferred_base)
if (trg_entry->preferred_base)
return -1;
/* If the current object is at pack edge, take the depth the
/*
* If the current object is at pack edge, take the depth the
* objects that depend on the current object into account --
* otherwise they would become too deep.
*/
if (cur_entry->delta_child) {
if (max_depth <= cur_entry->delta_limit)
if (trg_entry->delta_child) {
if (max_depth <= trg_entry->delta_limit)
return 0;
max_depth -= cur_entry->delta_limit;
max_depth -= trg_entry->delta_limit;
}
size = cur_entry->size;
oldsize = old_entry->size;
sizediff = oldsize > size ? oldsize - size : size - oldsize;
if (size < 50)
return -1;
if (old_entry->depth >= max_depth)
if (src_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).
*/
/* Now some size filtering euristics. */
size = trg_entry->size;
max_size = size / 2 - 20;
if (cur_entry->delta)
max_size = cur_entry->delta_size-1;
if (trg_entry->delta)
max_size = trg_entry->delta_size-1;
src_size = src_entry->size;
sizediff = src_size < size ? size - src_size : 0;
if (sizediff >= max_size)
return 0;
delta_buf = diff_delta(old->data, oldsize,
cur->data, size, &delta_size, max_size);
delta_buf = create_delta(src_index, trg->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;
trg_entry->delta = src_entry;
trg_entry->delta_size = delta_size;
trg_entry->depth = src_entry->depth + 1;
free(delta_buf);
return 0;
return 1;
}
static void progress_interval(int signum)
......@@ -1109,11 +1102,19 @@ static void find_deltas(struct object_entry **list, int window, int depth)
*/
continue;
if (entry->size < 50)
continue;
if (n->index)
free_delta_index(n->index);
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);
die("object %s inconsistent object length (%lu vs %lu)",
sha1_to_hex(entry->sha1), size, entry->size);
n->index = create_delta_index(n->data, size);
if (!n->index)
die("out of memory");
j = window;
while (--j > 0) {
......@@ -1124,7 +1125,7 @@ static void find_deltas(struct object_entry **list, int window, int depth)
m = array + other_idx;
if (!m->entry)
break;
if (try_delta(n, m, depth) < 0)
if (try_delta(n, m, m->index, depth) < 0)
break;
}
#if 0
......@@ -1144,8 +1145,11 @@ static void find_deltas(struct object_entry **list, int window, int depth)
if (progress)
fputc('\n', stderr);
for (i = 0; i < window; ++i)
for (i = 0; i < window; ++i) {
if (array[i].index)
free_delta_index(array[i].index);
free(array[i].data);
}
free(array);
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment