Merge branch 'pe/cleanup'
[git/git.git] / pack-objects.c
index 136a7f5..9346392 100644 (file)
@@ -1,9 +1,13 @@
 #include "cache.h"
 #include "object.h"
+#include "blob.h"
+#include "commit.h"
+#include "tag.h"
+#include "tree.h"
 #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 +36,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 +62,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,
@@ -606,7 +607,7 @@ static void add_pbase_tree(struct tree_desc *tree, struct name_path *up)
                if (!add_object_entry(sha1, hash, 1))
                        continue;
 
-               if (!strcmp(type, "tree")) {
+               if (!strcmp(type, tree_type)) {
                        struct tree_desc sub;
                        void *elem;
                        struct name_path me;
@@ -629,7 +630,7 @@ static void add_preferred_base(unsigned char *sha1)
        struct tree_desc tree;
        void *elem;
 
-       elem = read_object_with_reference(sha1, "tree", &tree.size, NULL);
+       elem = read_object_with_reference(sha1, tree_type, &tree.size, NULL);
        tree.buf = elem;
        if (!tree.buf)
                return;
@@ -687,13 +688,13 @@ static void check_object(struct object_entry *entry)
                die("unable to get type of object %s",
                    sha1_to_hex(entry->sha1));
 
-       if (!strcmp(type, "commit")) {
+       if (!strcmp(type, commit_type)) {
                entry->type = OBJ_COMMIT;
-       } else if (!strcmp(type, "tree")) {
+       } else if (!strcmp(type, tree_type)) {
                entry->type = OBJ_TREE;
-       } else if (!strcmp(type, "blob")) {
+       } else if (!strcmp(type, blob_type)) {
                entry->type = OBJ_BLOB;
-       } else if (!strcmp(type, "tag")) {
+       } else if (!strcmp(type, tag_type)) {
                entry->type = OBJ_TAG;
        } else
                die("unable to pack object %s of type %s",
@@ -824,8 +825,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;
@@ -867,27 +866,8 @@ 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,
@@ -897,14 +877,12 @@ static int try_delta(struct unpacked *cur, struct unpacked *old, unsigned max_de
        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;
 }
 
@@ -966,6 +944,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;
@@ -1041,6 +1028,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;
@@ -1106,18 +1110,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",