update-index/diff-index: use core.preloadindex to improve performance

'update-index --refresh' and 'diff-index' (without --cached) don't honor
the core.preloadindex setting yet. Porcelain commands using these (such as
git [svn] rebase) suffer from this, especially on Windows.

Use read_cache_preload to improve performance.

Additionally, in builtin/diff.c, don't preload index status if we don't
access the working copy (--cached).

Results with msysgit on WebKit repo (2GB in 200k files):

| update-index | diff-index | rebase
----------------+--------------+------------+---------
msysgit-v1.8.0  |       9.157s |    10.536s | 42.791s
+ preloadindex  |       9.157s |    10.536s | 28.725s
+ this patch    |       2.329s |     2.752s | 15.152s
+ fscache [1]   |       0.731s |     1.171s |  8.877s

[1] https://github.com/kblees/git/tree/kb/fscache-v3

Thanks-to: Albert Krawczyk <pro-logic@optusnet.com.au>
Signed-off-by: Karsten Blees <blees@dcon.de>
Signed-off-by: Jeff King <peff@peff.net>

diff --git a/builtin/diff-index.c b/builtin/diff-index.c
index 2eb32bd9da8cfa4d7b1b99f9d22ffa5b3d6202e5..1c737f79216fda2e5395422d8aee2e4f5d6482a4 100644 (file)
--- a/builtin/diff-index.c
+++ b/builtin/diff-index.c
@@ -41,9 +41,13 @@ int cmd_diff_index(int argc, const char **argv, const char *prefix)
        if (rev.pending.nr != 1 ||
            rev.max_count != -1 || rev.min_age != -1 || rev.max_age != -1)
                usage(diff_cache_usage);
        if (rev.pending.nr != 1 ||
            rev.max_count != -1 || rev.min_age != -1 || rev.max_age != -1)
                usage(diff_cache_usage);

-       if (!cached)
+       if (!cached) {

                setup_work_tree();
                setup_work_tree();

-       if (read_cache() < 0) {
+               if (read_cache_preload(rev.diffopt.pathspec.raw) < 0) {
+                       perror("read_cache_preload");
+                       return -1;
+               }
+       } else if (read_cache() < 0) {

                perror("read_cache");
                return -1;
        }
                perror("read_cache");
                return -1;
        }

diff --git a/builtin/diff.c b/builtin/diff.c
index 9650be2c50e6f79dbe033fae39f490d49c6318da..198b9216a47e646e1372085e103cf8e72da31eba 100644 (file)
--- a/builtin/diff.c
+++ b/builtin/diff.c
@@ -130,8 +130,6 @@ static int builtin_diff_index(struct rev_info *revs,
                        usage(builtin_diff_usage);
                argv++; argc--;
        }
                        usage(builtin_diff_usage);
                argv++; argc--;
        }

-       if (!cached)
-               setup_work_tree();

        /*
         * Make sure there is one revision (i.e. pending object),
         * and there is no revision filtering parameters.
        /*
         * Make sure there is one revision (i.e. pending object),
         * and there is no revision filtering parameters.


@@ -140,8 +138,14 @@ static int builtin_diff_index(struct rev_info *revs,
            revs->max_count != -1 || revs->min_age != -1 ||
            revs->max_age != -1)
                usage(builtin_diff_usage);
            revs->max_count != -1 || revs->min_age != -1 ||
            revs->max_age != -1)
                usage(builtin_diff_usage);

-       if (read_cache_preload(revs->diffopt.pathspec.raw) < 0) {
-               perror("read_cache_preload");
+       if (!cached) {
+               setup_work_tree();
+               if (read_cache_preload(revs->diffopt.pathspec.raw) < 0) {
+                       perror("read_cache_preload");
+                       return -1;
+               }
+       } else if (read_cache() < 0) {
+               perror("read_cache");

                return -1;
        }
        return run_diff_index(revs, cached);
                return -1;
        }
        return run_diff_index(revs, cached);

diff --git a/builtin/update-index.c b/builtin/update-index.c
index 4ce341ceebbe27cc21b0341e4a4339af84af51de..dd8d10b3d57cc5a6e9cf1d071c9d17c1b5993df6 100644 (file)
--- a/builtin/update-index.c
+++ b/builtin/update-index.c
@@ -593,6 +593,7 @@ struct refresh_params {
 static int refresh(struct refresh_params *o, unsigned int flag)
 {
        setup_work_tree();
 static int refresh(struct refresh_params *o, unsigned int flag)
 {
        setup_work_tree();

+       read_cache_preload(NULL);

        *o->has_errors |= refresh_cache(o->flags | flag);
        return 0;
 }
        *o->has_errors |= refresh_cache(o->flags | flag);
        return 0;
 }