Performance optimization for detection of modified submodules

PATCH In review Jens Lehmann 2 participants 4 messages Jun 15, 2016

Share & tools

Jens Lehmann

author

2016-06-15 22:48 UTC #0 lore raw

PATCH v2 1/1 Performance optimization for detection of modified submodules

In the worst case is_submodule_modified() got called three times for each submodule. The information we got from scanning the whole submodule tree the first time should not be thrown away.

New parameters have been added to diff_change() and diff_addremove(), the information is stored in a new member of struct diff_filespec. Its value is then reused instead of calling is_submodule_modified() again.

When no explicit "-dirty" is needed in the output the call to is_submodule_modified() is not necessary when the submodules HEAD already disagrees with the ref of the superproject, as this alone marks it as modified. To achieve that, get_stat_data() got an extra argument.

Signed-off-by Jens Lehmann <[email protected]>

---

Changed since the first version:

- diff_change() now has two dirty_submodule arguments, one for each side.

- If the submodules HEAD does not match the ref it is compared against, is_submodule_modified() is only called when the patch formatted output is requested.

- Changed the type of the new dirty_submodule flags to unsigned.

- Updated the commit message

 diff-lib.c  |   46 +++++++++++++++++++++++++++++++---------------
 diff.c      |   15 +++++++++++----
 diff.h      |   10 ++++++----
 diffcore.h  |    1 +
 revision.c  |    5 +++--
 tree-diff.c |    8 ++++----
 6 files changed, 56 insertions(+), 29 deletions(-)

diff-lib.c +31 ~~-15~~

index 29c5915..ec2e2ac 100644
@@ -73,6 +73,7 @@ int run_diff_files(struct rev_info *revs, unsigned int option)
 		unsigned int oldmode, newmode;
 		struct cache_entry *ce = active_cache[i];
 		int changed;
+		unsigned dirty_submodule = 0;
 
 		if (DIFF_OPT_TST(&revs->diffopt, QUICK) &&
 			DIFF_OPT_TST(&revs->diffopt, HAS_CHANGES))

@@ -173,12 +174,16 @@ int run_diff_files(struct rev_info *revs, unsigned int option)
 			if (silent_on_removed)
 				continue;
 			diff_addremove(&revs->diffopt, '-', ce->ce_mode,
-				       ce->sha1, ce->name);
+				       ce->sha1, ce->name, 0);
 			continue;
 		}
 		changed = ce_match_stat(ce, &st, ce_option);
-		if (S_ISGITLINK(ce->ce_mode) && !changed)
-			changed = is_submodule_modified(ce->name);
+		if (S_ISGITLINK(ce->ce_mode)
+		    && (!changed || (revs->diffopt.output_format & DIFF_FORMAT_PATCH))
+		    && is_submodule_modified(ce->name)) {
+			changed = 1;
+			dirty_submodule = 1;
+		}
 		if (!changed) {
 			ce_mark_uptodate(ce);
 			if (!DIFF_OPT_TST(&revs->diffopt, FIND_COPIES_HARDER))

@@ -188,7 +193,7 @@ int run_diff_files(struct rev_info *revs, unsigned int option)
 		newmode = ce_mode_from_stat(ce, st.st_mode);
 		diff_change(&revs->diffopt, oldmode, newmode,
 			    ce->sha1, (changed ? null_sha1 : ce->sha1),
-			    ce->name);
+			    ce->name, 0, dirty_submodule);
 
 	}
 	diffcore_std(&revs->diffopt);

