Reviewers: Michael Starzinger,
Description:
Minor cleanups of numeric seeded hashing patch.
Please review this at http://codereview.chromium.org/9155010/
SVN Base: http://v8.googlecode.com/svn/branches/bleeding_edge/
Affected files:
M src/arm/code-stubs-arm.cc
M src/arm/macro-assembler-arm.h
M src/arm/macro-assembler-arm.cc
M src/flag-definitions.h
M src/heap.h
M src/heap.cc
M src/ia32/code-stubs-ia32.cc
M src/ia32/macro-assembler-ia32.h
M src/ia32/macro-assembler-ia32.cc
M src/mips/code-stubs-mips.cc
M src/mips/macro-assembler-mips.h
M src/mips/macro-assembler-mips.cc
M src/objects-inl.h
M src/objects.h
M src/objects.cc
M src/profile-generator.cc
M src/x64/code-stubs-x64.cc
M src/x64/macro-assembler-x64.h
M src/x64/macro-assembler-x64.cc
M test/cctest/test-hashing.cc
Index: src/arm/code-stubs-arm.cc
===================================================================
--- src/arm/code-stubs-arm.cc (revision 10365)
+++ src/arm/code-stubs-arm.cc (working copy)
@@ -5730,7 +5730,7 @@
Register hash,
Register character) {
// hash = character + (character << 10);
- __ LoadRoot(hash, Heap::kStringHashSeedRootIndex);
+ __ LoadRoot(hash, Heap::kHashSeedRootIndex);
// Untag smi seed and add the character.
__ add(hash, character, Operand(hash, LSR, kSmiTagSize));
// hash += hash << 10;
Index: src/arm/macro-assembler-arm.cc
===================================================================
--- src/arm/macro-assembler-arm.cc (revision 10366)
+++ src/arm/macro-assembler-arm.cc (working copy)
@@ -1416,7 +1416,7 @@
void MacroAssembler::GetNumberHash(Register t0, Register scratch) {
// First of all we assign the hash seed to scratch.
- LoadRoot(scratch, Heap::kStringHashSeedRootIndex);
+ LoadRoot(scratch, Heap::kHashSeedRootIndex);
SmiUntag(scratch);
// Xor original key with a seed.
Index: src/arm/macro-assembler-arm.h
===================================================================
--- src/arm/macro-assembler-arm.h (revision 10366)
+++ src/arm/macro-assembler-arm.h (working copy)
@@ -590,10 +590,8 @@
Register scratch,
Label* miss);
-
void GetNumberHash(Register t0, Register scratch);
-
void LoadFromNumberDictionary(Label* miss,
Register elements,
Register key,
Index: src/flag-definitions.h
===================================================================
--- src/flag-definitions.h (revision 10365)
+++ src/flag-definitions.h (working copy)
@@ -349,13 +349,13 @@
"print stack trace when throwing exceptions")
DEFINE_bool(preallocate_message_memory, false,
"preallocate some memory to build stack traces.")
-DEFINE_bool(randomize_string_hashes,
+DEFINE_bool(randomize_hashes,
true,
- "randomize string hashes to avoid predictable hash collisions "
+ "randomize hashes to avoid predictable hash collisions "
"(with snapshots this option cannot override the baked-in
seed)")
-DEFINE_int(string_hash_seed,
+DEFINE_int(hash_seed,
0,
- "Fixed seed to use to string hashing (0 means random)"
+ "Fixed seed to use to hash property keys (0 means random)"
"(with snapshots this option cannot override the baked-in
seed)")
// v8.cc
Index: src/heap.cc
===================================================================
--- src/heap.cc (revision 10365)
+++ src/heap.cc (working copy)
@@ -5644,13 +5644,13 @@
if (!lo_space_->Setup()) return false;
// Setup the seed that is used to randomize the string hash function.
- ASSERT(string_hash_seed() == 0);
- if (FLAG_randomize_string_hashes) {
- if (FLAG_string_hash_seed == 0) {
- set_string_hash_seed(
+ ASSERT(hash_seed() == 0);
+ if (FLAG_randomize_hashes) {
+ if (FLAG_hash_seed == 0) {
+ set_hash_seed(
Smi::FromInt(V8::RandomPrivate(isolate()) & 0x3fffffff));
} else {
- set_string_hash_seed(Smi::FromInt(FLAG_string_hash_seed));
+ set_hash_seed(Smi::FromInt(FLAG_hash_seed));
}
}
Index: src/heap.h
===================================================================
--- src/heap.h (revision 10365)
+++ src/heap.h (working copy)
@@ -96,7 +96,7 @@
V(FixedArray, single_character_string_cache,
SingleCharacterStringCache) \
V(FixedArray, string_split_cache,
StringSplitCache) \
V(Object, termination_exception,
TerminationException) \
- V(Smi, string_hash_seed,
StringHashSeed) \
+ V(Smi, hash_seed,
HashSeed) \
V(Map, string_map,
StringMap) \
V(Map, symbol_map,
SymbolMap) \
V(Map, cons_string_map,
ConsStringMap) \
@@ -1506,9 +1506,9 @@
return idle_notification_will_schedule_next_gc_;
}
- uint32_t StringHashSeed() {
- uint32_t seed = static_cast<uint32_t>(string_hash_seed()->value());
- ASSERT(FLAG_randomize_string_hashes || seed == 0);
+ uint32_t HashSeed() {
+ uint32_t seed = static_cast<uint32_t>(hash_seed()->value());
+ ASSERT(FLAG_randomize_hashes || seed == 0);
return seed;
}
Index: src/ia32/code-stubs-ia32.cc
===================================================================
--- src/ia32/code-stubs-ia32.cc (revision 10365)
+++ src/ia32/code-stubs-ia32.cc (working copy)
@@ -6037,7 +6037,7 @@
if (Serializer::enabled()) {
ExternalReference roots_array_start =
ExternalReference::roots_array_start(masm->isolate());
- __ mov(scratch, Immediate(Heap::kStringHashSeedRootIndex));
+ __ mov(scratch, Immediate(Heap::kHashSeedRootIndex));
__ mov(scratch, Operand::StaticArray(scratch,
times_pointer_size,
roots_array_start));
@@ -6046,7 +6046,7 @@
__ shl(scratch, 10);
__ add(hash, scratch);
} else {
- int32_t seed = masm->isolate()->heap()->StringHashSeed();
+ int32_t seed = masm->isolate()->heap()->HashSeed();
__ lea(scratch, Operand(character, seed));
__ shl(scratch, 10);
__ lea(hash, Operand(scratch, character, times_1, seed));
Index: src/ia32/macro-assembler-ia32.cc
===================================================================
--- src/ia32/macro-assembler-ia32.cc (revision 10366)
+++ src/ia32/macro-assembler-ia32.cc (working copy)
@@ -1001,12 +1001,12 @@
if (Serializer::enabled()) {
ExternalReference roots_array_start =
ExternalReference::roots_array_start(isolate());
- mov(scratch, Immediate(Heap::kStringHashSeedRootIndex));
+ mov(scratch, Immediate(Heap::kHashSeedRootIndex));
xor_(r0, Operand::StaticArray(scratch,
times_pointer_size,
roots_array_start));
} else {
- int32_t seed = isolate()->heap()->StringHashSeed();
+ int32_t seed = isolate()->heap()->HashSeed();
xor_(r0, Immediate(seed));
}
Index: src/ia32/macro-assembler-ia32.h
===================================================================
--- src/ia32/macro-assembler-ia32.h (revision 10366)
+++ src/ia32/macro-assembler-ia32.h (working copy)
@@ -497,10 +497,8 @@
Register scratch,
Label* miss);
-
void GetNumberHash(Register r0, Register scratch);
-
void LoadFromNumberDictionary(Label* miss,
Register elements,
Register key,
Index: src/mips/code-stubs-mips.cc
===================================================================
--- src/mips/code-stubs-mips.cc (revision 10365)
+++ src/mips/code-stubs-mips.cc (working copy)
@@ -5927,7 +5927,7 @@
Register hash,
Register character) {
// hash = seed + character + ((seed + character) << 10);
- __ LoadRoot(hash, Heap::kStringHashSeedRootIndex);
+ __ LoadRoot(hash, Heap::kHashSeedRootIndex);
// Untag smi seed and add the character.
__ SmiUntag(hash);
__ addu(hash, hash, character);
Index: src/mips/macro-assembler-mips.cc
===================================================================
--- src/mips/macro-assembler-mips.cc (revision 10366)
+++ src/mips/macro-assembler-mips.cc (working copy)
@@ -411,7 +411,7 @@
void MacroAssembler::GetNumberHash(Register reg0, Register scratch) {
// First of all we assign the hash seed to scratch.
- LoadRoot(scratch, Heap::kStringHashSeedRootIndex);
+ LoadRoot(scratch, Heap::kHashSeedRootIndex);
SmiUntag(scratch);
// Xor original key with a seed.
Index: src/mips/macro-assembler-mips.h
===================================================================
--- src/mips/macro-assembler-mips.h (revision 10366)
+++ src/mips/macro-assembler-mips.h (working copy)
@@ -405,10 +405,8 @@
Register scratch,
Label* miss);
-
void GetNumberHash(Register reg0, Register scratch);
-
void LoadFromNumberDictionary(Label* miss,
Register elements,
Register key,
Index: src/objects-inl.h
===================================================================
--- src/objects-inl.h (revision 10366)
+++ src/objects-inl.h (working copy)
@@ -4328,7 +4328,7 @@
is_array_index_(0 < length_ && length_ <= String::kMaxArrayIndexSize),
is_first_char_(true),
is_valid_(true) {
- ASSERT(FLAG_randomize_string_hashes || raw_running_hash_ == 0);
+ ASSERT(FLAG_randomize_hashes || raw_running_hash_ == 0);
}
Index: src/objects.cc
===================================================================
--- src/objects.cc (revision 10366)
+++ src/objects.cc (working copy)
@@ -6929,14 +6929,14 @@
if (StringShape(this).IsSequentialAscii()) {
field = HashSequentialString(SeqAsciiString::cast(this)->GetChars(),
len,
- GetHeap()->StringHashSeed());
+ GetHeap()->HashSeed());
} else if (StringShape(this).IsSequentialTwoByte()) {
field = HashSequentialString(SeqTwoByteString::cast(this)->GetChars(),
len,
- GetHeap()->StringHashSeed());
+ GetHeap()->HashSeed());
} else {
StringInputBuffer buffer(this);
- field = ComputeHashField(&buffer, len, GetHeap()->StringHashSeed());
+ field = ComputeHashField(&buffer, len, GetHeap()->HashSeed());
}
// Store the hash code in the object.
@@ -10718,7 +10718,7 @@
uint32_t Hash() {
ASSERT(length_ >= 0);
ASSERT(from_ + length_ <= string_->length());
- StringHasher hasher(length_, string_->GetHeap()->StringHashSeed());
+ StringHasher hasher(length_, string_->GetHeap()->HashSeed());
// Very long strings have a trivial hash that doesn't inspect the
// string contents.
@@ -11636,7 +11636,7 @@
bool SymbolTable::LookupTwoCharsSymbolIfExists(uint32_t c1,
uint32_t c2,
String** symbol) {
- TwoCharHashTableKey key(c1, c2, GetHeap()->StringHashSeed());
+ TwoCharHashTableKey key(c1, c2, GetHeap()->HashSeed());
int entry = FindEntry(&key);
if (entry == kNotFound) {
return false;
@@ -11651,14 +11651,14 @@
MaybeObject* SymbolTable::LookupSymbol(Vector<const char> str,
Object** s) {
- Utf8SymbolKey key(str, GetHeap()->StringHashSeed());
+ Utf8SymbolKey key(str, GetHeap()->HashSeed());
return LookupKey(&key, s);
}
MaybeObject* SymbolTable::LookupAsciiSymbol(Vector<const char> str,
Object** s) {
- AsciiSymbolKey key(str, GetHeap()->StringHashSeed());
+ AsciiSymbolKey key(str, GetHeap()->HashSeed());
return LookupKey(&key, s);
}
@@ -11667,14 +11667,14 @@
int from,
int length,
Object** s) {
- SubStringAsciiSymbolKey key(str, from, length,
GetHeap()->StringHashSeed());
+ SubStringAsciiSymbolKey key(str, from, length, GetHeap()->HashSeed());
return LookupKey(&key, s);
}
MaybeObject* SymbolTable::LookupTwoByteSymbol(Vector<const uc16> str,
Object** s) {
- TwoByteSymbolKey key(str, GetHeap()->StringHashSeed());
+ TwoByteSymbolKey key(str, GetHeap()->HashSeed());
return LookupKey(&key, s);
}
Index: src/objects.h
===================================================================
--- src/objects.h (revision 10366)
+++ src/objects.h (working copy)
@@ -2599,7 +2599,7 @@
static const bool UsesSeed = false;
static uint32_t Hash(Key key) { return 0; }
static uint32_t SeededHash(Key key, uint32_t seed) {
- // Won't be called if UsesSeed isn't overridden by child class.
+ ASSERT(UsesSeed);
return Hash(key);
}
static uint32_t HashForObject(Key key, Object* object) { return 0; }
@@ -2616,7 +2616,7 @@
inline uint32_t Hash(Key key) {
if (Shape::UsesSeed) {
return Shape::SeededHash(key,
- GetHeap()->StringHashSeed());
+ GetHeap()->HashSeed());
} else {
return Shape::Hash(key);
}
@@ -2625,7 +2625,7 @@
inline uint32_t HashForObject(Key key, Object* object) {
if (Shape::UsesSeed) {
return Shape::SeededHashForObject(key,
- GetHeap()->StringHashSeed(), object);
+ GetHeap()->HashSeed(), object);
} else {
return Shape::HashForObject(key, object);
}
Index: src/profile-generator.cc
===================================================================
--- src/profile-generator.cc (revision 10366)
+++ src/profile-generator.cc (working copy)
@@ -111,7 +111,7 @@
OS::StrNCpy(dst, src, len);
dst[len] = '\0';
uint32_t hash =
- HashSequentialString(dst.start(), len, HEAP->StringHashSeed());
+ HashSequentialString(dst.start(), len, HEAP->HashSeed());
return AddOrDisposeString(dst.start(), hash);
}
@@ -145,7 +145,7 @@
return format;
}
uint32_t hash = HashSequentialString(
- str.start(), len, HEAP->StringHashSeed());
+ str.start(), len, HEAP->HashSeed());
return AddOrDisposeString(str.start(), hash);
}
@@ -156,7 +156,7 @@
SmartArrayPointer<char> data =
name->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL, 0,
length);
uint32_t hash =
- HashSequentialString(*data, length,
name->GetHeap()->StringHashSeed());
+ HashSequentialString(*data, length, name->GetHeap()->HashSeed());
return AddOrDisposeString(data.Detach(), hash);
}
return "";
@@ -1509,7 +1509,7 @@
const char* label = info->GetLabel();
id ^= HashSequentialString(label,
static_cast<int>(strlen(label)),
- HEAP->StringHashSeed());
+ HEAP->HashSeed());
intptr_t element_count = info->GetElementCount();
if (element_count != -1)
id ^= ComputeIntegerHash(static_cast<uint32_t>(element_count),
Index: src/x64/code-stubs-x64.cc
===================================================================
--- src/x64/code-stubs-x64.cc (revision 10365)
+++ src/x64/code-stubs-x64.cc (working copy)
@@ -4959,7 +4959,7 @@
Register character,
Register scratch) {
// hash = (seed + character) + ((seed + character) << 10);
- __ LoadRoot(scratch, Heap::kStringHashSeedRootIndex);
+ __ LoadRoot(scratch, Heap::kHashSeedRootIndex);
__ SmiToInteger32(scratch, scratch);
__ addl(scratch, character);
__ movl(hash, scratch);
Index: src/x64/macro-assembler-x64.cc
===================================================================
--- src/x64/macro-assembler-x64.cc (revision 10366)
+++ src/x64/macro-assembler-x64.cc (working copy)
@@ -3421,7 +3421,7 @@
void MacroAssembler::GetNumberHash(Register r0, Register scratch) {
// First of all we assign the hash seed to scratch.
- LoadRoot(scratch, Heap::kStringHashSeedRootIndex);
+ LoadRoot(scratch, Heap::kHashSeedRootIndex);
SmiToInteger32(scratch, scratch);
// Xor original key with a seed.
Index: src/x64/macro-assembler-x64.h
===================================================================
--- src/x64/macro-assembler-x64.h (revision 10366)
+++ src/x64/macro-assembler-x64.h (working copy)
@@ -986,10 +986,8 @@
Register scratch,
Label* miss);
-
void GetNumberHash(Register r0, Register scratch);
-
void LoadFromNumberDictionary(Label* miss,
Register elements,
Register key,
Index: test/cctest/test-hashing.cc
===================================================================
--- test/cctest/test-hashing.cc (revision 10366)
+++ test/cctest/test-hashing.cc (working copy)
@@ -206,7 +206,7 @@
uint32_t runtime_hash = ComputeIntegerHash(
key,
- Isolate::Current()->heap()->StringHashSeed());
+ Isolate::Current()->heap()->HashSeed());
CHECK(runtime_hash == codegen_hash);
}
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
