fixup! Merge pull request #964 from jeffhostetler/jeffhostetler/memihash_perf

I should really implement special-handling for a new drop! prefix to
commit messages...

This commit reverts that Pull Request, in preparation for merging in a new
iteration of that work (which looks substantially different from the
previous iteration...).

Signed-off-by: Johannes Schindelin <[email protected]>

Author: dscho

cache.h

@@ -173,9 +173,6 @@ struct cache_entry {
 	unsigned int ce_flags;
 	unsigned int ce_namelen;
 	unsigned int index;	/* for link extension */
-	unsigned int precompute_hash_state;
-	unsigned int precompute_hash_name;
-	unsigned int precompute_hash_dir;
 	struct object_id oid;
 	char name[FLEX_ARRAY]; /* more */
 };
@@ -232,19 +229,6 @@ struct cache_entry {
 #error "CE_EXTENDED_FLAGS out of range"
 #endif
 
-/*
- * Bit set if preload-index precomputed the hash value(s)
- * for this cache-entry.
- */ 
-#define CE_PRECOMPUTE_HASH_STATE__SET   (1 << 0)
-/*
- * Bit set if precompute-index also precomputed the hash value
- * for the parent directory.
- */ 
-#define CE_PRECOMPUTE_HASH_STATE__DIR   (1 << 1)
-
-void precompute_istate_hashes(struct cache_entry *ce);
-
 /* Forward structure decls */
 struct pathspec;
 struct child_process;

hashmap.c

@@ -50,23 +50,6 @@ unsigned int memihash(const void *buf, size_t len)
 	return hash;
 }
 
-/*
- * Incoporate another chunk of data into a memihash
- * computation.
- */ 
-unsigned int memihash_cont(unsigned int hash_seed, const void *buf, size_t len)
-{
-	unsigned int hash = hash_seed;
-	unsigned char *ucbuf = (unsigned char *) buf;
-	while (len--) {
-		unsigned int c = *ucbuf++;
-		if (c >= 'a' && c <= 'z')
-			c -= 'a' - 'A';
-		hash = (hash * FNV32_PRIME) ^ c;
-	}
-	return hash;
-}
-
 #define HASHMAP_INITIAL_SIZE 64
 /* grow / shrink by 2^2 */
 #define HASHMAP_RESIZE_BITS 2

hashmap.h

@@ -12,7 +12,6 @@ extern unsigned int strhash(const char *buf);
 extern unsigned int strihash(const char *buf);
 extern unsigned int memhash(const void *buf, size_t len);
 extern unsigned int memihash(const void *buf, size_t len);
-extern unsigned int memihash_cont(unsigned int hash_seed, const void *buf, size_t len);
 
 static inline unsigned int sha1hash(const unsigned char *sha1)
 {

name-hash.c

@@ -23,23 +23,17 @@ static int dir_entry_cmp(const struct dir_entry *e1,
 			name ? name : e2->name, e1->namelen);
 }
 
-static struct dir_entry *find_dir_entry__hash(struct index_state *istate,
-		const char *name, unsigned int namelen, unsigned int hash)
+static struct dir_entry *find_dir_entry(struct index_state *istate,
+		const char *name, unsigned int namelen)
 {
 	struct dir_entry key;
-	hashmap_entry_init(&key, hash);
+	hashmap_entry_init(&key, memihash(name, namelen));
 	key.namelen = namelen;
 	return hashmap_get(&istate->dir_hash, &key, name);
 }
 
