From: ZheNing Hu <adlternative@xxxxxxxxx>
We parsed format string in verify_ref_format() and stored the parsed
atom in used_atom array. But in format_ref_array_item() we have
another round of parsing format string. This affects performance.
Introducing the struct parsed_atom_list which can save the current
atom's start and end address in format string and its index in
used_atom. All parsed_atom_list entry are linked together in the
form of linked list, and the head node of the linked list is stored
in struct ref_format. Create clear_parsed_atom_list() which can used
to clear the nodes on the linked list.
This can bring performance improvement.
Mentored-by: Christian Couder <christian.couder@xxxxxxxxx>
Mentored-by: Hariom Verma <hariom18599@xxxxxxxxx>
Signed-off-by: ZheNing Hu <adlternative@xxxxxxxxx>
---
builtin/branch.c | 2 ++
builtin/for-each-ref.c | 3 ++-
builtin/tag.c | 2 ++
builtin/verify-tag.c | 2 ++
ref-filter.c | 45 +++++++++++++++++++++++++++++++++---------
ref-filter.h | 11 +++++++++++
6 files changed, 55 insertions(+), 10 deletions(-)
diff --git a/builtin/branch.c b/builtin/branch.c
index b23b1d1752a..e361f8cc661 100644
--- a/builtin/branch.c
+++ b/builtin/branch.c
@@ -459,6 +459,7 @@ static void print_ref_list(struct ref_filter *filter, struct ref_sorting *sortin
strbuf_release(&err);
strbuf_release(&out);
ref_array_clear(&array);
+ clear_parsed_atom_list(&format->parsed_atom_head);
free(to_free);
}
@@ -678,6 +679,7 @@ int cmd_branch(int argc, const char **argv, const char *prefix)
memset(&filter, 0, sizeof(filter));
filter.kind = FILTER_REFS_BRANCHES;
filter.abbrev = -1;
+ INIT_LIST_HEAD(&format.parsed_atom_head);
if (argc == 2 && !strcmp(argv[1], "-h"))
usage_with_options(builtin_branch_usage, options);
diff --git a/builtin/for-each-ref.c b/builtin/for-each-ref.c
index 89cb6307d46..6e22d80d5b5 100644
--- a/builtin/for-each-ref.c
+++ b/builtin/for-each-ref.c
@@ -53,8 +53,8 @@ int cmd_for_each_ref(int argc, const char **argv, const char *prefix)
memset(&array, 0, sizeof(array));
memset(&filter, 0, sizeof(filter));
-
format.format = "%(objectname) %(objecttype)\t%(refname)";
+ INIT_LIST_HEAD(&format.parsed_atom_head);
git_config(git_default_config, NULL);
@@ -96,6 +96,7 @@ int cmd_for_each_ref(int argc, const char **argv, const char *prefix)
ref_array_clear(&array);
free_commit_list(filter.with_commit);
free_commit_list(filter.no_commit);
+ clear_parsed_atom_list(&format.parsed_atom_head);
UNLEAK(sorting);
return 0;
}
diff --git a/builtin/tag.c b/builtin/tag.c
index 452558ec957..549339cbbe4 100644
--- a/builtin/tag.c
+++ b/builtin/tag.c
@@ -78,6 +78,7 @@ static int list_tags(struct ref_filter *filter, struct ref_sorting *sorting,
strbuf_release(&output);
ref_array_clear(&array);
free(to_free);
+ clear_parsed_atom_list(&format->parsed_atom_head);
return 0;
}
@@ -493,6 +494,7 @@ int cmd_tag(int argc, const char **argv, const char *prefix)
memset(&filter, 0, sizeof(filter));
filter.lines = -1;
opt.sign = -1;
+ INIT_LIST_HEAD(&format.parsed_atom_head);
argc = parse_options(argc, argv, prefix, options, git_tag_usage, 0);
diff --git a/builtin/verify-tag.c b/builtin/verify-tag.c
index f45136a06ba..8b0a2b2587c 100644
--- a/builtin/verify-tag.c
+++ b/builtin/verify-tag.c
@@ -39,6 +39,7 @@ int cmd_verify_tag(int argc, const char **argv, const char *prefix)
OPT_END()
};
+ INIT_LIST_HEAD(&format.parsed_atom_head);
git_config(git_verify_tag_config, NULL);
argc = parse_options(argc, argv, prefix, verify_tag_options,
@@ -73,5 +74,6 @@ int cmd_verify_tag(int argc, const char **argv, const char *prefix)
if (format.format)
pretty_print_ref(name, &oid, &format);
}
+ clear_parsed_atom_list(&format.parsed_atom_head);
return had_error;
}
diff --git a/ref-filter.c b/ref-filter.c
index 65ba00633dc..76a31fb79b1 100644
--- a/ref-filter.c
+++ b/ref-filter.c
@@ -1035,6 +1035,7 @@ int verify_ref_format(struct ref_format *format)
for (cp = format->format; *cp && (sp = find_next(cp)); ) {
struct strbuf err = STRBUF_INIT;
const char *color, *ep = strchr(sp, ')');
+ struct parsed_atom_list *e;
int at;
if (!ep)
@@ -1043,6 +1044,12 @@ int verify_ref_format(struct ref_format *format)
at = parse_ref_filter_atom(format, sp + 2, ep, &err);
if (at < 0)
die("%s", err.buf);
+ e = xmalloc(sizeof(*e));
+ e->beg = sp + 2;
+ e->end = ep;
+ e->at = at;
+ list_add_tail(&e->list, &format->parsed_atom_head);
+
if (need_parse_buffer(used_atom[at].atom_type))
format->can_skip_parse_buffer = 0;
if (reject_atom(used_atom[at].atom_type))
@@ -2615,25 +2622,31 @@ int format_ref_array_item(struct ref_array_item *info,
struct strbuf *final_buf,
struct strbuf *error_buf)
{
- const char *cp, *sp, *ep;
+ const char *cp, *sp;
+ struct list_head *item;
struct ref_formatting_state state = REF_FORMATTING_STATE_INIT;
state.quote_style = format->quote_style;
push_stack_element(&state.stack);
info->can_skip_parse_buffer = format->can_skip_parse_buffer;
- for (cp = format->format; *cp && (sp = find_next(cp)); cp = ep + 1) {
+
+ cp = format->format;
+
+ list_for_each(item, &format->parsed_atom_head) {
struct atom_value *atomv;
- int pos;
+ struct parsed_atom_list *e =
+ list_entry(item, struct parsed_atom_list, list);
- ep = strchr(sp, ')');
- if (cp < sp)
- append_literal(cp, sp, &state);
- pos = parse_ref_filter_atom(format, sp + 2, ep, error_buf);
- if (pos < 0 || get_ref_atom_value(info, pos, &atomv, error_buf) ||
+ if (cp < e->beg - 2)
+ append_literal(cp, e->beg - 2, &state);
+ if (get_ref_atom_value(info, e->at, &atomv, error_buf) ||
atomv->handler(atomv, &state, error_buf)) {
pop_stack_element(&state.stack);
return -1;
}
+ cp = e->end + 1;
+ if (!*cp)
+ break;
}
if (*cp) {
sp = cp + strlen(cp);
@@ -2681,10 +2694,12 @@ static int parse_sorting_atom(const char *atom)
* This parses an atom using a dummy ref_format, since we don't
* actually care about the formatting details.
*/
+ int res;
struct ref_format dummy = REF_FORMAT_INIT;
const char *end = atom + strlen(atom);
struct strbuf err = STRBUF_INIT;
- int res = parse_ref_filter_atom(&dummy, atom, end, &err);
+
+ res = parse_ref_filter_atom(&dummy, atom, end, &err);
if (res < 0)
die("%s", err.buf);
strbuf_release(&err);
@@ -2757,3 +2772,15 @@ int parse_opt_merge_filter(const struct option *opt, const char *arg, int unset)
return 0;
}
+
+void clear_parsed_atom_list(struct list_head *parsed_atom_head)
+{
+ struct list_head *pos, *tmp;
+ struct parsed_atom_list *item;
+
+ list_for_each_safe(pos, tmp, parsed_atom_head) {
+ item = list_entry(pos, struct parsed_atom_list, list);
+ list_del(pos);
+ free(item);
+ }
+}
diff --git a/ref-filter.h b/ref-filter.h
index 5bceae1dac9..df54836a643 100644
--- a/ref-filter.h
+++ b/ref-filter.h
@@ -72,6 +72,13 @@ struct ref_filter {
verbose;
};
+struct parsed_atom_list {
+ const char *beg;
+ const char *end;
+ int at;
+ struct list_head list;
+};
+
struct ref_format {
/*
* Set these to define the format; make sure you call
@@ -85,6 +92,7 @@ struct ref_format {
int can_skip_parse_buffer;
/* Internal state to ref-filter */
int need_color_reset_at_eol;
+ struct list_head parsed_atom_head;
};
#define REF_FORMAT_INIT { .use_color = -1, .can_skip_parse_buffer = 1 }
@@ -112,6 +120,9 @@ struct ref_format {
int filter_refs(struct ref_array *array, struct ref_filter *filter, unsigned int type);
/* Clear all memory allocated to ref_array */
void ref_array_clear(struct ref_array *array);
+/* Clear the parsed_atom_list in ref_format*/
+void clear_parsed_atom_list(struct list_head *parsed_atom_head);
+
/* Used to verify if the given format is correct and to parse out the used atoms */
int verify_ref_format(struct ref_format *format);
/* Sort the given ref_array as per the ref_sorting provided */
--
gitgitgadget
