2005-05-21 09:40:01 +00:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2005 Junio C Hamano
|
2010-08-23 17:17:03 +00:00
|
|
|
* Copyright (C) 2010 Google Inc.
|
2005-05-21 09:40:01 +00:00
|
|
|
*/
|
|
|
|
#include "cache.h"
|
|
|
|
#include "diff.h"
|
|
|
|
#include "diffcore.h"
|
2010-08-23 17:17:03 +00:00
|
|
|
#include "xdiff-interface.h"
|
Use kwset in pickaxe
Benchmarks in the hot cache case:
before:
$ perf stat --repeat=5 git log -Sqwerty
Performance counter stats for 'git log -Sqwerty' (5 runs):
47,092,744 cache-misses # 2.825 M/sec ( +- 1.607% )
123,368,389 cache-references # 7.400 M/sec ( +- 0.812% )
330,040,998 branch-misses # 3.134 % ( +- 0.257% )
10,530,896,750 branches # 631.663 M/sec ( +- 0.121% )
62,037,201,030 instructions # 1.399 IPC ( +- 0.142% )
44,331,294,321 cycles # 2659.073 M/sec ( +- 0.326% )
96,794 page-faults # 0.006 M/sec ( +- 11.952% )
25 CPU-migrations # 0.000 M/sec ( +- 25.266% )
1,424 context-switches # 0.000 M/sec ( +- 0.540% )
16671.708650 task-clock-msecs # 0.997 CPUs ( +- 0.343% )
16.728692052 seconds time elapsed ( +- 0.344% )
after:
$ perf stat --repeat=5 git log -Sqwerty
Performance counter stats for 'git log -Sqwerty' (5 runs):
51,385,522 cache-misses # 4.619 M/sec ( +- 0.565% )
129,177,880 cache-references # 11.611 M/sec ( +- 0.219% )
319,222,775 branch-misses # 6.946 % ( +- 0.134% )
4,595,913,233 branches # 413.086 M/sec ( +- 0.112% )
31,395,042,533 instructions # 1.062 IPC ( +- 0.129% )
29,558,348,598 cycles # 2656.740 M/sec ( +- 0.204% )
93,224 page-faults # 0.008 M/sec ( +- 4.487% )
19 CPU-migrations # 0.000 M/sec ( +- 10.425% )
950 context-switches # 0.000 M/sec ( +- 0.360% )
11125.796039 task-clock-msecs # 0.997 CPUs ( +- 0.239% )
11.164216599 seconds time elapsed ( +- 0.240% )
So the kwset code is about 33% faster.
Signed-off-by: Fredrik Kuivinen <frekui@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-20 22:41:57 +00:00
|
|
|
#include "kwset.h"
|
2016-06-25 05:22:37 +00:00
|
|
|
#include "commit.h"
|
|
|
|
#include "quote.h"
|
2010-08-23 17:17:03 +00:00
|
|
|
|
2013-04-05 05:28:10 +00:00
|
|
|
typedef int (*pickaxe_fn)(mmfile_t *one, mmfile_t *two,
|
|
|
|
struct diff_options *o,
|
|
|
|
regex_t *regexp, kwset_t kws);
|
|
|
|
|
2010-08-23 17:17:03 +00:00
|
|
|
struct diffgrep_cb {
|
|
|
|
regex_t *regexp;
|
|
|
|
int hit;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void diffgrep_consume(void *priv, char *line, unsigned long len)
|
|
|
|
{
|
|
|
|
struct diffgrep_cb *data = priv;
|
|
|
|
regmatch_t regmatch;
|
|
|
|
int hold;
|
|
|
|
|
|
|
|
if (line[0] != '+' && line[0] != '-')
|
|
|
|
return;
|
|
|
|
if (data->hit)
|
|
|
|
/*
|
|
|
|
* NEEDSWORK: we should have a way to terminate the
|
|
|
|
* caller early.
|
|
|
|
*/
|
|
|
|
return;
|
|
|
|
/* Yuck -- line ought to be "const char *"! */
|
|
|
|
hold = line[len];
|
|
|
|
line[len] = '\0';
|
|
|
|
data->hit = !regexec(data->regexp, line + 1, 1, ®match, 0);
|
|
|
|
line[len] = hold;
|
|
|
|
}
|
|
|
|
|
2013-04-05 05:28:10 +00:00
|
|
|
static int diff_grep(mmfile_t *one, mmfile_t *two,
|
|
|
|
struct diff_options *o,
|
2011-10-06 16:50:18 +00:00
|
|
|
regex_t *regexp, kwset_t kws)
|
2010-08-23 17:17:03 +00:00
|
|
|
{
|
|
|
|
regmatch_t regmatch;
|
2013-04-05 05:28:10 +00:00
|
|
|
struct diffgrep_cb ecbdata;
|
|
|
|
xpparam_t xpp;
|
|
|
|
xdemitconf_t xecfg;
|
2013-04-04 20:20:29 +00:00
|
|
|
|
2013-04-05 05:28:10 +00:00
|
|
|
if (!one)
|
|
|
|
return !regexec(regexp, two->ptr, 1, ®match, 0);
|
|
|
|
if (!two)
|
|
|
|
return !regexec(regexp, one->ptr, 1, ®match, 0);
|
2010-08-23 17:17:03 +00:00
|
|
|
|
2013-04-05 05:28:10 +00:00
|
|
|
/*
|
|
|
|
* We have both sides; need to run textual diff and see if
|
|
|
|
* the pattern appears on added/deleted lines.
|
|
|
|
*/
|
|
|
|
memset(&xpp, 0, sizeof(xpp));
|
|
|
|
memset(&xecfg, 0, sizeof(xecfg));
|
|
|
|
ecbdata.regexp = regexp;
|
|
|
|
ecbdata.hit = 0;
|
|
|
|
xecfg.ctxlen = o->context;
|
|
|
|
xecfg.interhunkctxlen = o->interhunkcontext;
|
react to errors in xdi_diff
When we call into xdiff to perform a diff, we generally lose
the return code completely. Typically by ignoring the return
of our xdi_diff wrapper, but sometimes we even propagate
that return value up and then ignore it later. This can
lead to us silently producing incorrect diffs (e.g., "git
log" might produce no output at all, not even a diff header,
for a content-level diff).
In practice this does not happen very often, because the
typical reason for xdiff to report failure is that it
malloc() failed (it uses straight malloc, and not our
xmalloc wrapper). But it could also happen when xdiff
triggers one our callbacks, which returns an error (e.g.,
outf() in builtin/rerere.c tries to report a write failure
in this way). And the next patch also plans to add more
failure modes.
Let's notice an error return from xdiff and react
appropriately. In most of the diff.c code, we can simply
die(), which matches the surrounding code (e.g., that is
what we do if we fail to load a file for diffing in the
first place). This is not that elegant, but we are probably
better off dying to let the user know there was a problem,
rather than simply generating bogus output.
We could also just die() directly in xdi_diff, but the
callers typically have a bit more context, and can provide a
better message (and if we do later decide to pass errors up,
we're one step closer to doing so).
There is one interesting case, which is in diff_grep(). Here
if we cannot generate the diff, there is nothing to match,
and we silently return "no hits". This is actually what the
existing code does already, but we make it a little more
explicit.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-09-24 23:12:23 +00:00
|
|
|
if (xdi_diff_outf(one, two, diffgrep_consume, &ecbdata, &xpp, &xecfg))
|
|
|
|
return 0;
|
2013-04-05 05:28:10 +00:00
|
|
|
return ecbdata.hit;
|
2010-08-23 17:17:03 +00:00
|
|
|
}
|
|
|
|
|
2013-07-06 13:53:27 +00:00
|
|
|
static unsigned int contains(mmfile_t *mf, regex_t *regexp, kwset_t kws)
|
2005-05-21 09:40:01 +00:00
|
|
|
{
|
2005-07-23 23:35:25 +00:00
|
|
|
unsigned int cnt;
|
2009-03-02 23:00:55 +00:00
|
|
|
unsigned long sz;
|
2005-05-21 09:40:01 +00:00
|
|
|
const char *data;
|
2005-07-23 23:35:25 +00:00
|
|
|
|
2012-10-28 12:27:12 +00:00
|
|
|
sz = mf->size;
|
|
|
|
data = mf->ptr;
|
2005-07-23 23:35:25 +00:00
|
|
|
cnt = 0;
|
|
|
|
|
2006-03-29 00:16:33 +00:00
|
|
|
if (regexp) {
|
|
|
|
regmatch_t regmatch;
|
|
|
|
int flags = 0;
|
|
|
|
|
2009-03-16 18:38:42 +00:00
|
|
|
assert(data[sz] == '\0');
|
2006-03-29 00:16:33 +00:00
|
|
|
while (*data && !regexec(regexp, data, 1, ®match, flags)) {
|
|
|
|
flags |= REG_NOTBOL;
|
2009-03-16 18:38:42 +00:00
|
|
|
data += regmatch.rm_eo;
|
|
|
|
if (*data && regmatch.rm_so == regmatch.rm_eo)
|
|
|
|
data++;
|
2005-07-23 23:35:25 +00:00
|
|
|
cnt++;
|
|
|
|
}
|
2006-03-29 00:16:33 +00:00
|
|
|
|
|
|
|
} else { /* Classic exact string match */
|
2009-03-02 23:00:55 +00:00
|
|
|
while (sz) {
|
2011-10-06 16:50:06 +00:00
|
|
|
struct kwsmatch kwsm;
|
|
|
|
size_t offset = kwsexec(kws, data, sz, &kwsm);
|
Use kwset in pickaxe
Benchmarks in the hot cache case:
before:
$ perf stat --repeat=5 git log -Sqwerty
Performance counter stats for 'git log -Sqwerty' (5 runs):
47,092,744 cache-misses # 2.825 M/sec ( +- 1.607% )
123,368,389 cache-references # 7.400 M/sec ( +- 0.812% )
330,040,998 branch-misses # 3.134 % ( +- 0.257% )
10,530,896,750 branches # 631.663 M/sec ( +- 0.121% )
62,037,201,030 instructions # 1.399 IPC ( +- 0.142% )
44,331,294,321 cycles # 2659.073 M/sec ( +- 0.326% )
96,794 page-faults # 0.006 M/sec ( +- 11.952% )
25 CPU-migrations # 0.000 M/sec ( +- 25.266% )
1,424 context-switches # 0.000 M/sec ( +- 0.540% )
16671.708650 task-clock-msecs # 0.997 CPUs ( +- 0.343% )
16.728692052 seconds time elapsed ( +- 0.344% )
after:
$ perf stat --repeat=5 git log -Sqwerty
Performance counter stats for 'git log -Sqwerty' (5 runs):
51,385,522 cache-misses # 4.619 M/sec ( +- 0.565% )
129,177,880 cache-references # 11.611 M/sec ( +- 0.219% )
319,222,775 branch-misses # 6.946 % ( +- 0.134% )
4,595,913,233 branches # 413.086 M/sec ( +- 0.112% )
31,395,042,533 instructions # 1.062 IPC ( +- 0.129% )
29,558,348,598 cycles # 2656.740 M/sec ( +- 0.204% )
93,224 page-faults # 0.008 M/sec ( +- 4.487% )
19 CPU-migrations # 0.000 M/sec ( +- 10.425% )
950 context-switches # 0.000 M/sec ( +- 0.360% )
11125.796039 task-clock-msecs # 0.997 CPUs ( +- 0.239% )
11.164216599 seconds time elapsed ( +- 0.240% )
So the kwset code is about 33% faster.
Signed-off-by: Fredrik Kuivinen <frekui@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-20 22:41:57 +00:00
|
|
|
if (offset == -1)
|
2009-03-02 23:00:55 +00:00
|
|
|
break;
|
2014-03-22 17:16:00 +00:00
|
|
|
sz -= offset + kwsm.size[0];
|
|
|
|
data += offset + kwsm.size[0];
|
2009-03-02 23:00:55 +00:00
|
|
|
cnt++;
|
2006-03-29 00:16:33 +00:00
|
|
|
}
|
2005-07-23 23:35:25 +00:00
|
|
|
}
|
|
|
|
return cnt;
|
2005-05-21 09:40:01 +00:00
|
|
|
}
|
|
|
|
|
2013-04-05 05:28:10 +00:00
|
|
|
static int has_changes(mmfile_t *one, mmfile_t *two,
|
|
|
|
struct diff_options *o,
|
2011-10-06 16:50:06 +00:00
|
|
|
regex_t *regexp, kwset_t kws)
|
2013-04-05 05:28:10 +00:00
|
|
|
{
|
2013-07-06 13:53:27 +00:00
|
|
|
unsigned int one_contains = one ? contains(one, regexp, kws) : 0;
|
|
|
|
unsigned int two_contains = two ? contains(two, regexp, kws) : 0;
|
|
|
|
return one_contains != two_contains;
|
2013-04-05 05:28:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int pickaxe_match(struct diff_filepair *p, struct diff_options *o,
|
|
|
|
regex_t *regexp, kwset_t kws, pickaxe_fn fn)
|
2011-10-06 16:26:24 +00:00
|
|
|
{
|
2013-04-04 20:20:29 +00:00
|
|
|
struct userdiff_driver *textconv_one = NULL;
|
|
|
|
struct userdiff_driver *textconv_two = NULL;
|
2012-10-28 12:27:12 +00:00
|
|
|
mmfile_t mf1, mf2;
|
|
|
|
int ret;
|
|
|
|
|
2012-10-28 12:34:06 +00:00
|
|
|
if (!o->pickaxe[0])
|
|
|
|
return 0;
|
|
|
|
|
2013-04-05 05:28:10 +00:00
|
|
|
/* ignore unmerged */
|
|
|
|
if (!DIFF_FILE_VALID(p->one) && !DIFF_FILE_VALID(p->two))
|
|
|
|
return 0;
|
|
|
|
|
2013-04-05 13:16:30 +00:00
|
|
|
if (DIFF_OPT_TST(o, ALLOW_TEXTCONV)) {
|
|
|
|
textconv_one = get_textconv(p->one);
|
|
|
|
textconv_two = get_textconv(p->two);
|
|
|
|
}
|
2013-04-04 20:20:29 +00:00
|
|
|
|
2012-10-28 12:27:12 +00:00
|
|
|
/*
|
|
|
|
* If we have an unmodified pair, we know that the count will be the
|
|
|
|
* same and don't even have to load the blobs. Unless textconv is in
|
|
|
|
* play, _and_ we are using two different textconv filters (e.g.,
|
|
|
|
* because a pair is an exact rename with different textconv attributes
|
|
|
|
* for each side, which might generate different content).
|
|
|
|
*/
|
|
|
|
if (textconv_one == textconv_two && diff_unmodified_pair(p))
|
|
|
|
return 0;
|
|
|
|
|
2013-04-05 00:08:47 +00:00
|
|
|
mf1.size = fill_textconv(textconv_one, p->one, &mf1.ptr);
|
|
|
|
mf2.size = fill_textconv(textconv_two, p->two, &mf2.ptr);
|
2012-10-28 12:27:12 +00:00
|
|
|
|
2013-04-05 05:28:10 +00:00
|
|
|
ret = fn(DIFF_FILE_VALID(p->one) ? &mf1 : NULL,
|
|
|
|
DIFF_FILE_VALID(p->two) ? &mf2 : NULL,
|
|
|
|
o, regexp, kws);
|
2012-10-28 12:27:12 +00:00
|
|
|
|
|
|
|
if (textconv_one)
|
|
|
|
free(mf1.ptr);
|
|
|
|
if (textconv_two)
|
|
|
|
free(mf2.ptr);
|
|
|
|
diff_free_filespec_data(p->one);
|
|
|
|
diff_free_filespec_data(p->two);
|
|
|
|
|
|
|
|
return ret;
|
2011-10-06 16:26:24 +00:00
|
|
|
}
|
|
|
|
|
2014-03-22 17:15:58 +00:00
|
|
|
static void pickaxe(struct diff_queue_struct *q, struct diff_options *o,
|
|
|
|
regex_t *regexp, kwset_t kws, pickaxe_fn fn)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct diff_queue_struct outq;
|
|
|
|
|
|
|
|
DIFF_QUEUE_CLEAR(&outq);
|
|
|
|
|
|
|
|
if (o->pickaxe_opts & DIFF_PICKAXE_ALL) {
|
|
|
|
/* Showing the whole changeset if needle exists */
|
|
|
|
for (i = 0; i < q->nr; i++) {
|
|
|
|
struct diff_filepair *p = q->queue[i];
|
|
|
|
if (pickaxe_match(p, o, regexp, kws, fn))
|
|
|
|
return; /* do not munge the queue */
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Otherwise we will clear the whole queue by copying
|
|
|
|
* the empty outq at the end of this function, but
|
|
|
|
* first clear the current entries in the queue.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < q->nr; i++)
|
|
|
|
diff_free_filepair(q->queue[i]);
|
|
|
|
} else {
|
|
|
|
/* Showing only the filepairs that has the needle */
|
|
|
|
for (i = 0; i < q->nr; i++) {
|
|
|
|
struct diff_filepair *p = q->queue[i];
|
|
|
|
if (pickaxe_match(p, o, regexp, kws, fn))
|
|
|
|
diff_q(&outq, p);
|
|
|
|
else
|
|
|
|
diff_free_filepair(p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
free(q->queue);
|
|
|
|
*q = outq;
|
|
|
|
}
|
|
|
|
|
2016-06-25 05:22:36 +00:00
|
|
|
static void regcomp_or_die(regex_t *regex, const char *needle, int cflags)
|
|
|
|
{
|
|
|
|
int err = regcomp(regex, needle, cflags);
|
|
|
|
if (err) {
|
|
|
|
/* The POSIX.2 people are surely sick */
|
|
|
|
char errbuf[1024];
|
|
|
|
regerror(err, regex, errbuf, 1024);
|
|
|
|
regfree(regex);
|
|
|
|
die("invalid regex: %s", errbuf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-22 17:15:57 +00:00
|
|
|
void diffcore_pickaxe(struct diff_options *o)
|
2005-05-21 09:40:01 +00:00
|
|
|
{
|
2010-08-31 20:44:39 +00:00
|
|
|
const char *needle = o->pickaxe;
|
|
|
|
int opts = o->pickaxe_opts;
|
2006-03-29 00:16:33 +00:00
|
|
|
regex_t regex, *regexp = NULL;
|
Use kwset in pickaxe
Benchmarks in the hot cache case:
before:
$ perf stat --repeat=5 git log -Sqwerty
Performance counter stats for 'git log -Sqwerty' (5 runs):
47,092,744 cache-misses # 2.825 M/sec ( +- 1.607% )
123,368,389 cache-references # 7.400 M/sec ( +- 0.812% )
330,040,998 branch-misses # 3.134 % ( +- 0.257% )
10,530,896,750 branches # 631.663 M/sec ( +- 0.121% )
62,037,201,030 instructions # 1.399 IPC ( +- 0.142% )
44,331,294,321 cycles # 2659.073 M/sec ( +- 0.326% )
96,794 page-faults # 0.006 M/sec ( +- 11.952% )
25 CPU-migrations # 0.000 M/sec ( +- 25.266% )
1,424 context-switches # 0.000 M/sec ( +- 0.540% )
16671.708650 task-clock-msecs # 0.997 CPUs ( +- 0.343% )
16.728692052 seconds time elapsed ( +- 0.344% )
after:
$ perf stat --repeat=5 git log -Sqwerty
Performance counter stats for 'git log -Sqwerty' (5 runs):
51,385,522 cache-misses # 4.619 M/sec ( +- 0.565% )
129,177,880 cache-references # 11.611 M/sec ( +- 0.219% )
319,222,775 branch-misses # 6.946 % ( +- 0.134% )
4,595,913,233 branches # 413.086 M/sec ( +- 0.112% )
31,395,042,533 instructions # 1.062 IPC ( +- 0.129% )
29,558,348,598 cycles # 2656.740 M/sec ( +- 0.204% )
93,224 page-faults # 0.008 M/sec ( +- 4.487% )
19 CPU-migrations # 0.000 M/sec ( +- 10.425% )
950 context-switches # 0.000 M/sec ( +- 0.360% )
11125.796039 task-clock-msecs # 0.997 CPUs ( +- 0.239% )
11.164216599 seconds time elapsed ( +- 0.240% )
So the kwset code is about 33% faster.
Signed-off-by: Fredrik Kuivinen <frekui@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-20 22:41:57 +00:00
|
|
|
kwset_t kws = NULL;
|
2005-05-21 09:40:01 +00:00
|
|
|
|
2014-03-22 17:15:57 +00:00
|
|
|
if (opts & (DIFF_PICKAXE_REGEX | DIFF_PICKAXE_KIND_G)) {
|
2014-03-22 17:15:56 +00:00
|
|
|
int cflags = REG_EXTENDED | REG_NEWLINE;
|
|
|
|
if (DIFF_OPT_TST(o, PICKAXE_IGNORE_CASE))
|
|
|
|
cflags |= REG_ICASE;
|
2016-06-25 05:22:36 +00:00
|
|
|
regcomp_or_die(®ex, needle, cflags);
|
2006-03-29 00:16:33 +00:00
|
|
|
regexp = ®ex;
|
2016-06-25 05:22:37 +00:00
|
|
|
} else if (DIFF_OPT_TST(o, PICKAXE_IGNORE_CASE) &&
|
|
|
|
has_non_ascii(needle)) {
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
int cflags = REG_NEWLINE | REG_ICASE;
|
|
|
|
|
|
|
|
basic_regex_quote_buf(&sb, needle);
|
|
|
|
regcomp_or_die(®ex, sb.buf, cflags);
|
|
|
|
strbuf_release(&sb);
|
|
|
|
regexp = ®ex;
|
Use kwset in pickaxe
Benchmarks in the hot cache case:
before:
$ perf stat --repeat=5 git log -Sqwerty
Performance counter stats for 'git log -Sqwerty' (5 runs):
47,092,744 cache-misses # 2.825 M/sec ( +- 1.607% )
123,368,389 cache-references # 7.400 M/sec ( +- 0.812% )
330,040,998 branch-misses # 3.134 % ( +- 0.257% )
10,530,896,750 branches # 631.663 M/sec ( +- 0.121% )
62,037,201,030 instructions # 1.399 IPC ( +- 0.142% )
44,331,294,321 cycles # 2659.073 M/sec ( +- 0.326% )
96,794 page-faults # 0.006 M/sec ( +- 11.952% )
25 CPU-migrations # 0.000 M/sec ( +- 25.266% )
1,424 context-switches # 0.000 M/sec ( +- 0.540% )
16671.708650 task-clock-msecs # 0.997 CPUs ( +- 0.343% )
16.728692052 seconds time elapsed ( +- 0.344% )
after:
$ perf stat --repeat=5 git log -Sqwerty
Performance counter stats for 'git log -Sqwerty' (5 runs):
51,385,522 cache-misses # 4.619 M/sec ( +- 0.565% )
129,177,880 cache-references # 11.611 M/sec ( +- 0.219% )
319,222,775 branch-misses # 6.946 % ( +- 0.134% )
4,595,913,233 branches # 413.086 M/sec ( +- 0.112% )
31,395,042,533 instructions # 1.062 IPC ( +- 0.129% )
29,558,348,598 cycles # 2656.740 M/sec ( +- 0.204% )
93,224 page-faults # 0.008 M/sec ( +- 4.487% )
19 CPU-migrations # 0.000 M/sec ( +- 10.425% )
950 context-switches # 0.000 M/sec ( +- 0.360% )
11125.796039 task-clock-msecs # 0.997 CPUs ( +- 0.239% )
11.164216599 seconds time elapsed ( +- 0.240% )
So the kwset code is about 33% faster.
Signed-off-by: Fredrik Kuivinen <frekui@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-20 22:41:57 +00:00
|
|
|
} else {
|
2012-02-21 09:02:46 +00:00
|
|
|
kws = kwsalloc(DIFF_OPT_TST(o, PICKAXE_IGNORE_CASE)
|
|
|
|
? tolower_trans_tbl : NULL);
|
2014-03-22 17:15:59 +00:00
|
|
|
kwsincr(kws, needle, strlen(needle));
|
Use kwset in pickaxe
Benchmarks in the hot cache case:
before:
$ perf stat --repeat=5 git log -Sqwerty
Performance counter stats for 'git log -Sqwerty' (5 runs):
47,092,744 cache-misses # 2.825 M/sec ( +- 1.607% )
123,368,389 cache-references # 7.400 M/sec ( +- 0.812% )
330,040,998 branch-misses # 3.134 % ( +- 0.257% )
10,530,896,750 branches # 631.663 M/sec ( +- 0.121% )
62,037,201,030 instructions # 1.399 IPC ( +- 0.142% )
44,331,294,321 cycles # 2659.073 M/sec ( +- 0.326% )
96,794 page-faults # 0.006 M/sec ( +- 11.952% )
25 CPU-migrations # 0.000 M/sec ( +- 25.266% )
1,424 context-switches # 0.000 M/sec ( +- 0.540% )
16671.708650 task-clock-msecs # 0.997 CPUs ( +- 0.343% )
16.728692052 seconds time elapsed ( +- 0.344% )
after:
$ perf stat --repeat=5 git log -Sqwerty
Performance counter stats for 'git log -Sqwerty' (5 runs):
51,385,522 cache-misses # 4.619 M/sec ( +- 0.565% )
129,177,880 cache-references # 11.611 M/sec ( +- 0.219% )
319,222,775 branch-misses # 6.946 % ( +- 0.134% )
4,595,913,233 branches # 413.086 M/sec ( +- 0.112% )
31,395,042,533 instructions # 1.062 IPC ( +- 0.129% )
29,558,348,598 cycles # 2656.740 M/sec ( +- 0.204% )
93,224 page-faults # 0.008 M/sec ( +- 4.487% )
19 CPU-migrations # 0.000 M/sec ( +- 10.425% )
950 context-switches # 0.000 M/sec ( +- 0.360% )
11125.796039 task-clock-msecs # 0.997 CPUs ( +- 0.239% )
11.164216599 seconds time elapsed ( +- 0.240% )
So the kwset code is about 33% faster.
Signed-off-by: Fredrik Kuivinen <frekui@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-20 22:41:57 +00:00
|
|
|
kwsprep(kws);
|
2006-03-29 00:16:33 +00:00
|
|
|
}
|
|
|
|
|
2014-03-22 17:15:57 +00:00
|
|
|
/* Might want to warn when both S and G are on; I don't care... */
|
|
|
|
pickaxe(&diff_queued_diff, o, regexp, kws,
|
|
|
|
(opts & DIFF_PICKAXE_KIND_G) ? diff_grep : has_changes);
|
2011-10-06 16:23:11 +00:00
|
|
|
|
2014-03-22 17:15:57 +00:00
|
|
|
if (regexp)
|
|
|
|
regfree(regexp);
|
Use kwset in pickaxe
Benchmarks in the hot cache case:
before:
$ perf stat --repeat=5 git log -Sqwerty
Performance counter stats for 'git log -Sqwerty' (5 runs):
47,092,744 cache-misses # 2.825 M/sec ( +- 1.607% )
123,368,389 cache-references # 7.400 M/sec ( +- 0.812% )
330,040,998 branch-misses # 3.134 % ( +- 0.257% )
10,530,896,750 branches # 631.663 M/sec ( +- 0.121% )
62,037,201,030 instructions # 1.399 IPC ( +- 0.142% )
44,331,294,321 cycles # 2659.073 M/sec ( +- 0.326% )
96,794 page-faults # 0.006 M/sec ( +- 11.952% )
25 CPU-migrations # 0.000 M/sec ( +- 25.266% )
1,424 context-switches # 0.000 M/sec ( +- 0.540% )
16671.708650 task-clock-msecs # 0.997 CPUs ( +- 0.343% )
16.728692052 seconds time elapsed ( +- 0.344% )
after:
$ perf stat --repeat=5 git log -Sqwerty
Performance counter stats for 'git log -Sqwerty' (5 runs):
51,385,522 cache-misses # 4.619 M/sec ( +- 0.565% )
129,177,880 cache-references # 11.611 M/sec ( +- 0.219% )
319,222,775 branch-misses # 6.946 % ( +- 0.134% )
4,595,913,233 branches # 413.086 M/sec ( +- 0.112% )
31,395,042,533 instructions # 1.062 IPC ( +- 0.129% )
29,558,348,598 cycles # 2656.740 M/sec ( +- 0.204% )
93,224 page-faults # 0.008 M/sec ( +- 4.487% )
19 CPU-migrations # 0.000 M/sec ( +- 10.425% )
950 context-switches # 0.000 M/sec ( +- 0.360% )
11125.796039 task-clock-msecs # 0.997 CPUs ( +- 0.239% )
11.164216599 seconds time elapsed ( +- 0.240% )
So the kwset code is about 33% faster.
Signed-off-by: Fredrik Kuivinen <frekui@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-20 22:41:57 +00:00
|
|
|
else
|
|
|
|
kwsfree(kws);
|
2005-05-21 09:40:01 +00:00
|
|
|
return;
|
|
|
|
}
|