status: show progress bar if refreshing the index takes too long

Refreshing the index is usually very fast, but it can still take a
long time sometimes. Cold cache is one. Or copying a repo to a new
place (*). It's good to show something to let the user know "git
status" is not hanging, it's just busy doing something.

(*) In this case, all stat info in the index becomes invalid and git
falls back to rehashing all file content to see if there's any
difference between updating stat info in the index. This is quite
expensive. Even with a repo as small as git.git, it takes 3
seconds.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin/am.c b/builtin/am.c
index 5e866d17c7c7b46ccf671916c853be228bf38ad6..22a93cfef34c0807f0e717031e0e02b6f11bebf0 100644 (file)
--- a/builtin/am.c
+++ b/builtin/am.c
@@ -2324,7 +2324,7 @@ int cmd_am(int argc, const char **argv, const char *prefix)
        /* Ensure a valid committer ident can be constructed */
        git_committer_info(IDENT_STRICT);
 
        /* Ensure a valid committer ident can be constructed */
        git_committer_info(IDENT_STRICT);
 

-       if (read_index_preload(&the_index, NULL) < 0)
+       if (read_index_preload(&the_index, NULL, 0) < 0)

                die(_("failed to read the index"));
 
        if (in_progress) {
                die(_("failed to read the index"));
 
        if (in_progress) {

diff --git a/builtin/commit.c b/builtin/commit.c
index 0d9828e29ebe89f037e68761d5cd5b407339cd48..752346306690a8aa7421882c70660b4af3ec5cbc 100644 (file)
--- a/builtin/commit.c
+++ b/builtin/commit.c
@@ -1295,6 +1295,7 @@ int cmd_status(int argc, const char **argv, const char *prefix)
        static int no_renames = -1;
        static const char *rename_score_arg = (const char *)-1;
        static struct wt_status s;
        static int no_renames = -1;
        static const char *rename_score_arg = (const char *)-1;
        static struct wt_status s;

+       unsigned int progress_flag = 0;

        int fd;
        struct object_id oid;
        static struct option builtin_status_options[] = {
        int fd;
        struct object_id oid;
        static struct option builtin_status_options[] = {


@@ -1355,8 +1356,13 @@ int cmd_status(int argc, const char **argv, const char *prefix)
                       PATHSPEC_PREFER_FULL,
                       prefix, argv);
 
                       PATHSPEC_PREFER_FULL,
                       prefix, argv);
 

-       read_cache_preload(&s.pathspec);
-       refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, &s.pathspec, NULL, NULL);
+       if (status_format != STATUS_FORMAT_PORCELAIN &&
+           status_format != STATUS_FORMAT_PORCELAIN_V2)
+               progress_flag = REFRESH_PROGRESS;
+       read_index_preload(&the_index, &s.pathspec, progress_flag);
+       refresh_index(&the_index,
+                     REFRESH_QUIET|REFRESH_UNMERGED|progress_flag,
+                     &s.pathspec, NULL, NULL);

 
        if (use_optional_locks())
                fd = hold_locked_index(&index_lock, 0);
 
        if (use_optional_locks())
                fd = hold_locked_index(&index_lock, 0);

diff --git a/cache.h b/cache.h
index 4d014541ab7bc7692919c871a5306543bbf361c5..35da02be9004fb9b12f9425f38637f468344f21c 100644 (file)
--- a/cache.h
+++ b/cache.h
@@ -410,7 +410,7 @@ void validate_cache_entries(const struct index_state *istate);
 
 #define read_cache() read_index(&the_index)
 #define read_cache_from(path) read_index_from(&the_index, (path), (get_git_dir()))
 
 #define read_cache() read_index(&the_index)
 #define read_cache_from(path) read_index_from(&the_index, (path), (get_git_dir()))

-#define read_cache_preload(pathspec) read_index_preload(&the_index, (pathspec))
+#define read_cache_preload(pathspec) read_index_preload(&the_index, (pathspec), 0)

 #define is_cache_unborn() is_index_unborn(&the_index)
 #define read_cache_unmerged() read_index_unmerged(&the_index)
 #define discard_cache() discard_index(&the_index)
 #define is_cache_unborn() is_index_unborn(&the_index)
 #define read_cache_unmerged() read_index_unmerged(&the_index)
 #define discard_cache() discard_index(&the_index)


@@ -659,7 +659,9 @@ extern int daemonize(void);
 /* Initialize and use the cache information */
 struct lock_file;
 extern int read_index(struct index_state *);
 /* Initialize and use the cache information */
 struct lock_file;
 extern int read_index(struct index_state *);

-extern int read_index_preload(struct index_state *, const struct pathspec *pathspec);
+extern int read_index_preload(struct index_state *,
+                             const struct pathspec *pathspec,
+                             unsigned int refresh_flags);

 extern int do_read_index(struct index_state *istate, const char *path,
                         int must_exist); /* for testting only! */
 extern int read_index_from(struct index_state *, const char *path,
 extern int do_read_index(struct index_state *istate, const char *path,
                         int must_exist); /* for testting only! */
 extern int read_index_from(struct index_state *, const char *path,


@@ -814,6 +816,7 @@ extern void fill_stat_cache_info(struct cache_entry *ce, struct stat *st);
 #define REFRESH_IGNORE_MISSING 0x0008  /* ignore non-existent */
 #define REFRESH_IGNORE_SUBMODULES      0x0010  /* ignore submodules */
 #define REFRESH_IN_PORCELAIN   0x0020  /* user friendly output, not "needs update" */
 #define REFRESH_IGNORE_MISSING 0x0008  /* ignore non-existent */
 #define REFRESH_IGNORE_SUBMODULES      0x0010  /* ignore submodules */
 #define REFRESH_IN_PORCELAIN   0x0020  /* user friendly output, not "needs update" */

+#define REFRESH_PROGRESS       0x0040  /* show progress bar if stderr is tty */

 extern int refresh_index(struct index_state *, unsigned int flags, const struct pathspec *pathspec, char *seen, const char *header_msg);
 extern struct cache_entry *refresh_cache_entry(struct index_state *, struct cache_entry *, unsigned int);
 
 extern int refresh_index(struct index_state *, unsigned int flags, const struct pathspec *pathspec, char *seen, const char *header_msg);
 extern struct cache_entry *refresh_cache_entry(struct index_state *, struct cache_entry *, unsigned int);
 

diff --git a/preload-index.c b/preload-index.c
index 71cd2437a3b33b343696bf96067603e8dc9e4464..2541b307e8bafc7280c0ded43346a0d723af1768 100644 (file)
--- a/preload-index.c
+++ b/preload-index.c
@@ -5,10 +5,12 @@
 #include "pathspec.h"
 #include "dir.h"
 #include "fsmonitor.h"
 #include "pathspec.h"
 #include "dir.h"
 #include "fsmonitor.h"

+#include "progress.h"

 
 #ifdef NO_PTHREADS
 static void preload_index(struct index_state *index,
 
 #ifdef NO_PTHREADS
 static void preload_index(struct index_state *index,

-                         const struct pathspec *pathspec)
+                         const struct pathspec *pathspec,
+                         unsigned int refresh_flags)

 {
        ; /* nothing */
 }
 {
        ; /* nothing */
 }


@@ -25,16 +27,23 @@ static void preload_index(struct index_state *index,
 #define MAX_PARALLEL (20)
 #define THREAD_COST (500)
 
 #define MAX_PARALLEL (20)
 #define THREAD_COST (500)
 

+struct progress_data {
+       unsigned long n;
+       struct progress *progress;
+       pthread_mutex_t mutex;
+};
+

 struct thread_data {
        pthread_t pthread;
        struct index_state *index;
        struct pathspec pathspec;
 struct thread_data {
        pthread_t pthread;
        struct index_state *index;
        struct pathspec pathspec;

+       struct progress_data *progress;

        int offset, nr;
 };
 
 static void *preload_thread(void *_data)
 {
        int offset, nr;
 };
 
 static void *preload_thread(void *_data)
 {

-       int nr;
+       int nr, last_nr;

        struct thread_data *p = _data;
        struct index_state *index = p->index;
        struct cache_entry **cep = index->cache + p->offset;
        struct thread_data *p = _data;
        struct index_state *index = p->index;
        struct cache_entry **cep = index->cache + p->offset;


@@ -43,6 +52,7 @@ static void *preload_thread(void *_data)
        nr = p->nr;
        if (nr + p->offset > index->cache_nr)
                nr = index->cache_nr - p->offset;
        nr = p->nr;
        if (nr + p->offset > index->cache_nr)
                nr = index->cache_nr - p->offset;

+       last_nr = nr;

 
        do {
                struct cache_entry *ce = *cep++;
 
        do {
                struct cache_entry *ce = *cep++;


@@ -58,6 +68,15 @@ static void *preload_thread(void *_data)
                        continue;
                if (ce->ce_flags & CE_FSMONITOR_VALID)
                        continue;
                        continue;
                if (ce->ce_flags & CE_FSMONITOR_VALID)
                        continue;

+               if (p->progress && !(nr & 31)) {
+                       struct progress_data *pd = p->progress;
+
+                       pthread_mutex_lock(&pd->mutex);
+                       pd->n += last_nr - nr;
+                       display_progress(pd->progress, pd->n);
+                       pthread_mutex_unlock(&pd->mutex);
+                       last_nr = nr;
+               }

                if (!ce_path_match(index, ce, &p->pathspec, NULL))
                        continue;
                if (threaded_has_symlink_leading_path(&cache, ce->name, ce_namelen(ce)))
                if (!ce_path_match(index, ce, &p->pathspec, NULL))
                        continue;
                if (threaded_has_symlink_leading_path(&cache, ce->name, ce_namelen(ce)))


@@ -69,16 +88,25 @@ static void *preload_thread(void *_data)
                ce_mark_uptodate(ce);
                mark_fsmonitor_valid(ce);
        } while (--nr > 0);
                ce_mark_uptodate(ce);
                mark_fsmonitor_valid(ce);
        } while (--nr > 0);

+       if (p->progress) {
+               struct progress_data *pd = p->progress;
+
+               pthread_mutex_lock(&pd->mutex);
+               display_progress(pd->progress, pd->n + last_nr);
+               pthread_mutex_unlock(&pd->mutex);
+       }

        cache_def_clear(&cache);
        return NULL;
 }
 
 static void preload_index(struct index_state *index,
        cache_def_clear(&cache);
        return NULL;
 }
 
 static void preload_index(struct index_state *index,

-                         const struct pathspec *pathspec)
+                         const struct pathspec *pathspec,
+                         unsigned int refresh_flags)

 {
        int threads, i, work, offset;
        struct thread_data data[MAX_PARALLEL];
        uint64_t start = getnanotime();
 {
        int threads, i, work, offset;
        struct thread_data data[MAX_PARALLEL];
        uint64_t start = getnanotime();

+       struct progress_data pd;

 
        if (!core_preload_index)
                return;
 
        if (!core_preload_index)
                return;


@@ -93,6 +121,13 @@ static void preload_index(struct index_state *index,
        offset = 0;
        work = DIV_ROUND_UP(index->cache_nr, threads);
        memset(&data, 0, sizeof(data));
        offset = 0;
        work = DIV_ROUND_UP(index->cache_nr, threads);
        memset(&data, 0, sizeof(data));

+
+       memset(&pd, 0, sizeof(pd));
+       if (refresh_flags & REFRESH_PROGRESS && isatty(2)) {
+               pd.progress = start_delayed_progress(_("Refreshing index"), index->cache_nr);
+               pthread_mutex_init(&pd.mutex, NULL);
+       }
+

        for (i = 0; i < threads; i++) {
                struct thread_data *p = data+i;
                p->index = index;
        for (i = 0; i < threads; i++) {
                struct thread_data *p = data+i;
                p->index = index;


@@ -100,6 +135,8 @@ static void preload_index(struct index_state *index,
                        copy_pathspec(&p->pathspec, pathspec);
                p->offset = offset;
                p->nr = work;
                        copy_pathspec(&p->pathspec, pathspec);
                p->offset = offset;
                p->nr = work;

+               if (pd.progress)
+                       p->progress = &pd;

                offset += work;
                if (pthread_create(&p->pthread, NULL, preload_thread, p))
                        die("unable to create threaded lstat");
                offset += work;
                if (pthread_create(&p->pthread, NULL, preload_thread, p))
                        die("unable to create threaded lstat");


@@ -109,15 +146,18 @@ static void preload_index(struct index_state *index,
                if (pthread_join(p->pthread, NULL))
                        die("unable to join threaded lstat");
        }
                if (pthread_join(p->pthread, NULL))
                        die("unable to join threaded lstat");
        }

+       stop_progress(&pd.progress);
+

        trace_performance_since(start, "preload index");
 }
 #endif
 
 int read_index_preload(struct index_state *index,
        trace_performance_since(start, "preload index");
 }
 #endif
 
 int read_index_preload(struct index_state *index,

-                      const struct pathspec *pathspec)
+                      const struct pathspec *pathspec,
+                      unsigned int refresh_flags)

 {
        int retval = read_index(index);
 
 {
        int retval = read_index(index);
 

-       preload_index(index, pathspec);
+       preload_index(index, pathspec, refresh_flags);

        return retval;
 }
        return retval;
 }

diff --git a/read-cache.c b/read-cache.c
index 7b1354d7590a70ecbd6e508bdd95eafd4793efcc..5969ca93c7e5d933aba0e882a0299b29419a2990 100644 (file)
--- a/read-cache.c
+++ b/read-cache.c
@@ -23,6 +23,7 @@
 #include "split-index.h"
 #include "utf8.h"
 #include "fsmonitor.h"
 #include "split-index.h"
 #include "utf8.h"
 #include "fsmonitor.h"

+#include "progress.h"

 
 /* Mask for the name length in ce_flags in the on-disk index */
 
 
 /* Mask for the name length in ce_flags in the on-disk index */
 


@@ -1477,6 +1478,11 @@ int refresh_index(struct index_state *istate, unsigned int flags,
        const char *added_fmt;
        const char *unmerged_fmt;
        uint64_t start = getnanotime();
        const char *added_fmt;
        const char *unmerged_fmt;
        uint64_t start = getnanotime();

+       struct progress *progress = NULL;
+
+       if (flags & REFRESH_PROGRESS && isatty(2))
+               progress = start_delayed_progress(_("Refresh index"),
+                                                 istate->cache_nr);

 
        modified_fmt = (in_porcelain ? "M\t%s\n" : "%s: needs update\n");
        deleted_fmt = (in_porcelain ? "D\t%s\n" : "%s: needs update\n");
 
        modified_fmt = (in_porcelain ? "M\t%s\n" : "%s: needs update\n");
        deleted_fmt = (in_porcelain ? "D\t%s\n" : "%s: needs update\n");


@@ -1516,6 +1522,8 @@ int refresh_index(struct index_state *istate, unsigned int flags,
                new_entry = refresh_cache_ent(istate, ce, options, &cache_errno, &changed);
                if (new_entry == ce)
                        continue;
                new_entry = refresh_cache_ent(istate, ce, options, &cache_errno, &changed);
                if (new_entry == ce)
                        continue;

+               if (progress)
+                       display_progress(progress, i);

                if (!new_entry) {
                        const char *fmt;
 
                if (!new_entry) {
                        const char *fmt;
 


@@ -1547,6 +1555,10 @@ int refresh_index(struct index_state *istate, unsigned int flags,
 
                replace_index_entry(istate, i, new_entry);
        }
 
                replace_index_entry(istate, i, new_entry);
        }

+       if (progress) {
+               display_progress(progress, istate->cache_nr);
+               stop_progress(&progress);
+       }

        trace_performance_since(start, "refresh index");
        return has_errors;
 }
        trace_performance_since(start, "refresh index");
        return has_errors;
 }

diff --git a/sequencer.c b/sequencer.c
index dc2c58d464c14be033f4bcba2ab4332886ead327..e0cd17df701de6d625b9e89975361dc42cfbccbe 100644 (file)
--- a/sequencer.c
+++ b/sequencer.c
@@ -1909,7 +1909,7 @@ static int read_and_refresh_cache(struct replay_opts *opts)
 {
        struct lock_file index_lock = LOCK_INIT;
        int index_fd = hold_locked_index(&index_lock, 0);
 {
        struct lock_file index_lock = LOCK_INIT;
        int index_fd = hold_locked_index(&index_lock, 0);

-       if (read_index_preload(&the_index, NULL) < 0) {
+       if (read_index_preload(&the_index, NULL, 0) < 0) {

                rollback_lock_file(&index_lock);
                return error(_("git %s: failed to read the index"),
                        _(action_name(opts)));
                rollback_lock_file(&index_lock);
                return error(_("git %s: failed to read the index"),
                        _(action_name(opts)));