2008-11-14 01:36:30 +01:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2008 Linus Torvalds
|
|
|
|
*/
|
|
|
|
#include "cache.h"
|
2013-07-14 10:35:25 +02:00
|
|
|
#include "pathspec.h"
|
2014-01-24 14:40:28 +01:00
|
|
|
#include "dir.h"
|
2008-11-15 13:08:14 +01:00
|
|
|
|
|
|
|
#ifdef NO_PTHREADS
|
2013-07-14 10:35:49 +02:00
|
|
|
static void preload_index(struct index_state *index,
|
|
|
|
const struct pathspec *pathspec)
|
2008-11-15 13:08:14 +01:00
|
|
|
{
|
|
|
|
; /* nothing */
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
|
2008-11-14 01:36:30 +01:00
|
|
|
#include <pthread.h>
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Mostly randomly chosen maximum thread counts: we
|
|
|
|
* cap the parallelism to 20 threads, and we want
|
|
|
|
* to have at least 500 lstat's per thread for it to
|
|
|
|
* be worth starting a thread.
|
|
|
|
*/
|
|
|
|
#define MAX_PARALLEL (20)
|
|
|
|
#define THREAD_COST (500)
|
|
|
|
|
|
|
|
struct thread_data {
|
|
|
|
pthread_t pthread;
|
|
|
|
struct index_state *index;
|
2013-07-14 10:35:49 +02:00
|
|
|
struct pathspec pathspec;
|
2008-11-14 01:36:30 +01:00
|
|
|
int offset, nr;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void *preload_thread(void *_data)
|
|
|
|
{
|
|
|
|
int nr;
|
|
|
|
struct thread_data *p = _data;
|
|
|
|
struct index_state *index = p->index;
|
|
|
|
struct cache_entry **cep = index->cache + p->offset;
|
2014-07-05 00:41:46 +02:00
|
|
|
struct cache_def cache = CACHE_DEF_INIT;
|
2008-11-14 01:36:30 +01:00
|
|
|
|
|
|
|
nr = p->nr;
|
|
|
|
if (nr + p->offset > index->cache_nr)
|
|
|
|
nr = index->cache_nr - p->offset;
|
|
|
|
|
|
|
|
do {
|
|
|
|
struct cache_entry *ce = *cep++;
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
if (ce_stage(ce))
|
|
|
|
continue;
|
2010-01-24 09:10:20 +01:00
|
|
|
if (S_ISGITLINK(ce->ce_mode))
|
|
|
|
continue;
|
2008-11-14 01:36:30 +01:00
|
|
|
if (ce_uptodate(ce))
|
|
|
|
continue;
|
2017-02-10 16:10:39 +01:00
|
|
|
if (ce_skip_worktree(ce))
|
|
|
|
continue;
|
2014-01-24 14:40:28 +01:00
|
|
|
if (!ce_path_match(ce, &p->pathspec, NULL))
|
2008-11-14 01:36:30 +01:00
|
|
|
continue;
|
2009-07-09 22:37:02 +02:00
|
|
|
if (threaded_has_symlink_leading_path(&cache, ce->name, ce_namelen(ce)))
|
|
|
|
continue;
|
2008-11-14 01:36:30 +01:00
|
|
|
if (lstat(ce->name, &st))
|
|
|
|
continue;
|
Fix index preloading for racy dirty case
In the threaded index preloading case, we must be sure to always use the
CE_MATCH_RACY_IS_DIRTY flag when calling ie_match_stat(), in order to make
sure that we only ever look at the stat() data, and don't try to do
anything fancy.
Because most of git internals are not thread-safe, and must not be called
in parallel.
Otherwise, what happens is that if the timestamps indicate that an entry
_might_ be dirty, we might start actually comparing filesystem data with
the object database. And we mustn't do that, because that would involve
looking up and creating the object structure, and that whole code sequence
with read_sha1_file() where we look up and add objects to the hashes is
definitely not thread-safe.
Nor do we want to add locking, because the whole point of the preload was
to be simple and not affect anything else. With CE_MATCH_RACY_IS_DIRTY, we
get what we wanted, and we'll just leave the hard cases well alone, to be
done later in the much simpler serial case.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-11-17 18:01:20 +01:00
|
|
|
if (ie_match_stat(index, ce, &st, CE_MATCH_RACY_IS_DIRTY))
|
2008-11-14 01:36:30 +01:00
|
|
|
continue;
|
|
|
|
ce_mark_uptodate(ce);
|
|
|
|
} while (--nr > 0);
|
2014-07-12 01:02:34 +02:00
|
|
|
cache_def_clear(&cache);
|
2008-11-14 01:36:30 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-07-14 10:35:49 +02:00
|
|
|
static void preload_index(struct index_state *index,
|
|
|
|
const struct pathspec *pathspec)
|
2008-11-14 01:36:30 +01:00
|
|
|
{
|
|
|
|
int threads, i, work, offset;
|
|
|
|
struct thread_data data[MAX_PARALLEL];
|
|
|
|
|
|
|
|
if (!core_preload_index)
|
|
|
|
return;
|
|
|
|
|
|
|
|
threads = index->cache_nr / THREAD_COST;
|
2017-09-22 18:35:38 +02:00
|
|
|
if ((index->cache_nr > 1) && (threads < 2) && getenv("GIT_FORCE_PRELOAD_TEST"))
|
|
|
|
threads = 2;
|
2008-11-14 01:36:30 +01:00
|
|
|
if (threads < 2)
|
|
|
|
return;
|
|
|
|
if (threads > MAX_PARALLEL)
|
|
|
|
threads = MAX_PARALLEL;
|
|
|
|
offset = 0;
|
2009-07-22 23:34:35 +02:00
|
|
|
work = DIV_ROUND_UP(index->cache_nr, threads);
|
2013-07-14 10:35:49 +02:00
|
|
|
memset(&data, 0, sizeof(data));
|
2008-11-14 01:36:30 +01:00
|
|
|
for (i = 0; i < threads; i++) {
|
|
|
|
struct thread_data *p = data+i;
|
|
|
|
p->index = index;
|
2013-07-14 10:35:49 +02:00
|
|
|
if (pathspec)
|
|
|
|
copy_pathspec(&p->pathspec, pathspec);
|
2008-11-14 01:36:30 +01:00
|
|
|
p->offset = offset;
|
|
|
|
p->nr = work;
|
|
|
|
offset += work;
|
|
|
|
if (pthread_create(&p->pthread, NULL, preload_thread, p))
|
|
|
|
die("unable to create threaded lstat");
|
|
|
|
}
|
|
|
|
for (i = 0; i < threads; i++) {
|
|
|
|
struct thread_data *p = data+i;
|
|
|
|
if (pthread_join(p->pthread, NULL))
|
|
|
|
die("unable to join threaded lstat");
|
|
|
|
}
|
|
|
|
}
|
2008-11-15 13:08:14 +01:00
|
|
|
#endif
|
2008-11-14 01:36:30 +01:00
|
|
|
|
2013-07-14 10:35:49 +02:00
|
|
|
int read_index_preload(struct index_state *index,
|
|
|
|
const struct pathspec *pathspec)
|
2008-11-14 01:36:30 +01:00
|
|
|
{
|
|
|
|
int retval = read_index(index);
|
|
|
|
|
|
|
|
preload_index(index, pathspec);
|
|
|
|
return retval;
|
|
|
|
}
|