Refactor patch-id filtering out of git-cherry and git-format-patch.
This implements the patch-id computation and recording library, patch-ids.c, and rewrites the get_patch_ids() function used in cherry and format-patch to use it, so that they do not pollute the object namespace. Earlier code threw non-objects into the in-core object database, and hoped for not getting bitten by SHA-1 collisions. While it may be practically Ok, it still was an ugly hack. Signed-off-by: Junio C Hamano <junkio@cox.net>
Junio C Hamano committed
Apr 9, 2007 at 17:01 UTC
5d23e133d23bc9e26d6f23a4d136901e18e6ffba
4 files changed
+228
-32
Makefile
+2
-1
@@ -283,7 +283,7 @@ LIB_H = \
283
diff.h object.h pack.h pkt-line.h quote.h refs.h list-objects.h sideband.h \
284
run-command.h strbuf.h tag.h tree.h git-compat-util.h revision.h \
285
tree-walk.h log-tree.h dir.h path-list.h unpack-trees.h builtin.h \
286
- utf8.h reflog-walk.h
286
+ utf8.h reflog-walk.h patch-ids.h
287
288
DIFF_OBJS = \
289
diff.o diff-lib.o diffcore-break.o diffcore-order.o \
@@ -295,6 +295,7 @@ LIB_OBJS = \
295
date.o diff-delta.o entry.o exec_cmd.o ident.o \
296
interpolate.o \
297
lockfile.o \
298
+ patch-ids.o \
299
object.o pack-check.o patch-delta.o path.o pkt-line.o sideband.o \
300
reachable.o reflog-walk.o \
301
quote.o read-cache.o refs.o run-command.o dir.o object-refs.o \
builtin-log.c
+13
-31
@@ -12,6 +12,7 @@
12
#include "builtin.h"
13
#include "tag.h"
14
#include "reflog-walk.h"
15
+#include "patch-ids.h"
16
17
static int default_show_root = 1;
18
@@ -333,25 +334,12 @@ static int reopen_stdout(struct commit *commit, int nr, int keep_subject)
334
335
}
336
336
-static int get_patch_id(struct commit *commit, struct diff_options *options,
337
- unsigned char *sha1)
338
-{
339
- if (commit->parents)
340
- diff_tree_sha1(commit->parents->item->object.sha1,
341
- commit->object.sha1, "", options);
342
- else
343
- diff_root_tree_sha1(commit->object.sha1, "", options);
344
- diffcore_std(options);
345
- return diff_flush_patch_id(options, sha1);
346
-}
347
-
348
-static void get_patch_ids(struct rev_info *rev, struct diff_options *options, const char *prefix)
337
+static void get_patch_ids(struct rev_info *rev, struct patch_ids *ids, const char *prefix)
338
{
339
struct rev_info check_rev;
340
struct commit *commit;
341
struct object *o1, *o2;
342
unsigned flags1, flags2;
354
- unsigned char sha1[20];
343
344
if (rev->pending.nr != 2)
345
die("Need exactly one range.");
@@ -364,10 +352,7 @@ static void get_patch_ids(struct rev_info *rev, struct diff_options *options, co
352
if ((flags1 & UNINTERESTING) == (flags2 & UNINTERESTING))
353
die("Not a range.");
354
367
- diff_setup(options);
368
- options->recursive = 1;
369
- if (diff_setup_done(options) < 0)
370
- die("diff_setup_done failed");
355
+ init_patch_ids(ids);
356
357
/* given a range a..b get all patch ids for b..a */
358
init_revisions(&check_rev, prefix);
@@ -382,8 +367,7 @@ static void get_patch_ids(struct rev_info *rev, struct diff_options *options, co
367
if (commit->parents && commit->parents->next)
368
continue;
369
385
- if (!get_patch_id(commit, options, sha1))
386
- created_object(sha1, xcalloc(1, sizeof(struct object)));
370
+ add_commit_patch_id(commit, ids);
371
}
372
373
/* reset for next revision walk */
@@ -421,7 +405,7 @@ int cmd_format_patch(int argc, const char **argv, const char *prefix)
405
int ignore_if_in_upstream = 0;
406
int thread = 0;
407
const char *in_reply_to = NULL;
424
- struct diff_options patch_id_opts;
408
+ struct patch_ids ids;
409
char *add_signoff = NULL;
410
char message_id[1024];
411
char ref_message_id[1024];
@@ -560,22 +544,19 @@ int cmd_format_patch(int argc, const char **argv, const char *prefix)
544
}
545
546
if (ignore_if_in_upstream)
563
- get_patch_ids(&rev, &patch_id_opts, prefix);
547
+ get_patch_ids(&rev, &ids, prefix);
548
549
if (!use_stdout)
550
realstdout = fdopen(dup(1), "w");
551
552
prepare_revision_walk(&rev);
553
while ((commit = get_revision(&rev)) != NULL) {
570
- unsigned char sha1[20];
571
-
554
/* ignore merges */
555
if (commit->parents && commit->parents->next)
556
continue;
557
558
if (ignore_if_in_upstream &&
577
- !get_patch_id(commit, &patch_id_opts, sha1) &&
578
- lookup_object(sha1))
559
+ has_commit_patch_id(commit, &ids))
560
continue;
561
562
nr++;
@@ -630,6 +611,8 @@ int cmd_format_patch(int argc, const char **argv, const char *prefix)
611
fclose(stdout);
612
}
613
free(list);
614
+ if (ignore_if_in_upstream)
615
+ free_patch_ids(&ids);
616
return 0;
617
}
618
@@ -652,7 +635,7 @@ static const char cherry_usage[] =
635
int cmd_cherry(int argc, const char **argv, const char *prefix)
636
{
637
struct rev_info revs;
655
- struct diff_options patch_id_opts;
638
+ struct patch_ids ids;
639
struct commit *commit;
640
struct commit_list *list = NULL;
641
const char *upstream;
@@ -698,7 +681,7 @@ int cmd_cherry(int argc, const char **argv, const char *prefix)
681
return 0;
682
}
683
701
- get_patch_ids(&revs, &patch_id_opts, prefix);
684
+ get_patch_ids(&revs, &ids, prefix);
685
686
if (limit && add_pending_commit(limit, &revs, UNINTERESTING))
687
die("Unknown commit %s", limit);
@@ -714,12 +697,10 @@ int cmd_cherry(int argc, const char **argv, const char *prefix)
697
}
698
699
while (list) {
717
- unsigned char sha1[20];
700
char sign = '+';
701
702
commit = list->item;
721
- if (!get_patch_id(commit, &patch_id_opts, sha1) &&
722
- lookup_object(sha1))
703
+ if (has_commit_patch_id(commit, &ids))
704
sign = '-';
705
706
if (verbose) {
@@ -737,5 +718,6 @@ int cmd_cherry(int argc, const char **argv, const char *prefix)
718
list = list->next;
719
}
720
721
+ free_patch_ids(&ids);
722
return 0;
723
}
patch-ids.c
new
+192
@@ -0,0 +1,192 @@
1
+#include "cache.h"
2
+#include "diff.h"
3
+#include "commit.h"
4
+#include "patch-ids.h"
5
+
6
+static int commit_patch_id(struct commit *commit, struct diff_options *options,
7
+ unsigned char *sha1)
8
+{
9
+ if (commit->parents)
10
+ diff_tree_sha1(commit->parents->item->object.sha1,
11
+ commit->object.sha1, "", options);
12
+ else
13
+ diff_root_tree_sha1(commit->object.sha1, "", options);
14
+ diffcore_std(options);
15
+ return diff_flush_patch_id(options, sha1);
16
+}
17
+
18
+static uint32_t take2(const unsigned char *id)
19
+{
20
+ return ((id[0] << 8) | id[1]);
21
+}
22
+
23
+/*
24
+ * Conventional binary search loop looks like this:
25
+ *
26
+ * do {
27
+ * int mi = (lo + hi) / 2;
28
+ * int cmp = "entry pointed at by mi" minus "target";
29
+ * if (!cmp)
30
+ * return (mi is the wanted one)
31
+ * if (cmp > 0)
32
+ * hi = mi; "mi is larger than target"
33
+ * else
34
+ * lo = mi+1; "mi is smaller than target"
35
+ * } while (lo < hi);
36
+ *
37
+ * The invariants are:
38
+ *
39
+ * - When entering the loop, lo points at a slot that is never
40
+ * above the target (it could be at the target), hi points at a
41
+ * slot that is guaranteed to be above the target (it can never
42
+ * be at the target).
43
+ *
44
+ * - We find a point 'mi' between lo and hi (mi could be the same
45
+ * as lo, but never can be the same as hi), and check if it hits
46
+ * the target. There are three cases:
47
+ *
48
+ * - if it is a hit, we are happy.
49
+ *
50
+ * - if it is strictly higher than the target, we update hi with
51
+ * it.
52
+ *
53
+ * - if it is strictly lower than the target, we update lo to be
54
+ * one slot after it, because we allow lo to be at the target.
55
+ *
56
+ * When choosing 'mi', we do not have to take the "middle" but
57
+ * anywhere in between lo and hi, as long as lo <= mi < hi is
58
+ * satisfied. When we somehow know that the distance between the
59
+ * target and lo is much shorter than the target and hi, we could
60
+ * pick mi that is much closer to lo than the midway.
61
+ */
62
+static int patch_pos(struct patch_id **table, int nr, const unsigned char *id)
63
+{
64
+ int hi = nr;
65
+ int lo = 0;
66
+ int mi = 0;
67
+
68
+ if (!nr)
69
+ return -1;
70
+
71
+ if (nr != 1) {
72
+ unsigned lov, hiv, miv, ofs;
73
+
74
+ for (ofs = 0; ofs < 18; ofs += 2) {
75
+ lov = take2(table[0]->patch_id + ofs);
76
+ hiv = take2(table[nr-1]->patch_id + ofs);
77
+ miv = take2(id + ofs);
78
+ if (miv < lov)
79
+ return -1;
80
+ if (hiv < miv)
81
+ return -1 - nr;
82
+ if (lov != hiv) {
83
+ /*
84
+ * At this point miv could be equal
85
+ * to hiv (but id could still be higher);
86
+ * the invariant of (mi < hi) should be
87
+ * kept.
88
+ */
89
+ mi = (nr-1) * (miv - lov) / (hiv - lov);
90
+ if (lo <= mi && mi < hi)
91
+ break;
92
+ die("oops");
93
+ }
94
+ }
95
+ if (18 <= ofs)
96
+ die("cannot happen -- lo and hi are identical");
97
+ }
98
+
99
+ do {
100
+ int cmp;
101
+ cmp = hashcmp(table[mi]->patch_id, id);
102
+ if (!cmp)
103
+ return mi;
104
+ if (cmp > 0)
105
+ hi = mi;
106
+ else
107
+ lo = mi + 1;
108
+ mi = (hi + lo) / 2;
109
+ } while (lo < hi);
110
+ return -lo-1;
111
+}
112
+
113
+#define BUCKET_SIZE 190 /* 190 * 21 = 3990, with slop close enough to 4K */
114
+struct patch_id_bucket {
115
+ struct patch_id_bucket *next;
116
+ int nr;
117
+ struct patch_id bucket[BUCKET_SIZE];
118
+};
119
+
120
+int init_patch_ids(struct patch_ids *ids)
121
+{
122
+ memset(ids, 0, sizeof(*ids));
123
+ diff_setup(&ids->diffopts);
124
+ ids->diffopts.recursive = 1;
125
+ if (diff_setup_done(&ids->diffopts) < 0)
126
+ return error("diff_setup_done failed");
127
+ return 0;
128
+}
129
+
130
+int free_patch_ids(struct patch_ids *ids)
131
+{
132
+ struct patch_id_bucket *next, *patches;
133
+
134
+ free(ids->table);
135
+ for (patches = ids->patches; patches; patches = next) {
136
+ next = patches->next;
137
+ free(patches);
138
+ }
139
+ return 0;
140
+}
141
+
142
+static struct patch_id *add_commit(struct commit *commit,
143
+ struct patch_ids *ids,
144
+ int no_add)
145
+{
146
+ struct patch_id_bucket *bucket;
147
+ struct patch_id *ent;
148
+ unsigned char sha1[20];
149
+ int pos;
150
+
151
+ if (commit_patch_id(commit, &ids->diffopts, sha1))
152
+ return NULL;
153
+ pos = patch_pos(ids->table, ids->nr, sha1);
154
+ if (0 <= pos)
155
+ return ids->table[pos];
156
+ if (no_add)
157
+ return NULL;
158
+
159
+ pos = -1 - pos;
160
+
161
+ bucket = ids->patches;
162
+ if (!bucket || (BUCKET_SIZE <= bucket->nr)) {
163
+ bucket = xcalloc(1, sizeof(*bucket));
164
+ bucket->next = ids->patches;
165
+ ids->patches = bucket;
166
+ }
167
+ ent = &bucket->bucket[bucket->nr++];
168
+ hashcpy(ent->patch_id, sha1);
169
+
170
+ if (ids->alloc <= ids->nr) {
171
+ ids->alloc = alloc_nr(ids->nr);
172
+ ids->table = xrealloc(ids->table, sizeof(ent) * ids->alloc);
173
+ }
174
+ if (pos < ids->nr)
175
+ memmove(ids->table + pos + 1, ids->table + pos,
176
+ sizeof(ent) * (ids->nr - pos));
177
+ ids->nr++;
178
+ ids->table[pos] = ent;
179
+ return ids->table[pos];
180
+}
181
+
182
+struct patch_id *has_commit_patch_id(struct commit *commit,
183
+ struct patch_ids *ids)
184
+{
185
+ return add_commit(commit, ids, 1);
186
+}
187
+
188
+struct patch_id *add_commit_patch_id(struct commit *commit,
189
+ struct patch_ids *ids)
190
+{
191
+ return add_commit(commit, ids, 0);
192
+}
patch-ids.h
new
+21
@@ -0,0 +1,21 @@
1
+#ifndef PATCH_IDS_H
2
+#define PATCH_IDS_H
3
+
4
+struct patch_id {
5
+ unsigned char patch_id[20];
6
+ char seen;
7
+};
8
+
9
+struct patch_ids {
10
+ struct diff_options diffopts;
11
+ int nr, alloc;
12
+ struct patch_id **table;
13
+ struct patch_id_bucket *patches;
14
+};
15
+
16
+int init_patch_ids(struct patch_ids *);
17
+int free_patch_ids(struct patch_ids *);
18
+struct patch_id *add_commit_patch_id(struct commit *, struct patch_ids *);
19
+struct patch_id *has_commit_patch_id(struct commit *, struct patch_ids *);
20
+
21
+#endif /* PATCH_IDS_H */