@@ -204,16 +209,18 @@ int run_diff_files(struct rev_info *revs, unsigned int option)
 static void diff_index_show_file(struct rev_info *revs,
 				 const char *prefix,
 				 struct cache_entry *ce,
-				 const unsigned char *sha1, unsigned int mode)
+				 const unsigned char *sha1, unsigned int mode,
+				 unsigned dirty_submodule)
 {
 	diff_addremove(&revs->diffopt, prefix[0], mode,
-		       sha1, ce->name);
+		       sha1, ce->name, dirty_submodule);
 }
 
 static int get_stat_data(struct cache_entry *ce,
 			 const unsigned char **sha1p,
 			 unsigned int *modep,
-			 int cached, int match_missing)
+			 int cached, int match_missing,
+			 unsigned *dirty_submodule, int output_format)
 {
 	const unsigned char *sha1 = ce->sha1;
 	unsigned int mode = ce->ce_mode;

@@ -233,8 +240,13 @@ static int get_stat_data(struct cache_entry *ce,
 			return -1;
 		}
 		changed = ce_match_stat(ce, &st, 0);
-		if (changed
-		    || (S_ISGITLINK(ce->ce_mode) && is_submodule_modified(ce->name))) {
+		if (S_ISGITLINK(ce->ce_mode)
+		    && (!changed || (output_format & DIFF_FORMAT_PATCH))
+		    && is_submodule_modified(ce->name)) {
+			changed = 1;
+			*dirty_submodule = 1;
+		}
+		if (changed) {
 			mode = ce_mode_from_stat(ce, st.st_mode);
 			sha1 = null_sha1;
 		}

@@ -251,15 +263,17 @@ static void show_new_file(struct rev_info *revs,
 {
 	const unsigned char *sha1;
 	unsigned int mode;
+	unsigned dirty_submodule = 0;
 
 	/*
 	 * New file in the index: it might actually be different in
 	 * the working copy.
 	 */
-	if (get_stat_data(new, &sha1, &mode, cached, match_missing) < 0)
+	if (get_stat_data(new, &sha1, &mode, cached, match_missing,
+	    &dirty_submodule, revs->diffopt.output_format) < 0)
 		return;
 
-	diff_index_show_file(revs, "+", new, sha1, mode);
+	diff_index_show_file(revs, "+", new, sha1, mode, dirty_submodule);
 }
 
 static int show_modified(struct rev_info *revs,

@@ -270,11 +284,13 @@ static int show_modified(struct rev_info *revs,
 {
 	unsigned int mode, oldmode;
 	const unsigned char *sha1;
+	unsigned dirty_submodule = 0;
 
-	if (get_stat_data(new, &sha1, &mode, cached, match_missing) < 0) {
+	if (get_stat_data(new, &sha1, &mode, cached, match_missing,
+			  &dirty_submodule, revs->diffopt.output_format) < 0) {
 		if (report_missing)
 			diff_index_show_file(revs, "-", old,
-					     old->sha1, old->ce_mode);
+					     old->sha1, old->ce_mode, 0);
 		return -1;
 	}

@@ -309,7 +325,7 @@ static int show_modified(struct rev_info *revs,
 		return 0;
 
 	diff_change(&revs->diffopt, oldmode, mode,
-		    old->sha1, sha1, old->name);
+		    old->sha1, sha1, old->name, 0, dirty_submodule);
 	return 0;
 }

@@ -356,7 +372,7 @@ static void do_oneway_diff(struct unpack_trees_options *o,
 	 * Something removed from the tree?
 	 */
 	if (!idx) {
-		diff_index_show_file(revs, "-", tree, tree->sha1, tree->ce_mode);
+		diff_index_show_file(revs, "-", tree, tree->sha1, tree->ce_mode, 0);
 		return;
 	}

diff.c +11 -4

index 012b3d3..f130a36 100644
@@ -2032,7 +2032,7 @@ static int diff_populate_gitlink(struct diff_filespec *s, int size_only)
 	char *data = xmalloc(100), *dirty = "";
 
 	/* Are we looking at the work tree? */
-	if (!s->sha1_valid && is_submodule_modified(s->path))
+	if (!s->sha1_valid && s->dirty_submodule)
 		dirty = "-dirty";
 
 	len = snprintf(data, 100,

@@ -3736,7 +3736,7 @@ int diff_result_code(struct diff_options *opt, int status)
 void diff_addremove(struct diff_options *options,
 		    int addremove, unsigned mode,
 		    const unsigned char *sha1,
-		    const char *concatpath)
+		    const char *concatpath, unsigned dirty_submodule)
 {
 	struct diff_filespec *one, *two;

@@ -3768,8 +3768,10 @@ void diff_addremove(struct diff_options *options,
 
 	if (addremove != '+')
 		fill_filespec(one, sha1, mode);
-	if (addremove != '-')
+	if (addremove != '-') {
 		fill_filespec(two, sha1, mode);
+		two->dirty_submodule = dirty_submodule;
+	}
 
 	diff_queue(&diff_queued_diff, one, two);
 	if (!DIFF_OPT_TST(options, DIFF_FROM_CONTENTS))

@@ -3780,7 +3782,8 @@ void diff_change(struct diff_options *options,
 		 unsigned old_mode, unsigned new_mode,
 		 const unsigned char *old_sha1,
 		 const unsigned char *new_sha1,
-		 const char *concatpath)
+		 const char *concatpath,
+		 unsigned old_dirty_submodule, unsigned new_dirty_submodule)
 {
 	struct diff_filespec *one, *two;

@@ -3793,6 +3796,8 @@ void diff_change(struct diff_options *options,
 		const unsigned char *tmp_c;
 		tmp = old_mode; old_mode = new_mode; new_mode = tmp;
 		tmp_c = old_sha1; old_sha1 = new_sha1; new_sha1 = tmp_c;
+		tmp = old_dirty_submodule; old_dirty_submodule = new_dirty_submodule;
+			new_dirty_submodule = tmp;
 	}
 
 	if (options->prefix &&

@@ -3803,6 +3808,8 @@ void diff_change(struct diff_options *options,
 	two = alloc_filespec(concatpath);
 	fill_filespec(one, old_sha1, old_mode);
 	fill_filespec(two, new_sha1, new_mode);
+	one->dirty_submodule = old_dirty_submodule;
+	two->dirty_submodule = new_dirty_submodule;
 
 	diff_queue(&diff_queued_diff, one, two);
 	if (!DIFF_OPT_TST(options, DIFF_FROM_CONTENTS))

diff.h +6 -4

index 06a9a88..2ef3341 100644
@@ -14,12 +14,13 @@ typedef void (*change_fn_t)(struct diff_options *options,
 		 unsigned old_mode, unsigned new_mode,
 		 const unsigned char *old_sha1,
 		 const unsigned char *new_sha1,
-		 const char *fullpath);
+		 const char *fullpath,
+		 unsigned old_dirty_submodule, unsigned new_dirty_submodule);
 
 typedef void (*add_remove_fn_t)(struct diff_options *options,
 		    int addremove, unsigned mode,
 		    const unsigned char *sha1,
-		    const char *fullpath);
+		    const char *fullpath, unsigned dirty_submodule);
 
 typedef void (*diff_format_fn_t)(struct diff_queue_struct *q,
 		struct diff_options *options, void *data);

@@ -177,13 +178,14 @@ extern void diff_addremove(struct diff_options *,
 			   int addremove,
 			   unsigned mode,
 			   const unsigned char *sha1,
-			   const char *fullpath);
+			   const char *fullpath, unsigned dirty_submodule);
 
 extern void diff_change(struct diff_options *,
 			unsigned mode1, unsigned mode2,
 			const unsigned char *sha1,
 			const unsigned char *sha2,
-			const char *fullpath);
+			const char *fullpath,
+			unsigned dirty_submodule1, unsigned dirty_submodule2);
 
 extern void diff_unmerge(struct diff_options *,
 			 const char *path,

diffcore.h +1 -0

index 5b63458..66687c3 100644
@@ -42,6 +42,7 @@ struct diff_filespec {
 #define DIFF_FILE_VALID(spec) (((spec)->mode) != 0)
 	unsigned should_free : 1; /* data should be free()'ed */
 	unsigned should_munmap : 1; /* data should be munmap()'ed */
+	unsigned dirty_submodule : 1;  /* For submodules: its work tree is dirty */
 
 	struct userdiff_driver *driver;
 	/* data should be considered "binary"; -1 means "don't know yet" */

revision.c +3 -2

index 25fa14d..769cfd4 100644
@@ -268,7 +268,7 @@ static int tree_difference = REV_TREE_SAME;
 static void file_add_remove(struct diff_options *options,
 		    int addremove, unsigned mode,
 		    const unsigned char *sha1,
-		    const char *fullpath)
+		    const char *fullpath, unsigned dirty_submodule)
 {
 	int diff = addremove == '+' ? REV_TREE_NEW : REV_TREE_OLD;

@@ -281,7 +281,8 @@ static void file_change(struct diff_options *options,
 		 unsigned old_mode, unsigned new_mode,
 		 const unsigned char *old_sha1,
 		 const unsigned char *new_sha1,
-		 const char *fullpath)
+		 const char *fullpath,
+		 unsigned old_dirty_submodule, unsigned new_dirty_submodule)
 {
 	tree_difference = REV_TREE_DIFFERENT;
 	DIFF_OPT_SET(options, HAS_CHANGES);

tree-diff.c +4 -4

index 7d745b4..fe9f52c 100644
@@ -68,7 +68,7 @@ static int compare_tree_entry(struct tree_desc *t1, struct tree_desc *t2, const
 		if (DIFF_OPT_TST(opt, TREE_IN_RECURSIVE)) {
 			newbase[baselen + pathlen1] = 0;
 			opt->change(opt, mode1, mode2,
-				    sha1, sha2, newbase);
+				    sha1, sha2, newbase, 0, 0);
 			newbase[baselen + pathlen1] = '/';
 		}
 		retval = diff_tree_sha1(sha1, sha2, newbase, opt);

@@ -77,7 +77,7 @@ static int compare_tree_entry(struct tree_desc *t1, struct tree_desc *t2, const
 	}
 
 	fullname = malloc_fullname(base, baselen, path1, pathlen1);
-	opt->change(opt, mode1, mode2, sha1, sha2, fullname);
+	opt->change(opt, mode1, mode2, sha1, sha2, fullname, 0, 0);
 	free(fullname);
 	return 0;
 }

@@ -241,7 +241,7 @@ static void show_entry(struct diff_options *opt, const char *prefix, struct tree
 
 		if (DIFF_OPT_TST(opt, TREE_IN_RECURSIVE)) {
 			newbase[baselen + pathlen] = 0;
-			opt->add_remove(opt, *prefix, mode, sha1, newbase);
+			opt->add_remove(opt, *prefix, mode, sha1, newbase, 0);
 			newbase[baselen + pathlen] = '/';
 		}

@@ -252,7 +252,7 @@ static void show_entry(struct diff_options *opt, const char *prefix, struct tree
 		free(newbase);
 	} else {
 		char *fullname = malloc_fullname(base, baselen, path, pathlen);
-		opt->add_remove(opt, prefix[0], mode, sha1, fullname);
+		opt->add_remove(opt, prefix[0], mode, sha1, fullname, 0);
 		free(fullname);
 	}
 }

Signature · 1 line

1.6.6.444.g4e34e.dirty

Junio C Hamano

2016-06-15 22:48 UTC #1 lore raw

Quoted 1 line · Jens Lehmann

- Changed the type of the new dirty_submodule flags to unsigned.

Why? An unsigned used in place of a bool raises an eyebrow as it is more common to use "int" (the most natural type on the platform). Going against tradition makes readers waste time wondering if there were some other reason why the code couldn't use "int" and had to use "unsigned" (e.g. "Hmmpphh, it looked like a mere boolean but the use of 'unsigned' suggests there might be something deeper going on. Is this used as a bitfield? Does this count and cannot go negative?").

diff-lib.c int run_diff_files(struct rev_info *revs, unsigned int option) · line 177

Quoted 6 lines

diff-lib.c +1 -1

@@ -173,12 +174,16 @@ int run_diff_files(struct rev_info *revs, unsigned int option)
 			if (silent_on_removed)
 				continue;
 			diff_addremove(&revs->diffopt, '-', ce->ce_mode,
-				       ce->sha1, ce->name);
+				       ce->sha1, ce->name, 0);

Removed from work tree; cannot be dirty---good.

diff-lib.c int run_diff_files(struct rev_info *revs, unsigned int option) · line 186

Quoted 6 lines

diff-lib.c +6 -0

+		if (S_ISGITLINK(ce->ce_mode)
+		    && (!changed || (revs->diffopt.output_format & DIFF_FORMAT_PATCH))
+		    && is_submodule_modified(ce->name)) {
+			changed = 1;
+			dirty_submodule = 1;
+		}

If the index records a submodule commit, and the commit checked out in the submodule is different from that commit, ce_compare_gitlink() called from ce_match_stat() would have already said "changed". If we want "-dirty", we need to call is_submodule_modified(), but otherwise we don't. Looks good.

Does DIFF_FORMAT_PATCH cover all cases where we may want a reliable value in "dirty_submodule" here? Should use of "--submodule=log" affect this decision?

diff-lib.c int run_diff_files(struct rev_info *revs, unsigned int option) · line 196

Quoted 6 lines

diff-lib.c +1 -1

@@ -188,7 +193,7 @@ int run_diff_files(struct rev_info *revs, unsigned int option)
 		newmode = ce_mode_from_stat(ce, st.st_mode);
 		diff_change(&revs->diffopt, oldmode, newmode,
 			    ce->sha1, (changed ? null_sha1 : ce->sha1),
-			    ce->name);
+			    ce->name, 0, dirty_submodule);

LHS is always index and RHS is work tree whose dirtiness is in dirty_submodule; good.

diff-lib.c int run_diff_files(struct rev_info *revs, unsigned int option) · line 216

Quoted 11 lines

diff-lib.c +3 -2

@@ -204,16 +209,18 @@ int run_diff_files(struct rev_info *revs, unsigned int option)
 static void diff_index_show_file(struct rev_info *revs,
 				 const char *prefix,
 				 struct cache_entry *ce,
-				 const unsigned char *sha1, unsigned int mode)
+				 const unsigned char *sha1, unsigned int mode,
+				 unsigned dirty_submodule)
 {
 	diff_addremove(&revs->diffopt, prefix[0], mode,
-		       sha1, ce->name);
+		       sha1, ce->name, dirty_submodule);

Mental note to myself. prefix[0] is either '-' (removed from the work tree) or '+' (added to the work tree). Added submodule could be immediately dirty.

diff-lib.c static void show_new_file(struct rev_info *revs, · line 276

Quoted 5 lines

diff-lib.c +1 -1

@@ -251,15 +263,17 @@ static void show_new_file(struct rev_info *revs,
 {
...
-	diff_index_show_file(revs, "+", new, sha1, mode);
+	diff_index_show_file(revs, "+", new, sha1, mode, dirty_submodule);

And this caller handles that case correctly; good.

diff-lib.c static int show_modified(struct rev_info *revs, · line 293

Quoted 13 lines

diff-lib.c +4 -2

@@ -270,11 +284,13 @@ static int show_modified(struct rev_info *revs,
 {
 	unsigned int mode, oldmode;
 	const unsigned char *sha1;
+	unsigned dirty_submodule = 0;
 
-	if (get_stat_data(new, &sha1, &mode, cached, match_missing) < 0) {
+	if (get_stat_data(new, &sha1, &mode, cached, match_missing,
+			  &dirty_submodule, revs->diffopt.output_format) < 0) {
 		if (report_missing)
 			diff_index_show_file(revs, "-", old,
-					     old->sha1, old->ce_mode);
+					     old->sha1, old->ce_mode, 0);

Again, removed from work tree cannot be dirty; good.

diff-lib.c static int show_modified(struct rev_info *revs, · line 330

Quoted 8 lines

diff-lib.c +1 -1

@@ -309,7 +325,7 @@ static int show_modified(struct rev_info *revs,
 		return 0;
 
 	diff_change(&revs->diffopt, oldmode, mode,
-		    old->sha1, sha1, old->name);
+		    old->sha1, sha1, old->name, 0, dirty_submodule);
 	return 0;
 }

Comparing between a tree entry and either an index entry or a file in the work tree. When cached (i.e. not looking at work tree), get_stat_data() doesn't touch dirty_submodule, so this won't make noises about submodule dirtyness, which is good.

diff-lib.c static void do_oneway_diff(struct unpack_trees_options *o, · line 375

Quoted 6 lines

diff-lib.c +1 -1

@@ -356,7 +372,7 @@ static void do_oneway_diff(struct unpack_trees_options *o,
 	 * Something removed from the tree?
 	 */
 	if (!idx) {
-		diff_index_show_file(revs, "-", tree, tree->sha1, tree->ce_mode);
+		diff_index_show_file(revs, "-", tree, tree->sha1, tree->ce_mode, 0);

Removed from the work tree and canont be dirty; good.

diff.c int diff_result_code(struct diff_options *opt, int status) · line 3739

Quoted 10 lines

diff.c +1 -1

index 012b3d3..f130a36 100644
@@ -3736,7 +3736,7 @@ int diff_result_code(struct diff_options *opt, int status)
 void diff_addremove(struct diff_options *options,
 		    int addremove, unsigned mode,
 		    const unsigned char *sha1,
-		    const char *concatpath)
+		    const char *concatpath, unsigned dirty_submodule)

A removed submodule cannot be dirty, so we can get away with only one dirty_submodule that always refers to the RHS (i.e. "two"); I see.

diffcore.h struct diff_filespec { · line 45

Quoted 9 lines

diffcore.h +1 -0

index 5b63458..66687c3 100644
@@ -42,6 +42,7 @@ struct diff_filespec {
 #define DIFF_FILE_VALID(spec) (((spec)->mode) != 0)
 	unsigned should_free : 1; /* data should be free()'ed */
 	unsigned should_munmap : 1; /* data should be munmap()'ed */
+	unsigned dirty_submodule : 1;  /* For submodules: its work tree is dirty */

By the way, we might want to consolidate these bitfields into a single

	unsigned should_free:1,
        	 should_munmap:1,
                 dirty_submodule:1;

in a separate clean-up patch, after all the dust settles.

Jens Lehmann

author

2016-06-15 22:48 UTC #2 lore raw

Am 19.01.2010 02:44, schrieb Junio C Hamano:

Quoted 11 lines

Quoted 1 line · Jens Lehmann
- Changed the type of the new dirty_submodule flags to unsigned.
Why? An unsigned used in place of a bool raises an eyebrow as it is more common to use "int" (the most natural type on the platform). Going against tradition makes readers waste time wondering if there were some other reason why the code couldn't use "int" and had to use "unsigned" (e.g. "Hmmpphh, it looked like a mere boolean but the use of 'unsigned' suggests there might be something deeper going on. Is this used as a bitfield? Does this count and cannot go negative?").

I am working on a subsequent patch where dirty_submodule is used as a bitfield to store more detailed information about the dirtiness. That is then used by "git diff --submodule" to tell the user if the submodule contains untracked and/or modified files.

But i can revert that part if you want.

Quoted 13 lines

diff-lib.c int run_diff_files(struct rev_info *revs, unsigned int option) · line 186
Quoted 6 lines
diff-lib.c +6 -0
+		if (S_ISGITLINK(ce->ce_mode)
+		    && (!changed || (revs->diffopt.output_format & DIFF_FORMAT_PATCH))
+		    && is_submodule_modified(ce->name)) {
+			changed = 1;
+			dirty_submodule = 1;
+		}
If the index records a submodule commit, and the commit checked out in the submodule is different from that commit, ce_compare_gitlink() called from ce_match_stat() would have already said "changed". If we want "-dirty", we need to call is_submodule_modified(), but otherwise we don't. Looks good.

Quoted 3 lines

Does DIFF_FORMAT_PATCH cover all cases where we may want a reliable value in "dirty_submodule" here? Should use of "--submodule=log" affect this decision?

In my testing "git diff --submodule=log" has DIFF_FORMAT_PATCH set too.

Quoted 7 lines

diff-lib.c +2 -1

@@ -204,16 +209,18 @@ int run_diff_files(struct rev_info *revs, unsigned int option)
 static void diff_index_show_file(struct rev_info *revs,
 				 const char *prefix,
 				 struct cache_entry *ce,
-				 const unsigned char *sha1, unsigned int mode)
+				 const unsigned char *sha1, unsigned int mode,
+				 unsigned dirty_submodule)

Quoted 8 lines

diff-lib.c int run_diff_files(struct rev_info *revs, unsigned int option) · line 216
Quoted 4 lines
diff-lib.c +1 -1
 {
 	diff_addremove(&revs->diffopt, prefix[0], mode,
-		       sha1, ce->name);
+		       sha1, ce->name, dirty_submodule);
Mental note to myself. prefix[0] is either '-' (removed from the work tree) or '+' (added to the work tree). Added submodule could be immediately dirty.

Should i add a comment there?

Quoted 12 lines

diffcore.h struct diff_filespec { · line 45

Quoted 9 lines

diffcore.h +1 -0

index 5b63458..66687c3 100644
@@ -42,6 +42,7 @@ struct diff_filespec {
 #define DIFF_FILE_VALID(spec) (((spec)->mode) != 0)
 	unsigned should_free : 1; /* data should be free()'ed */
 	unsigned should_munmap : 1; /* data should be munmap()'ed */
+	unsigned dirty_submodule : 1;  /* For submodules: its work tree is dirty */

By the way, we might want to consolidate these bitfields into a single

Quoted 5 lines

	unsigned should_free:1,
        	 should_munmap:1,
                 dirty_submodule:1;
in a separate clean-up patch, after all the dust settles.

Okay.

Junio C Hamano

2016-06-15 22:48 UTC #3 lore raw

Quoted 6 lines · Jens Lehmann

I am working on a subsequent patch where dirty_submodule is used as a bitfield to store more detailed information about the dirtiness. That is then used by "git diff --submodule" to tell the user if the submodule contains untracked and/or modified files.
But i can revert that part if you want.

"Will be used as bitfield in later patches" is a justification that was missing; with that I think the patch is Ok as-is.

Quoted 5 lines

Quoted 3 lines
Mental note to myself. prefix[0] is either '-' (removed from the work tree) or '+' (added to the work tree). Added submodule could be immediately dirty.
Should i add a comment there?

Meh, that was just me thinking aloud.

Thanks.