merge-ort: add a new mergeability_only option

Git Forges may be interested in whether two branches can be merged while
not being interested in what the resulting merge tree is nor which files
conflicted.  For such cases, add a new mergeability_only option.  This
option allows the merge machinery to, in the "outer layer" of the merge:
  * exit upon first[-ish] conflict
  * avoid (not prevent) writing merged blobs/trees to the object store

I have a number of qualifiers there, so let me explain each:

"outer layer":

Note that since the recursive merge of merge bases (corresponding to
call_depth > 0) can conflict without the outer final merge
(corresponding to call_depth == 0) conflicting, we can't short-circuit
nor avoid writing merged blobs/trees to the object store during those
inner merges.

"first-ish conflict":

The current patch only exits early from process_entries() on the first
conflict it detects, but conflicts could have been detected in a
previous function call, namely detect_and_process_renames().  However:
  * conflicts detected by detect_and_process_renames() are quite rare
    conflict types
  * the detection would still come after regular rename detection
    (which is the expensive part of detect_and_process_renames()), so
    it is not saving us much in computation time given that
    process_entries() directly follows detect_and_process_renames()
  * [this overlaps with the next bullet point] process_entries() is the
    place where virtually all object writing occurs (object writing is
    sometimes more of a concern for Forges than computation time), so
    exiting early here isn't saving us much in object writes either
  * the code changes needed to handle an earlier exit are slightly
    more invasive in detect_and_process_renames() than for
    process_entries().
Given the rareness of the even earlier conflicts, the limited savings
we'd get from exiting even earlier, and in an attempt to keep this
patch simpler, we don't guarantee that we actually exit on the first
conflict detected.  We can always revisit this decision later if we
decide that a further micro-optimization to exit slightly earlier in
rare cases is worthwhile.

"avoid (not prevent) writing objects":

The detect_and_process_renames() call can also write objects to the
object store, when rename/rename conflicts involve one (or more) files
that have also been modified on both sides.  Because of this alternate
call path leading to handle_content_merges(), our "early exit" does not
prevent writing objects entirely, even within the "outer layer"
(i.e. even within call_depth == 0).  I figure that's fine though, since
we're already writing objects for the inner merges (i.e. for call_depth
> 0), which are likely going to represent vastly more objects than files
involved in rename/rename+modify/modify cases in the outer merge, on
average.

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

