X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=pack-objects.c;h=d7ba938af734f3ece9ff4f7060f32b8406f1827f;hb=4c61b7d15a6215fa4dffa33c37c3ef9df80d3f67;hp=d6a3463604bf3e61d8cf8b7d55947c229def8f07;hpb=0c1fc940eeae051e890304c40d1e66a478afadc8;p=git.git

diff --git a/pack-objects.c b/pack-objects.c
index d6a34636..d7ba938a 100644
--- a/pack-objects.c
+++ b/pack-objects.c
@@ -3,7 +3,7 @@
 #include "delta.h"
 #include "pack.h"
 #include "csum-file.h"
-#include "diff.h"
+#include "tree-walk.h"
 #include <sys/time.h>
 #include <signal.h>
 
@@ -32,9 +32,6 @@ struct object_entry {
 				 * be used as the base objectto delta huge
 				 * objects against.
 				 */
-	int based_on_preferred;	/* current delta candidate is a preferred
-				 * one, or delta against a preferred one.
-				 */
 };
 
 /*
@@ -61,7 +58,7 @@ static int nr_objects = 0, nr_alloc = 0, nr_result = 0;
 static const char *base_name;
 static unsigned char pack_file_sha1[20];
 static int progress = 1;
-static volatile int progress_update = 0;
+static volatile sig_atomic_t progress_update = 0;
 
 /*
  * The object names in objects array are hashed with this hashtable,
@@ -204,7 +201,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, 0, NULL);
+			       buf, size, &delta_size, 0);
         if (!delta_buf || delta_size != entry->delta_size)
         	die("delta size changed");
         free(buf);
@@ -810,7 +807,6 @@ static int type_size_sort(const struct object_entry *a, const struct object_entr
 struct unpacked {
 	struct object_entry *entry;
 	void *data;
-	void **delta_index;
 };
 
 /*
@@ -825,8 +821,6 @@ static int try_delta(struct unpacked *cur, struct unpacked *old, unsigned max_de
 {
 	struct object_entry *cur_entry = cur->entry;
 	struct object_entry *old_entry = old->entry;
-	int old_preferred = (old_entry->preferred_base ||
-			     old_entry->based_on_preferred);
 	unsigned long size, oldsize, delta_size, sizediff;
 	long max_size;
 	void *delta_buf;
@@ -868,45 +862,23 @@ static int try_delta(struct unpacked *cur, struct unpacked *old, unsigned max_de
 	 * delete).
 	 */
 	max_size = size / 2 - 20;
-	if (cur_entry->delta) {
-		if (cur_entry->based_on_preferred) {
-			if (old_preferred)
-				max_size = cur_entry->delta_size-1;
-			else
-				/* trying with non-preferred one when we
-				 * already have a delta based on preferred
-				 * one is pointless.
-				 */
-				return -1;
-		}
-		else if (!old_preferred)
-			max_size = cur_entry->delta_size-1;
-		else
-			/* otherwise...  even if delta with a
-			 * preferred one produces a bigger result than
-			 * what we currently have, which is based on a
-			 * non-preferred one, it is OK.
-			 */
-			;
-	}
+	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, old->delta_index);
+			       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;
-	cur_entry->based_on_preferred = old_preferred;
 	free(delta_buf);
 	return 0;
 }
 
 static void progress_interval(int signum)
 {
-	signal(SIGALRM, progress_interval);
 	progress_update = 1;
 }
 
@@ -950,7 +922,6 @@ static void find_deltas(struct object_entry **list, int window, int depth)
 			 */
 			continue;
 
-		free(n->delta_index);
 		free(n->data);
 		n->entry = entry;
 		n->data = read_sha1_file(entry->sha1, type, &size);
@@ -969,6 +940,15 @@ static void find_deltas(struct object_entry **list, int window, int depth)
 			if (try_delta(n, m, depth) < 0)
 				break;
 		}
+#if 0
+		/* if we made n a delta, and if n is already at max
+		 * depth, leaving it in the window is pointless.  we
+		 * should evict it first.
+		 * ... in theory only; somehow this makes things worse.
+		 */
+		if (entry->delta && depth <= entry->depth)
+			continue;
+#endif
 		idx++;
 		if (idx >= window)
 			idx = 0;
@@ -977,10 +957,8 @@ static void find_deltas(struct object_entry **list, int window, int depth)
 	if (progress)
 		fputc('\n', stderr);
 
-	for (i = 0; i < window; ++i) {
-		free(array[i].delta_index);
+	for (i = 0; i < window; ++i)
 		free(array[i].data);
-	}
 	free(array);
 }
 
@@ -1046,6 +1024,23 @@ static int reuse_cached_pack(unsigned char *sha1, int pack_to_stdout)
 	return 1;
 }
 
+static void setup_progress_signal(void)
+{
+	struct sigaction sa;
+	struct itimerval v;
+
+	memset(&sa, 0, sizeof(sa));
+	sa.sa_handler = progress_interval;
+	sigemptyset(&sa.sa_mask);
+	sa.sa_flags = SA_RESTART;
+	sigaction(SIGALRM, &sa, NULL);
+
+	v.it_interval.tv_sec = 1;
+	v.it_interval.tv_usec = 0;
+	v.it_value = v.it_interval;
+	setitimer(ITIMER_REAL, &v, NULL);
+}
+
 int main(int argc, char **argv)
 {
 	SHA_CTX ctx;
@@ -1111,18 +1106,24 @@ int main(int argc, char **argv)
 	prepare_packed_git();
 
 	if (progress) {
-		struct itimerval v;
-		v.it_interval.tv_sec = 1;
-		v.it_interval.tv_usec = 0;
-		v.it_value = v.it_interval;
-		signal(SIGALRM, progress_interval);
-		setitimer(ITIMER_REAL, &v, NULL);
 		fprintf(stderr, "Generating pack...\n");
+		setup_progress_signal();
 	}
 
-	while (fgets(line, sizeof(line), stdin) != NULL) {
+	for (;;) {
 		unsigned char sha1[20];
 
+		if (!fgets(line, sizeof(line), stdin)) {
+			if (feof(stdin))
+				break;
+			if (!ferror(stdin))
+				die("fgets returned NULL, not EOF, not error!");
+			if (errno != EINTR)
+				die("fgets: %s", strerror(errno));
+			clearerr(stdin);
+			continue;
+		}
+
 		if (line[0] == '-') {
 			if (get_sha1_hex(line+1, sha1))
 				die("expected edge sha1, got garbage:\n %s",