-static struct dir_entry *find_dir_entry(struct index_state *istate,
-		const char *name, unsigned int namelen)
-{
-	return find_dir_entry__hash(istate, name, namelen, memihash(name,namelen));
-}
-
 static struct dir_entry *hash_dir_entry(struct index_state *istate,
-		struct cache_entry *ce, int namelen, struct dir_entry **p_previous_dir)
+		struct cache_entry *ce, int namelen)
 {
 	/*
 	 * Throw each directory component in the hash for quick lookup
@@ -49,18 +43,6 @@ static struct dir_entry *hash_dir_entry(struct index_state *istate,
 	 * in index_state.name_hash (as ordinary cache_entries).
 	 */
 	struct dir_entry *dir;
-	unsigned int hash;
-	int use_precomputed_dir_hash = 0;
-
-	if (ce->precompute_hash_state & CE_PRECOMPUTE_HASH_STATE__SET) {
-		if (!(ce->precompute_hash_state & CE_PRECOMPUTE_HASH_STATE__DIR))
-			return NULL; /* item does not have a parent directory */
-		if (namelen == ce_namelen(ce)) {
-			/* dir hash only valid for outer-most call (not recursive ones) */
-			use_precomputed_dir_hash = 1;
-			hash = ce->precompute_hash_dir;
-		}
-	}
 
 	/* get length of parent directory */
 	while (namelen > 0 && !is_dir_sep(ce->name[namelen - 1]))
@@ -70,43 +52,24 @@ static struct dir_entry *hash_dir_entry(struct index_state *istate,
 	namelen--;
 
 	/* lookup existing entry for that directory */
-	if (p_previous_dir && *p_previous_dir
-		&& namelen == (*p_previous_dir)->namelen
-		&& memcmp(ce->name, (*p_previous_dir)->name, namelen) == 0) {
-		/*
-		 * When our caller is sequentially iterating thru the index,
-		 * items in the same directory will be sequential, and therefore
-		 * refer to the same dir_entry.
-		 */
-		dir = *p_previous_dir;
-	} else {
-		if (!use_precomputed_dir_hash)
-			hash = memihash(ce->name, namelen);
-		dir = find_dir_entry__hash(istate, ce->name, namelen, hash);
-	}
-
+	dir = find_dir_entry(istate, ce->name, namelen);
 	if (!dir) {
 		/* not found, create it and add to hash table */
 		FLEX_ALLOC_MEM(dir, name, ce->name, namelen);
-		hashmap_entry_init(dir, hash);
+		hashmap_entry_init(dir, memihash(ce->name, namelen));
 		dir->namelen = namelen;
 		hashmap_add(&istate->dir_hash, dir);
 
 		/* recursively add missing parent directories */
-		dir->parent = hash_dir_entry(istate, ce, namelen, NULL);
+		dir->parent = hash_dir_entry(istate, ce, namelen);
 	}
-
-	if (p_previous_dir)
-		*p_previous_dir = dir;
-
 	return dir;
 }
 
-static void add_dir_entry(struct index_state *istate, struct cache_entry *ce,
-	struct dir_entry **p_previous_dir)
+static void add_dir_entry(struct index_state *istate, struct cache_entry *ce)
 {
 	/* Add reference to the directory entry (and parents if 0). */
-	struct dir_entry *dir = hash_dir_entry(istate, ce, ce_namelen(ce), p_previous_dir);
+	struct dir_entry *dir = hash_dir_entry(istate, ce, ce_namelen(ce));
 	while (dir && !(dir->nr++))
 		dir = dir->parent;
 }
@@ -117,7 +80,7 @@ static void remove_dir_entry(struct index_state *istate, struct cache_entry *ce)
 	 * Release reference to the directory entry. If 0, remove and continue
 	 * with parent directory.
 	 */
-	struct dir_entry *dir = hash_dir_entry(istate, ce, ce_namelen(ce), NULL);
+	struct dir_entry *dir = hash_dir_entry(istate, ce, ce_namelen(ce));
 	while (dir && !(--dir->nr)) {
 		struct dir_entry *parent = dir->parent;
 		hashmap_remove(&istate->dir_hash, dir, NULL);
@@ -126,25 +89,16 @@ static void remove_dir_entry(struct index_state *istate, struct cache_entry *ce)
 	}
 }
 
