diffcore-rename: enable filtering possible rename sources

Add the ability to diffcore_rename_extended() to allow external callers
to declare that they only need renames detected for a subset of source
files, and use that information to skip detecting renames for them.

There are two important pieces to this optimization that may not be
obvious at first glance:

  * We do not require callers to just filter the filepairs out
    to remove the non-relevant sources, because exact rename detection
    is fast and when it finds a match it can remove both a source and a
    destination whereas the relevant_sources filter can only remove a
    source.

  * We need to filter out the source pairs in a preliminary pass instead
    of adding a
       strset_contains(relevant_sources, one->path)
    check within the nested matrix loop.  The reason for that is if we
    have 30k renames, doing 30k * 30k = 900M strset_contains() calls
    becomes extraordinarily expensive and defeats the performance gains
    from this change; we only want to do 30k such calls instead.

If callers pass NULL for relevant_sources, that is special cases to
treat all sources as relevant.  Since all callers currently pass NULL,
this optimization does not yet have any effect.  Subsequent commits will
have merge-ort compute a set of relevant_sources to restrict which
sources we detect renames for, and have merge-ort pass that set of
relevant_sources to diffcore_rename_extended().

A note about filtering order:

Some may be curious why we don't filter out irrelevant sources at the
same time we filter out exact renames.  While that technically could be
done at this point, there are two reasons to defer it:

First, was to reinforce a lesson that was too easy to forget.  As I
mentioned above, in the past I filtered irrelevant sources out before
exact rename checking, and then discovered that exact renames' ability
to remove both sources and destinations was an important consideration
and thus doing the filtering after exact rename checking would speed
things up.  Then at some point I realized that basename matching could
also remove both sources and destinations, and decided to put irrelevant
source filtering after basename filtering.  That slowed things down a
lot.  But, despite learning about this important ordering, in later
restructuring I forgot and made the same mistake of putting the
filtering after basename guided rename detection again.  So, I have this
series of patches structured to do the irrelevant filtering last to
start to show how much extra it costs, and then add relevant filtering
in to find_basename_matches() to show how much it speeds things up.
Basically, it's a way to reinforce something that apparently was too
easy to forget, and make sure the commit messages record this lesson.

Second, the items in the "relevant_sources" in this patch series will
include all sources that *might be* relevant.  It has to be conservative
and catch anything that might need a rename, but in the patch series
after this one we'll find ways to weed out more of the *might be*
relevant ones.  Unfortunately, merge-ort does not have sufficient
information to weed those ones out, and there isn't enough information
at the time of filtering exact renames out to remove the extra ones
either.  It has to be deferred.  So the deferral is in part to simplify
some later additions.

Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/diffcore-rename.c b/diffcore-rename.c
index 1fe902ed2af0c526aa94d82481c9f930457bf324..7f6115fd90187701506f0983fa7646aa164c5c88 100644 (file)
--- a/diffcore-rename.c
+++ b/diffcore-rename.c
@@ -991,11 +991,12 @@ static int find_renames(struct diff_score *mx,
        return count;
 }
 
