fetch-pack: avoid quadratic behavior in rev_list_push

When we call find_common to start finding common ancestors
with the remote side of a fetch, the first thing we do is
insert the tip of each ref into our rev_list linked list. We
keep the list sorted the whole time with
commit_list_insert_by_date, which means our insertion ends
up doing O(n^2) timestamp comparisons.

We could teach rev_list_push to use an unsorted list, and
then sort it once after we have added each ref. However, in
get_rev, we process the list by popping commits off the
front and adding parents back in timestamp-sorted order. So
that procedure would still operate on the large list.

Instead, we can replace the linked list with a heap-based
priority queue, which can do O(log n) insertion, making the
whole insertion procedure O(n log n).

As a result of switching to the prio_queue struct, we fix
two minor bugs:

1. When we "pop" a commit in get_rev, and when we clear
the rev_list in find_common, we do not take care to
free the "struct commit_list", and just leak its
memory. With the prio_queue implementation, the memory
management is handled for us.

2. In get_rev, we look at the head commit of the list,
possibly push its parents onto the list, and then "pop"
the front of the list off, assuming it is the same
element that we just peeked at. This is typically going
to be the case, but would not be in the face of clock
skew: the parents are inserted by date, and could
potentially be inserted at the head of the list if they
have a timestamp newer than their descendent. In this
case, we would accidentally pop the parent, and never
process it at all.

The new implementation pulls the commit off of the
queue as we examine it, and so does not suffer from
this problem.

With this patch, a fetch of a single commit into a
repository with 50,000 refs went from:

real    0m7.984s
user    0m7.852s
sys     0m0.120s

to:

real    0m2.017s
user    0m1.884s
sys     0m0.124s

Before this patch, a larger case with 370K refs still had
not completed after tens of minutes; with this patch, it
completes in about 12 seconds.

Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/fetch-pack.c b/fetch-pack.c
index 4df8abd7c17af86968320f20c3aa66cac8029529..6684348c0ec9ea742eb98666b56a0bfcef316560 100644 (file)
--- a/fetch-pack.c
+++ b/fetch-pack.c
@@ -11,6 +11,7 @@
 #include "run-command.h"
 #include "transport.h"
 #include "version.h"
 #include "run-command.h"
 #include "transport.h"
 #include "version.h"

+#include "prio-queue.h"

 
 static int transfer_unpack_limit = -1;
 static int fetch_unpack_limit = -1;
 
 static int transfer_unpack_limit = -1;
 static int fetch_unpack_limit = -1;


@@ -37,7 +38,7 @@ static int marked;
  */
 #define MAX_IN_VAIN 256
 
  */
 #define MAX_IN_VAIN 256
 

-static struct commit_list *rev_list;
+static struct prio_queue rev_list = { compare_commits_by_commit_date };

 static int non_common_revs, multi_ack, use_sideband, allow_tip_sha1_in_want;
 
 static void rev_list_push(struct commit *commit, int mark)
 static int non_common_revs, multi_ack, use_sideband, allow_tip_sha1_in_want;
 
 static void rev_list_push(struct commit *commit, int mark)


@@ -49,7 +50,7 @@ static void rev_list_push(struct commit *commit, int mark)
                        if (parse_commit(commit))
                                return;
 
                        if (parse_commit(commit))
                                return;
 

-               commit_list_insert_by_date(commit, &rev_list);
+               prio_queue_put(&rev_list, commit);

 
                if (!(commit->object.flags & COMMON))
                        non_common_revs++;
 
                if (!(commit->object.flags & COMMON))
                        non_common_revs++;


@@ -122,10 +123,10 @@ static const unsigned char *get_rev(void)
                unsigned int mark;
                struct commit_list *parents;
 
                unsigned int mark;
                struct commit_list *parents;
 

-               if (rev_list == NULL || non_common_revs == 0)
+               if (rev_list.nr == 0 || non_common_revs == 0)

                        return NULL;
 
                        return NULL;
 

-               commit = rev_list->item;
+               commit = prio_queue_get(&rev_list);

                if (!commit->object.parsed)
                        parse_commit(commit);
                parents = commit->parents;
                if (!commit->object.parsed)
                        parse_commit(commit);
                parents = commit->parents;


@@ -152,8 +153,6 @@ static const unsigned char *get_rev(void)
                                mark_common(parents->item, 1, 0);
                        parents = parents->next;
                }
                                mark_common(parents->item, 1, 0);
                        parents = parents->next;
                }

-
-               rev_list = rev_list->next;

        }
 
        return commit->object.sha1;
        }
 
        return commit->object.sha1;


@@ -442,7 +441,7 @@ static int find_common(struct fetch_pack_args *args,
                                        in_vain = 0;
                                        got_continue = 1;
                                        if (ack == ACK_ready) {
                                        in_vain = 0;
                                        got_continue = 1;
                                        if (ack == ACK_ready) {

-                                               rev_list = NULL;
+                                               clear_prio_queue(&rev_list);

                                                got_ready = 1;
                                        }
                                        break;
                                                got_ready = 1;
                                        }
                                        break;