diff --git a/merge-ort.c b/merge-ort.c
index 77310a4a52c972c11560afb6e882222a947b84e5..47b3d1730ece367020eb6c9736c6419f6cd9372f 100644 (file)
--- a/merge-ort.c
+++ b/merge-ort.c
@@ -2127,6 +2127,7 @@ static int handle_content_merge(struct merge_options *opt,
                                const struct version_info *b,
                                const char *pathnames[3],
                                const int extra_marker_size,
+                               const int record_object,
                                struct version_info *result)
 {
        /*
@@ -2214,7 +2215,7 @@ static int handle_content_merge(struct merge_options *opt,
                        ret = -1;
                }
 
-               if (!ret &&
+               if (!ret && record_object &&
                    write_object_file(result_buf.ptr, result_buf.size,
                                      OBJ_BLOB, &result->oid)) {
                        path_msg(opt, ERROR_OBJECT_WRITE_FAILED, 0,
@@ -2897,6 +2898,7 @@ static int process_renames(struct merge_options *opt,
                        struct version_info merged;
                        struct conflict_info *base, *side1, *side2;
                        unsigned was_binary_blob = 0;
+                       const int record_object = true;
 
                        pathnames[0] = oldpath;
                        pathnames[1] = newpath;
@@ -2947,6 +2949,7 @@ static int process_renames(struct merge_options *opt,
                                                           &side2->stages[2],
                                                           pathnames,
                                                           1 + 2 * opt->priv->call_depth,
+                                                          record_object,
                                                           &merged);
                        if (clean_merge < 0)
                                return -1;
@@ -3061,6 +3064,7 @@ static int process_renames(struct merge_options *opt,
 
                        struct conflict_info *base, *side1, *side2;
                        int clean;
+                       const int record_object = true;
 
                        pathnames[0] = oldpath;
                        pathnames[other_source_index] = oldpath;
@@ -3080,6 +3084,7 @@ static int process_renames(struct merge_options *opt,
                                                     &side2->stages[2],
                                                     pathnames,
                                                     1 + 2 * opt->priv->call_depth,
+                                                    record_object,
                                                     &merged);
                        if (clean < 0)
                                return -1;
@@ -3931,9 +3936,12 @@ static int write_completed_directory(struct merge_options *opt,
                 * Write out the tree to the git object directory, and also
                 * record the mode and oid in dir_info->result.
                 */
+               int record_tree = (!opt->mergeability_only ||
+                                  opt->priv->call_depth);
                dir_info->is_null = 0;
                dir_info->result.mode = S_IFDIR;
-               if (write_tree(&dir_info->result.oid, &info->versions, offset,
+               if (record_tree &&
+                   write_tree(&dir_info->result.oid, &info->versions, offset,
                               opt->repo->hash_algo->rawsz) < 0)
                        ret = -1;
        }
@@ -4231,10 +4239,13 @@ static int process_entry(struct merge_options *opt,
                struct version_info *o = &ci->stages[0];
                struct version_info *a = &ci->stages[1];
                struct version_info *b = &ci->stages[2];
+               int record_object = (!opt->mergeability_only ||
+                                    opt->priv->call_depth);
 
                clean_merge = handle_content_merge(opt, path, o, a, b,
                                                   ci->pathnames,
                                                   opt->priv->call_depth * 2,
+                                                  record_object,
                                                   &merged_file);
                if (clean_merge < 0)
                        return -1;
@@ -4395,6 +4406,8 @@ static int process_entries(struct merge_options *opt,
                                                   STRING_LIST_INIT_NODUP,
                                                   NULL, 0 };
        int ret = 0;
+       const int record_tree = (!opt->mergeability_only ||
+                                opt->priv->call_depth);
 
        trace2_region_enter("merge", "process_entries setup", opt->repo);
        if (strmap_empty(&opt->priv->paths)) {
@@ -4454,6 +4467,12 @@ static int process_entries(struct merge_options *opt,
                                ret = -1;
                                goto cleanup;
                        };
+                       if (!ci->merged.clean && opt->mergeability_only &&
+                           !opt->priv->call_depth) {
+                               ret = 0;
+                               goto cleanup;
+                       }
+
                }
        }
        trace2_region_leave("merge", "processing", opt->repo);
@@ -4468,7 +4487,8 @@ static int process_entries(struct merge_options *opt,
                fflush(stdout);
                BUG("dir_metadata accounting completely off; shouldn't happen");
        }
-       if (write_tree(result_oid, &dir_metadata.versions, 0,
+       if (record_tree &&
+           write_tree(result_oid, &dir_metadata.versions, 0,
                       opt->repo->hash_algo->rawsz) < 0)
                ret = -1;
 cleanup:
@@ -4715,6 +4735,8 @@ void merge_display_update_messages(struct merge_options *opt,
 
        if (opt->record_conflict_msgs_as_headers)
                BUG("Either display conflict messages or record them as headers, not both");
+       if (opt->mergeability_only)
+               BUG("Displaying conflict messages incompatible with mergeability-only checks");
 
        trace2_region_enter("merge", "display messages", opt->repo);
 
@@ -5171,10 +5193,12 @@ redo:
        result->path_messages = &opt->priv->conflicts;
 
        if (result->clean >= 0) {
-               result->tree = parse_tree_indirect(&working_tree_oid);
-               if (!result->tree)
-                       die(_("unable to read tree (%s)"),
-                           oid_to_hex(&working_tree_oid));
+               if (!opt->mergeability_only) {
+                       result->tree = parse_tree_indirect(&working_tree_oid);
+                       if (!result->tree)
+                               die(_("unable to read tree (%s)"),
+                                   oid_to_hex(&working_tree_oid));
+               }
                /* existence of conflicted entries implies unclean */
                result->clean &= strmap_empty(&opt->priv->conflicted);
        }

diff --git a/merge-ort.h b/merge-ort.h
index 30750c03962f2cb42c2f01cba10e27a067c85673..6045579825da8bfbf52c70904b89faa080dff7e5 100644 (file)
--- a/merge-ort.h
+++ b/merge-ort.h
@@ -83,6 +83,7 @@ struct merge_options {
        /* miscellaneous control options */
        const char *subtree_shift;
        unsigned renormalize : 1;
+       unsigned mergeability_only : 1; /* exit early, write fewer objects */
        unsigned record_conflict_msgs_as_headers : 1;
        const char *msg_header_prefix;