-static void remove_unneeded_paths_from_src(int detecting_copies)
+static void remove_unneeded_paths_from_src(int detecting_copies,
+                                          struct strset *interesting)
 {
        int i, new_num_src;
 
-       if (detecting_copies)
+       if (detecting_copies && !interesting)
                return; /* nothing to remove */
        if (break_idx)
                return; /* culling incompatible with break detection */
@@ -1022,12 +1023,18 @@ static void remove_unneeded_paths_from_src(int detecting_copies)
         *      from rename_src here.
         */
        for (i = 0, new_num_src = 0; i < rename_src_nr; i++) {
+               struct diff_filespec *one = rename_src[i].p->one;
+
                /*
                 * renames are stored in rename_dst, so if a rename has
                 * already been detected using this source, we can just
                 * remove the source knowing rename_dst has its info.
                 */
-               if (rename_src[i].p->one->rename_used)
+               if (!detecting_copies && one->rename_used)
+                       continue;
+
+               /* If we don't care about the source path, skip it */
+               if (interesting && !strset_contains(interesting, one->path))
                        continue;
 
                if (new_num_src < i)
@@ -1040,6 +1047,7 @@ static void remove_unneeded_paths_from_src(int detecting_copies)
 }
 
 void diffcore_rename_extended(struct diff_options *options,
+                             struct strset *relevant_sources,
                              struct strset *dirs_removed,
                              struct strmap *dir_rename_count)
 {
@@ -1060,6 +1068,8 @@ void diffcore_rename_extended(struct diff_options *options,
        want_copies = (detect_rename == DIFF_DETECT_COPY);
        if (dirs_removed && (break_idx || want_copies))
                BUG("dirs_removed incompatible with break/copy detection");
+       if (break_idx && relevant_sources)
+               BUG("break detection incompatible with source specification");
        if (!minimum_score)
                minimum_score = DEFAULT_RENAME_SCORE;
 
@@ -1127,9 +1137,10 @@ void diffcore_rename_extended(struct diff_options *options,
                /*
                 * Cull sources:
                 *   - remove ones corresponding to exact renames
+                *   - remove ones not found in relevant_sources
                 */
                trace2_region_enter("diff", "cull after exact", options->repo);
-               remove_unneeded_paths_from_src(want_copies);
+               remove_unneeded_paths_from_src(want_copies, relevant_sources);
                trace2_region_leave("diff", "cull after exact", options->repo);
        } else {
                /* Determine minimum score to match basenames */
@@ -1148,7 +1159,7 @@ void diffcore_rename_extended(struct diff_options *options,
                 *   - remove ones involved in renames (found via exact match)
                 */
                trace2_region_enter("diff", "cull after exact", options->repo);
-               remove_unneeded_paths_from_src(want_copies);
+               remove_unneeded_paths_from_src(want_copies, NULL);
                trace2_region_leave("diff", "cull after exact", options->repo);
 
                /* Preparation for basename-driven matching. */
@@ -1167,9 +1178,10 @@ void diffcore_rename_extended(struct diff_options *options,
                /*
                 * Cull sources, again:
                 *   - remove ones involved in renames (found via basenames)
+                *   - remove ones not found in relevant_sources
                 */
                trace2_region_enter("diff", "cull basename", options->repo);
-               remove_unneeded_paths_from_src(want_copies);
+               remove_unneeded_paths_from_src(want_copies, relevant_sources);
                trace2_region_leave("diff", "cull basename", options->repo);
        }
 
@@ -1342,5 +1354,5 @@ void diffcore_rename_extended(struct diff_options *options,
 
 void diffcore_rename(struct diff_options *options)
 {
-       diffcore_rename_extended(options, NULL, NULL);
+       diffcore_rename_extended(options, NULL, NULL, NULL);
 }

diff --git a/diffcore.h b/diffcore.h
index c6ba64abd198ac239069fa7c0fba5d42d0961604..737c93a6cc791d4dfffeae2ab8166029fc5fd7b7 100644 (file)
--- a/diffcore.h
+++ b/diffcore.h
@@ -166,6 +166,7 @@ void partial_clear_dir_rename_count(struct strmap *dir_rename_count);
 void diffcore_break(struct repository *, int);
 void diffcore_rename(struct diff_options *);
 void diffcore_rename_extended(struct diff_options *options,
+                             struct strset *relevant_sources,
                              struct strset *dirs_removed,
                              struct strmap *dir_rename_count);
 void diffcore_merge_broken(void);

diff --git a/merge-ort.c b/merge-ort.c
index 467404cc0a358c4187c7c8587b1c877c56aacbd2..aba0b9fa54c3b5caae6510c4308f2de719f536a1 100644 (file)
--- a/merge-ort.c
+++ b/merge-ort.c
@@ -2029,6 +2029,7 @@ static void detect_regular_renames(struct merge_options *opt,
        diff_queued_diff = renames->pairs[side_index];
        trace2_region_enter("diff", "diffcore_rename", opt->repo);
        diffcore_rename_extended(&diff_opts,
+                                NULL,
                                 &renames->dirs_removed[side_index],
                                 &renames->dir_rename_count[side_index]);
        trace2_region_leave("diff", "diffcore_rename", opt->repo);