-static void hash_index_entry(struct index_state *istate, struct cache_entry *ce,
-	struct dir_entry **p_previous_dir)
+static void hash_index_entry(struct index_state *istate, struct cache_entry *ce)
 {
-	unsigned int h;
-
 	if (ce->ce_flags & CE_HASHED)
 		return;
 	ce->ce_flags |= CE_HASHED;
-
-	if (ce->precompute_hash_state & CE_PRECOMPUTE_HASH_STATE__SET)
-		h = ce->precompute_hash_name;
-	else
-		h = memihash(ce->name, ce_namelen(ce));
-
-	hashmap_entry_init(ce, h);
+	hashmap_entry_init(ce, memihash(ce->name, ce_namelen(ce)));
 	hashmap_add(&istate->name_hash, ce);
 
 	if (ignore_case)
-		add_dir_entry(istate, ce, p_previous_dir);
+		add_dir_entry(istate, ce);
 }
 
 static int cache_entry_cmp(const struct cache_entry *ce1,
@@ -160,24 +114,22 @@ static int cache_entry_cmp(const struct cache_entry *ce1,
 
 static void lazy_init_name_hash(struct index_state *istate)
 {
-	struct dir_entry *previous_dir = NULL;
 	int nr;
 
 	if (istate->name_hash_initialized)
 		return;
 	hashmap_init(&istate->name_hash, (hashmap_cmp_fn) cache_entry_cmp,
 			istate->cache_nr);
-	hashmap_init(&istate->dir_hash, (hashmap_cmp_fn) dir_entry_cmp,
-			istate->cache_nr);
+	hashmap_init(&istate->dir_hash, (hashmap_cmp_fn) dir_entry_cmp, 0);
 	for (nr = 0; nr < istate->cache_nr; nr++)
-		hash_index_entry(istate, istate->cache[nr], &previous_dir);
+		hash_index_entry(istate, istate->cache[nr]);
 	istate->name_hash_initialized = 1;
 }
 
 void add_name_hash(struct index_state *istate, struct cache_entry *ce)
 {
 	if (istate->name_hash_initialized)
-		hash_index_entry(istate, ce, NULL);
+		hash_index_entry(istate, ce);
 }
 
 void remove_name_hash(struct index_state *istate, struct cache_entry *ce)
@@ -284,45 +236,3 @@ void free_name_hash(struct index_state *istate)
 	hashmap_free(&istate->name_hash, 0);
 	hashmap_free(&istate->dir_hash, 1);
 }
-
-/*
- * Precompute the hash values for this cache_entry
- * for use in the istate.name_hash and istate.dir_hash.
- *
- * If the item is in the root directory, just compute the
- * hash value (for istate.name_hash) on the full path.
- *
- * If the item is in a subdirectory, first compute the
- * hash value for the immediate parent directory (for
- * istate.dir_hash) and then the hash value for the full
- * path by continuing the computation.
- *
- * Note that these hashes will be used by
- * wt_status_collect_untracked() as it scans the worktree
- * and maps observed paths back to the index (optionally
- * ignoring case).  Therefore, we probably only *NEED* to
- * precompute this for non-skip-worktree items (since
- * status should not observe skipped items), but because
- * lazy_init_name_hash() hashes everything, we force it
- * here.
- */ 
-void precompute_istate_hashes(struct cache_entry *ce)
-{
-	int namelen = ce_namelen(ce);
-
-	while (namelen > 0 && !is_dir_sep(ce->name[namelen - 1]))
-		namelen--;
-
-	if (namelen <= 0) {
-		ce->precompute_hash_name = memihash(ce->name, ce_namelen(ce));
-		ce->precompute_hash_state = CE_PRECOMPUTE_HASH_STATE__SET;
-	} else {
-		namelen--;
-		ce->precompute_hash_dir = memihash(ce->name, namelen);
-		ce->precompute_hash_name = memihash_cont(
-			ce->precompute_hash_dir, &ce->name[namelen],
-			ce_namelen(ce) - namelen);
-		ce->precompute_hash_state =
-			CE_PRECOMPUTE_HASH_STATE__SET | CE_PRECOMPUTE_HASH_STATE__DIR;
-	}
-}

preload-index.c

@@ -46,8 +46,6 @@ static void *preload_thread(void *_data)
 		struct cache_entry *ce = *cep++;
 		struct stat st;
 
-		precompute_istate_hashes(ce);
-
 		if (ce_stage(ce))
 			continue;
 		if (S_ISGITLINK(ce->ce_mode))

read-cache.c

@@ -77,7 +77,6 @@ void rename_index_entry_at(struct index_state *istate, int nr, const char *new_n
 	copy_cache_entry(new, old);
 	new->ce_flags &= ~CE_HASHED;
 	new->ce_namelen = namelen;
-	new->precompute_hash_state = 0;
 	new->index = 0;
 	memcpy(new->name, new_name, namelen + 1);
 
@@ -619,7 +618,6 @@ static struct cache_entry *create_alias_ce(struct index_state *istate,
 	new = xcalloc(1, cache_entry_size(len));
 	memcpy(new->name, alias->name, len);
 	copy_cache_entry(new, ce);
-	new->precompute_hash_state = 0;
 	save_or_free_index_entry(istate, ce);
 	return new;
 }
@@ -1550,7 +1548,6 @@ static struct cache_entry *cache_entry_from_ondisk(struct ondisk_cache_entry *on
 	ce->ce_stat_data.sd_size  = get_be32(&ondisk->size);
 	ce->ce_flags = flags & ~CE_NAMEMASK;
 	ce->ce_namelen = len;
-	ce->precompute_hash_state = 0;
 	ce->index = 0;
 	hashcpy(ce->oid.hash, ondisk->sha1);
 	memcpy(ce->name, name, len);