@matheusbsbs / matheus-bagliano / commits / 2eac2a4cc4

ls-files -k: a directory only can be killed if the index has a non-directory

"ls-files -o" and "ls-files -k" both traverse the working tree down to find either all untracked paths or those that will be "killed" (removed from the working tree to make room) when the paths recorded in the index are checked out. It is necessary to traverse the working tree fully when enumerating all the "other" paths, but when we are only interested in "killed" paths, we can take advantage of the fact that paths that do not overlap with entries in the index can never be killed. The treat_one_path() helper function, which is called during the recursive traversal, is the ideal place to implement an optimization. When we are looking at a directory P in the working tree, there are three cases: (1) P exists in the index. Everything inside the directory P in the working tree needs to go when P is checked out from the index. (2) P does not exist in the index, but there is P/Q in the index. We know P will stay a directory when we check out the contents of the index, but we do not know yet if there is a directory P/Q in the working tree to be killed, so we need to recurse. (3) P does not exist in the index, and there is no P/Q in the index to require P to be a directory, either. Only in this case, we know that everything inside P will not be killed without recursing. Note that this helper is called by treat_leading_path() that decides if we need to traverse only subdirectories of a single common leading directory, which is essential for this optimization to be correct. This caller checks each level of the leading path component from shallower directory to deeper ones, and that is what allows us to only check if the path appears in the index. If the call to treat_one_path() weren't there, given a path P/Q/R, the real traversal may start from directory P/Q/R, even when the index records P as a regular file, and we would end up having to check if any leading subpath in P/Q/R, e.g. P, appears in the index. Signed-off-by: Junio C Hamano <gitster@pobox.com>

Junio C Hamano committed Aug 15, 2013 at 12:13 UTC 2eac2a4cc4bdc8d77b31204bc20751cb56f0d575

3 files changed +31 -3

builtin/ls-files.c

@@ -213,6 +213,8 @@ static void show_files(struct dir_struct *dir)

213

214 /* For cached/deleted files we don't need to even do the readdir */

215 if (show_others || show_killed) {

216 + if (!show_others)

217 + dir->flags |= DIR_COLLECT_KILLED_ONLY;

218 fill_directory(dir, pathspec);

219 if (show_others)

220 show_other_files(dir);

dir.c

+27 -2

@@ -1173,12 +1173,37 @@ static enum path_treatment treat_one_path(struct dir_struct *dir,

1173 int dtype, struct dirent *de)

1174 {

1175 int exclude;

1176 + int has_path_in_index = !!cache_name_exists(path->buf, path->len, ignore_case);

1177 +

1178 if (dtype == DT_UNKNOWN)

1179 dtype = get_dtype(de, path->buf, path->len);

1180

1181 /* Always exclude indexed files */

1180 - if (dtype != DT_DIR &&

1181 - cache_name_exists(path->buf, path->len, ignore_case))

1182 + if (dtype != DT_DIR && has_path_in_index)

1183 + return path_none;

1184 +

1185 + /*

1186 + * When we are looking at a directory P in the working tree,

1187 + * there are three cases:

1188 + *

1189 + * (1) P exists in the index. Everything inside the directory P in

1190 + * the working tree needs to go when P is checked out from the

1191 + * index.

1192 + *

1193 + * (2) P does not exist in the index, but there is P/Q in the index.

1194 + * We know P will stay a directory when we check out the contents

1195 + * of the index, but we do not know yet if there is a directory

1196 + * P/Q in the working tree to be killed, so we need to recurse.

1197 + *

1198 + * (3) P does not exist in the index, and there is no P/Q in the index

1199 + * to require P to be a directory, either. Only in this case, we

1200 + * know that everything inside P will not be killed without

1201 + * recursing.

1202 + */

1203 + if ((dir->flags & DIR_COLLECT_KILLED_ONLY) &&

1204 + (dtype == DT_DIR) &&

1205 + !has_path_in_index &&

1206 + (directory_exists_in_index(path->buf, path->len) == index_nonexistent))

1207 return path_none;

1208

1209 exclude = is_excluded(dir, path->buf, &dtype);

dir.h

+2 -1

@@ -80,7 +80,8 @@ struct dir_struct {

80 DIR_HIDE_EMPTY_DIRECTORIES = 1<<2,

81 DIR_NO_GITLINKS = 1<<3,

82 DIR_COLLECT_IGNORED = 1<<4,

83 - DIR_SHOW_IGNORED_TOO = 1<<5

83 + DIR_SHOW_IGNORED_TOO = 1<<5,

84 + DIR_COLLECT_KILLED_ONLY = 1<<6

85 } flags;

86 struct dir_entry **entries;

87 struct dir_entry **ignored;