@matheusbsbs / matheus-bagliano / commits / 52894e7095

tree-diff: rework diff_tree interface to be sha1 based

In the next commit this will allow to reduce intermediate calls, when recursing into subtrees - at that stage we know only subtree sha1, and it is natural for tree walker to start from that phase. For now we do diff_tree show_path diff_tree_sha1 diff_tree ... and the change will allow to reduce it to diff_tree show_path diff_tree Also, it will allow to omit allocating strbuf for each subtree, and just reuse the common strbuf via playing with its len. The above-mentioned improvements go in the next 2 patches. The downside is that try_to_follow_renames(), if active, we cause re-reading of 2 initial trees, which was negligible based on my timings, and which is outweighed cogently by the upsides. NOTE To keep with the current interface and semantics, I needed to rename the function from diff_tree() to diff_tree_sha1(). As diff_tree_sha1() was already used, and the function we are talking here is its more low-level helper, let's use convention for prefixing such helpers with "ll_". So the final renaming is diff_tree() -> ll_diff_tree_sha1() Signed-off-by: Kirill Smelkov <kirr@mns.spb.ru> Signed-off-by: Junio C Hamano <gitster@pobox.com>

Kirill Smelkov committed Mar 27, 2014 at 18:24 UTC 52894e70951518e44c064cef2561aed38202fd36

1 file changed +28 -32

tree-diff.c

+28 -32

@@ -141,12 +141,17 @@ static void skip_uninteresting(struct tree_desc *t, struct strbuf *base,

141 }

142 }

143

144 -static int diff_tree(struct tree_desc *t1, struct tree_desc *t2,

145 - const char *base_str, struct diff_options *opt)

144 +static int ll_diff_tree_sha1(const unsigned char *old, const unsigned char *new,

145 + const char *base_str, struct diff_options *opt)

146 {

147 + struct tree_desc t1, t2;

148 + void *t1tree, *t2tree;

149 struct strbuf base;

150 int baselen = strlen(base_str);

151

152 + t1tree = fill_tree_descriptor(&t1, old);

153 + t2tree = fill_tree_descriptor(&t2, new);

154 +

155 /* Enable recursion indefinitely */

156 opt->pathspec.recursive = DIFF_OPT_TST(opt, RECURSIVE);

157

@@ -159,39 +164,41 @@ static int diff_tree(struct tree_desc *t1, struct tree_desc *t2,

164 if (diff_can_quit_early(opt))

165 break;

166 if (opt->pathspec.nr) {

162 - skip_uninteresting(t1, &base, opt);

163 - skip_uninteresting(t2, &base, opt);

167 + skip_uninteresting(&t1, &base, opt);

168 + skip_uninteresting(&t2, &base, opt);

169 }

165 - if (!t1->size && !t2->size)

170 + if (!t1.size && !t2.size)

171 break;

172

168 - cmp = tree_entry_pathcmp(t1, t2);

173 + cmp = tree_entry_pathcmp(&t1, &t2);

174

175 /* t1 = t2 */

176 if (cmp == 0) {

177 if (DIFF_OPT_TST(opt, FIND_COPIES_HARDER) ||

173 - hashcmp(t1->entry.sha1, t2->entry.sha1) ||

174 - (t1->entry.mode != t2->entry.mode))

175 - show_path(&base, opt, t1, t2);

178 + hashcmp(t1.entry.sha1, t2.entry.sha1) ||

179 + (t1.entry.mode != t2.entry.mode))

180 + show_path(&base, opt, &t1, &t2);

181

177 - update_tree_entry(t1);

178 - update_tree_entry(t2);

182 + update_tree_entry(&t1);

183 + update_tree_entry(&t2);

184 }

185

186 /* t1 < t2 */

187 else if (cmp < 0) {

183 - show_path(&base, opt, t1, /*t2=*/NULL);

184 - update_tree_entry(t1);

188 + show_path(&base, opt, &t1, /*t2=*/NULL);

189 + update_tree_entry(&t1);

190 }

191

192 /* t1 > t2 */

193 else {

189 - show_path(&base, opt, /*t1=*/NULL, t2);

190 - update_tree_entry(t2);

194 + show_path(&base, opt, /*t1=*/NULL, &t2);

195 + update_tree_entry(&t2);

196 }

197 }

198

199 strbuf_release(&base);

200 + free(t2tree);

201 + free(t1tree);

202 return 0;

203 }

204

@@ -206,7 +213,7 @@ static inline int diff_might_be_rename(void)

213 !DIFF_FILE_VALID(diff_queued_diff.queue[0]->one);

214 }

215

209 -static void try_to_follow_renames(struct tree_desc *t1, struct tree_desc *t2, const char *base, struct diff_options *opt)

216 +static void try_to_follow_renames(const unsigned char *old, const unsigned char *new, const char *base, struct diff_options *opt)

217 {

218 struct diff_options diff_opts;

219 struct diff_queue_struct *q = &diff_queued_diff;

@@ -244,7 +251,7 @@ static void try_to_follow_renames(struct tree_desc *t1, struct tree_desc *t2, co

251 diff_opts.break_opt = opt->break_opt;

252 diff_opts.rename_score = opt->rename_score;

253 diff_setup_done(&diff_opts);

247 - diff_tree(t1, t2, base, &diff_opts);

254 + ll_diff_tree_sha1(old, new, base, &diff_opts);

255 diffcore_std(&diff_opts);

256 free_pathspec(&diff_opts.pathspec);

257

@@ -305,23 +312,12 @@ static void try_to_follow_renames(struct tree_desc *t1, struct tree_desc *t2, co

312

313 int diff_tree_sha1(const unsigned char *old, const unsigned char *new, const char *base, struct diff_options *opt)

314 {

308 - void *tree1, *tree2;

309 - struct tree_desc t1, t2;

310 - unsigned long size1, size2;

315 int retval;

316

313 - tree1 = fill_tree_descriptor(&t1, old);

314 - tree2 = fill_tree_descriptor(&t2, new);

315 - size1 = t1.size;

316 - size2 = t2.size;

317 - retval = diff_tree(&t1, &t2, base, opt);

318 - if (!*base && DIFF_OPT_TST(opt, FOLLOW_RENAMES) && diff_might_be_rename()) {

319 - init_tree_desc(&t1, tree1, size1);

320 - init_tree_desc(&t2, tree2, size2);

321 - try_to_follow_renames(&t1, &t2, base, opt);

322 - }

323 - free(tree1);

324 - free(tree2);

317 + retval = ll_diff_tree_sha1(old, new, base, opt);

318 + if (!*base && DIFF_OPT_TST(opt, FOLLOW_RENAMES) && diff_might_be_rename())

319 + try_to_follow_renames(old, new, base, opt);

320 +

321 return retval;

322 }

323