@matheusbsbs / matheus-bagliano / commits / 2d9c58c69d
Fork 0

Remove "tree->entries" tree-entry list from tree parser

Instead, just use the tree buffer directly, and use the tree-walk infrastructure to walk the buffers instead of the tree-entry list. The tree-entry list is inefficient, and generates tons of small allocations for no good reason. The tree-walk infrastructure is generally no harder to use than following a linked list, and allows us to do most tree parsing in-place. Some programs still use the old tree-entry lists, and are a bit painful to convert without major surgery. For them we have a helper function that creates a temporary tree-entry list on demand. Signed-off-by: Linus Torvalds <torvalds@osdl.org> Signed-off-by: Junio C Hamano <junkio@cox.net>

Linus Torvalds committed May 29, 2006 at 12:18 UTC 2d9c58c69d1bab601e67b036d0546e85abcee7eb
9 files changed +116 -57
builtin-ls-tree.c
+1 -1
@@ -53,7 +53,7 @@ static int show_recursive(const char *base, int baselen, const char *pathname)
53 }
54 }
55
56 -static int show_tree(unsigned char *sha1, const char *base, int baselen,
56 +static int show_tree(const unsigned char *sha1, const char *base, int baselen,
57 const char *pathname, unsigned mode, int stage)
58 {
59 int retval = 0;
builtin-read-tree.c
+2 -2
@@ -165,7 +165,7 @@ static int unpack_trees_rec(struct tree_entry_list **posns, int len,
165 struct tree *tree = lookup_tree(posns[i]->sha1);
166 any_dirs = 1;
167 parse_tree(tree);
168 - subposns[i] = tree->entries;
168 + subposns[i] = create_tree_entry_list(tree);
169 posns[i] = posns[i]->next;
170 src[i + merge] = &df_conflict_entry;
171 continue;
@@ -370,7 +370,7 @@ static int unpack_trees(merge_fn_t fn)
370 if (len) {
371 posns = xmalloc(len * sizeof(struct tree_entry_list *));
372 for (i = 0; i < len; i++) {
373 - posns[i] = ((struct tree *) posn->item)->entries;
373 + posns[i] = create_tree_entry_list((struct tree *) posn->item);
374 posn = posn->next;
375 }
376 if (unpack_trees_rec(posns, len, "", fn, &indpos))
builtin-rev-list.c
+16 -10
@@ -113,7 +113,7 @@ static struct object_list **process_tree(struct tree *tree,
113 const char *name)
114 {
115 struct object *obj = &tree->object;
116 - struct tree_entry_list *entry;
116 + struct tree_desc desc;
117 struct name_path me;
118
119 if (!revs.tree_objects)
@@ -128,16 +128,22 @@ static struct object_list **process_tree(struct tree *tree,
128 me.up = path;
129 me.elem = name;
130 me.elem_len = strlen(name);
131 - entry = tree->entries;
132 - tree->entries = NULL;
133 - while (entry) {
134 - struct tree_entry_list *next = entry->next;
135 - if (entry->directory)
136 - p = process_tree(lookup_tree(entry->sha1), p, &me, entry->name);
131 +
132 + desc.buf = tree->buffer;
133 + desc.size = tree->size;
134 +
135 + while (desc.size) {
136 + unsigned mode;
137 + const char *name;
138 + const unsigned char *sha1;
139 +
140 + sha1 = tree_entry_extract(&desc, &name, &mode);
141 + update_tree_entry(&desc);
142 +
143 + if (S_ISDIR(mode))
144 + p = process_tree(lookup_tree(sha1), p, &me, name);
145 else
138 - p = process_blob(lookup_blob(entry->sha1), p, &me, entry->name);
139 - free(entry);
140 - entry = next;
146 + p = process_blob(lookup_blob(sha1), p, &me, name);
147 }
148 free(tree->buffer);
149 tree->buffer = NULL;
fetch.c
+11 -5
@@ -41,16 +41,22 @@ static int process_tree(struct tree *tree)
41 if (parse_tree(tree))
42 return -1;
43
44 - entry = tree->entries;
45 - tree->entries = NULL;
44 + entry = create_tree_entry_list(tree);
45 while (entry) {
46 struct tree_entry_list *next = entry->next;
48 - if (process(entry->item.any))
49 - return -1;
50 - free(entry->name);
47 +
48 + if (entry->directory) {
49 + struct tree *tree = lookup_tree(entry->sha1);
50 + process_tree(tree);
51 + } else {
52 + struct blob *blob = lookup_blob(entry->sha1);
53 + process(&blob->object);
54 + }
55 free(entry);
56 entry = next;
57 }
58 + free(tree->buffer);
59 + tree->buffer = NULL;
60 return 0;
61 }
62
fsck-objects.c
+5 -2
@@ -11,6 +11,7 @@
11 #include "cache-tree.h"
12
13 #define REACHABLE 0x0001
14 +#define SEEN 0x0002
15
16 static int show_root = 0;
17 static int show_tags = 0;
@@ -161,7 +162,7 @@ static int fsck_tree(struct tree *item)
162 struct tree_entry_list *entry, *last;
163
164 last = NULL;
164 - for (entry = item->entries; entry; entry = entry->next) {
165 + for (entry = create_tree_entry_list(item); entry; entry = entry->next) {
166 if (strchr(entry->name, '/'))
167 has_full_path = 1;
168 has_zero_pad |= entry->zeropad;
@@ -205,7 +206,6 @@ static int fsck_tree(struct tree *item)
206 }
207 if (last)
208 free(last);
208 - item->entries = NULL;
209 free(item->buffer);
210 item->buffer = NULL;
211
@@ -277,6 +277,9 @@ static int fsck_sha1(unsigned char *sha1)
277 struct object *obj = parse_object(sha1);
278 if (!obj)
279 return error("%s: object not found", sha1_to_hex(sha1));
280 + if (obj->flags & SEEN)
281 + return 0;
282 + obj->flags |= SEEN;
283 if (obj->type == blob_type)
284 return 0;
285 if (obj->type == tree_type)
http-push.c
+20 -10
@@ -1704,6 +1704,7 @@ static struct object_list **process_blob(struct blob *blob,
1704 return p;
1705
1706 obj->flags |= SEEN;
1707 + name = strdup(name);
1708 return add_object(obj, p, path, name);
1709 }
1710
@@ -1713,7 +1714,7 @@ static struct object_list **process_tree(struct tree *tree,
1714 const char *name)
1715 {
1716 struct object *obj = &tree->object;
1716 - struct tree_entry_list *entry;
1717 + struct tree_desc desc;
1718 struct name_path me;
1719
1720 obj->flags |= LOCAL;
@@ -1724,21 +1725,30 @@ static struct object_list **process_tree(struct tree *tree,
1725 die("bad tree object %s", sha1_to_hex(obj->sha1));
1726
1727 obj->flags |= SEEN;
1728 + name = strdup(name);
1729 p = add_object(obj, p, NULL, name);
1730 me.up = path;
1731 me.elem = name;
1732 me.elem_len = strlen(name);
1731 - entry = tree->entries;
1732 - tree->entries = NULL;
1733 - while (entry) {
1734 - struct tree_entry_list *next = entry->next;
1735 - if (entry->directory)
1736 - p = process_tree(lookup_tree(entry->sha1), p, &me, entry->name);
1733 +
1734 + desc.buf = tree->buffer;
1735 + desc.size = tree->size;
1736 +
1737 + while (desc.size) {
1738 + unsigned mode;
1739 + const char *name;
1740 + const unsigned char *sha1;
1741 +
1742 + sha1 = tree_entry_extract(&desc, &name, &mode);
1743 + update_tree_entry(&desc);
1744 +
1745 + if (S_ISDIR(mode))
1746 + p = process_tree(lookup_tree(sha1), p, &me, name);
1747 else
1738 - p = process_blob(lookup_blob(entry->sha1), p, &me, entry->name);
1739 - free(entry);
1740 - entry = next;
1748 + p = process_blob(lookup_blob(sha1), p, &me, name);
1749 }
1750 + free(tree->buffer);
1751 + tree->buffer = NULL;
1752 return p;
1753 }
1754
revision.c
+1 -2
@@ -63,8 +63,7 @@ void mark_tree_uninteresting(struct tree *tree)
63 return;
64 if (parse_tree(tree) < 0)
65 die("bad tree %s", sha1_to_hex(obj->sha1));
66 - entry = tree->entries;
67 - tree->entries = NULL;
66 + entry = create_tree_entry_list(tree);
67 while (entry) {
68 struct tree_entry_list *next = entry->next;
69 if (entry->directory)
tree.c
+57 -24
@@ -151,22 +151,65 @@ struct tree *lookup_tree(const unsigned char *sha1)
151 return (struct tree *) obj;
152 }
153
154 -int parse_tree_buffer(struct tree *item, void *buffer, unsigned long size)
154 +static int track_tree_refs(struct tree *item)
155 {
156 + int n_refs = 0, i;
157 + struct object_refs *refs;
158 struct tree_desc desc;
157 - struct tree_entry_list **list_p;
158 - int n_refs = 0;
159
160 + /* Count how many entries there are.. */
161 + desc.buf = item->buffer;
162 + desc.size = item->size;
163 + while (desc.size) {
164 + n_refs++;
165 + update_tree_entry(&desc);
166 + }
167 +
168 + /* Allocate object refs and walk it again.. */
169 + i = 0;
170 + refs = alloc_object_refs(n_refs);
171 + desc.buf = item->buffer;
172 + desc.size = item->size;
173 + while (desc.size) {
174 + unsigned mode;
175 + const char *name;
176 + const unsigned char *sha1;
177 + struct object *obj;
178 +
179 + sha1 = tree_entry_extract(&desc, &name, &mode);
180 + update_tree_entry(&desc);
181 + if (S_ISDIR(mode))
182 + obj = &lookup_tree(sha1)->object;
183 + else
184 + obj = &lookup_blob(sha1)->object;
185 + refs->ref[i++] = obj;
186 + }
187 + set_object_refs(&item->object, refs);
188 + return 0;
189 +}
190 +
191 +int parse_tree_buffer(struct tree *item, void *buffer, unsigned long size)
192 +{
193 if (item->object.parsed)
194 return 0;
195 item->object.parsed = 1;
196 item->buffer = buffer;
197 item->size = size;
198
166 - desc.buf = buffer;
167 - desc.size = size;
199 + if (track_object_refs)
200 + track_tree_refs(item);
201 + return 0;
202 +}
203 +
204 +struct tree_entry_list *create_tree_entry_list(struct tree *tree)
205 +{
206 + struct tree_desc desc;
207 + struct tree_entry_list *ret = NULL;
208 + struct tree_entry_list **list_p = &ret;
209 +
210 + desc.buf = tree->buffer;
211 + desc.size = tree->size;
212
169 - list_p = &item->entries;
213 while (desc.size) {
214 unsigned mode;
215 const char *path;
@@ -186,29 +229,19 @@ int parse_tree_buffer(struct tree *item, void *buffer, unsigned long size)
229 entry->next = NULL;
230
231 update_tree_entry(&desc);
189 - n_refs++;
232 *list_p = entry;
233 list_p = &entry->next;
234 }
235 + return ret;
236 +}
237
194 - if (track_object_refs) {
195 - struct tree_entry_list *entry;
196 - unsigned i = 0;
197 - struct object_refs *refs = alloc_object_refs(n_refs);
198 - for (entry = item->entries; entry; entry = entry->next) {
199 - struct object *obj;
200 -
201 - if (entry->directory)
202 - obj = &lookup_tree(entry->sha1)->object;
203 - else
204 - obj = &lookup_blob(entry->sha1)->object;
205 - refs->ref[i++] = obj;
206 - }
207 -
208 - set_object_refs(&item->object, refs);
238 +void free_tree_entry_list(struct tree_entry_list *list)
239 +{
240 + while (list) {
241 + struct tree_entry_list *next = list->next;
242 + free(list);
243 + list = next;
244 }
210 -
211 - return 0;
245 }
246
247 int parse_tree(struct tree *item)
tree.h
+3 -1
@@ -20,9 +20,11 @@ struct tree {
20 struct object object;
21 void *buffer;
22 unsigned long size;
23 - struct tree_entry_list *entries;
23 };
24
25 +struct tree_entry_list *create_tree_entry_list(struct tree *);
26 +void free_tree_entry_list(struct tree_entry_list *);
27 +
28 struct tree *lookup_tree(const unsigned char *sha1);
29
30 int parse_tree_buffer(struct tree *item, void *buffer, unsigned long size);