mirror of
https://github.com/dart-lang/sdk
synced 2024-09-05 00:13:50 +00:00
7c6cab995a
The Insert method runs in constant time, but inserting multiple pairs with the same key results in all pairs being added to the map. Remove only removes the most recent pair with a key equal to its argument, so this means calling Remove after an Insert does not guarantee that Lookup for a key will fail. The new Update method, when used instead of Insert, guarantees that the map contains at most one pair for a set of equal keys. This means that Lookup is guaranteed to fail after a Remove call, but the Update method requires walking the existing chain of entries for the key's hash value. (In practice, our code tends to call Lookup before Insert to avoid adding pairs with equal keys more than once, but this practice does mean that updating the value returned by Lookup cannot be done without first removing the old entry. This new method simplifies that workflow if used consistently.) Change-Id: I2944472a7fc74c1de41cb25eb9469a7c7e491ceb Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/114069 Commit-Queue: Teagan Strickland <sstrickl@google.com> Reviewed-by: Martin Kustermann <kustermann@google.com>
304 lines
8.3 KiB
C++
304 lines
8.3 KiB
C++
// Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file
|
|
// for details. All rights reserved. Use of this source code is governed by a
|
|
// BSD-style license that can be found in the LICENSE file.
|
|
|
|
#include "vm/hash_map.h"
|
|
#include "platform/assert.h"
|
|
#include "vm/unit_test.h"
|
|
|
|
namespace dart {
|
|
|
|
class TestValue {
|
|
public:
|
|
explicit TestValue(intptr_t x) : x_(x) {}
|
|
intptr_t Hashcode() const { return x_ & 1; }
|
|
bool Equals(TestValue* other) { return x_ == other->x_; }
|
|
|
|
private:
|
|
intptr_t x_;
|
|
};
|
|
|
|
TEST_CASE(DirectChainedHashMap) {
|
|
DirectChainedHashMap<PointerKeyValueTrait<TestValue> > map;
|
|
EXPECT(map.IsEmpty());
|
|
TestValue v1(0);
|
|
TestValue v2(1);
|
|
TestValue v3(0);
|
|
map.Insert(&v1);
|
|
EXPECT(map.LookupValue(&v1) == &v1);
|
|
map.Insert(&v2);
|
|
EXPECT(map.LookupValue(&v1) == &v1);
|
|
EXPECT(map.LookupValue(&v2) == &v2);
|
|
EXPECT(map.LookupValue(&v3) == &v1);
|
|
EXPECT(map.Remove(&v1));
|
|
EXPECT(map.Lookup(&v1) == NULL);
|
|
map.Insert(&v1);
|
|
DirectChainedHashMap<PointerKeyValueTrait<TestValue> > map2(map);
|
|
EXPECT(map2.LookupValue(&v1) == &v1);
|
|
EXPECT(map2.LookupValue(&v2) == &v2);
|
|
EXPECT(map2.LookupValue(&v3) == &v1);
|
|
}
|
|
|
|
TEST_CASE(DirectChainedHashMapInsertRemove) {
|
|
DirectChainedHashMap<PointerKeyValueTrait<TestValue> > map;
|
|
EXPECT(map.IsEmpty());
|
|
TestValue v1(1);
|
|
TestValue v2(3); // Note: v1, v2, v3 should have the same hash.
|
|
TestValue v3(5);
|
|
|
|
// Start with adding and removing the same element.
|
|
map.Insert(&v1);
|
|
EXPECT(map.LookupValue(&v1) == &v1);
|
|
EXPECT(map.Remove(&v1));
|
|
EXPECT(map.Lookup(&v1) == NULL);
|
|
|
|
// Inserting v2 first should put it at the head of the list.
|
|
map.Insert(&v2);
|
|
map.Insert(&v1);
|
|
EXPECT(map.LookupValue(&v2) == &v2);
|
|
EXPECT(map.LookupValue(&v1) == &v1);
|
|
|
|
// Check to see if removing the head of the list causes issues.
|
|
EXPECT(map.Remove(&v2));
|
|
EXPECT(map.Lookup(&v2) == NULL);
|
|
EXPECT(map.LookupValue(&v1) == &v1);
|
|
|
|
// Reinsert v2, which will place it at the back of the hash map list.
|
|
map.Insert(&v2);
|
|
EXPECT(map.LookupValue(&v2) == &v2);
|
|
|
|
// Remove from the back of the hash map list.
|
|
EXPECT(map.Remove(&v2));
|
|
EXPECT(map.Lookup(&v2) == NULL);
|
|
EXPECT(map.Remove(&v1));
|
|
EXPECT(map.Lookup(&v1) == NULL);
|
|
|
|
// Check to see that removing an invalid element returns false.
|
|
EXPECT(!map.Remove(&v1));
|
|
|
|
// One last case: remove from the middle of a hash map list.
|
|
map.Insert(&v1);
|
|
map.Insert(&v2);
|
|
map.Insert(&v3);
|
|
|
|
EXPECT(map.LookupValue(&v1) == &v1);
|
|
EXPECT(map.LookupValue(&v2) == &v2);
|
|
EXPECT(map.LookupValue(&v3) == &v3);
|
|
|
|
EXPECT(map.Remove(&v2));
|
|
EXPECT(map.LookupValue(&v1) == &v1);
|
|
EXPECT(map.Lookup(&v2) == NULL);
|
|
EXPECT(map.LookupValue(&v3) == &v3);
|
|
|
|
EXPECT(map.Remove(&v1));
|
|
EXPECT(map.Remove(&v3));
|
|
|
|
EXPECT(map.IsEmpty());
|
|
}
|
|
|
|
TEST_CASE(MallocDirectChainedHashMap) {
|
|
MallocDirectChainedHashMap<PointerKeyValueTrait<TestValue> > map;
|
|
EXPECT(map.IsEmpty());
|
|
TestValue v1(0);
|
|
TestValue v2(1);
|
|
TestValue v3(0);
|
|
map.Insert(&v1);
|
|
EXPECT(map.LookupValue(&v1) == &v1);
|
|
map.Insert(&v2);
|
|
EXPECT(map.LookupValue(&v1) == &v1);
|
|
EXPECT(map.LookupValue(&v2) == &v2);
|
|
EXPECT(map.LookupValue(&v3) == &v1);
|
|
MallocDirectChainedHashMap<PointerKeyValueTrait<TestValue> > map2(map);
|
|
EXPECT(map2.LookupValue(&v1) == &v1);
|
|
EXPECT(map2.LookupValue(&v2) == &v2);
|
|
EXPECT(map2.LookupValue(&v3) == &v1);
|
|
}
|
|
|
|
class IntptrPair {
|
|
public:
|
|
IntptrPair() : first_(-1), second_(-1) {}
|
|
IntptrPair(intptr_t first, intptr_t second)
|
|
: first_(first), second_(second) {}
|
|
|
|
intptr_t first() const { return first_; }
|
|
intptr_t second() const { return second_; }
|
|
|
|
bool operator==(const IntptrPair& other) {
|
|
return (first_ == other.first_) && (second_ == other.second_);
|
|
}
|
|
|
|
bool operator!=(const IntptrPair& other) {
|
|
return (first_ != other.first_) || (second_ != other.second_);
|
|
}
|
|
|
|
private:
|
|
intptr_t first_;
|
|
intptr_t second_;
|
|
};
|
|
|
|
TEST_CASE(DirectChainedHashMapIterator) {
|
|
IntptrPair p1(1, 1);
|
|
IntptrPair p2(2, 2);
|
|
IntptrPair p3(3, 3);
|
|
IntptrPair p4(4, 4);
|
|
IntptrPair p5(5, 5);
|
|
DirectChainedHashMap<NumbersKeyValueTrait<IntptrPair> > map;
|
|
EXPECT(map.IsEmpty());
|
|
DirectChainedHashMap<NumbersKeyValueTrait<IntptrPair> >::Iterator it =
|
|
map.GetIterator();
|
|
EXPECT(it.Next() == NULL);
|
|
it.Reset();
|
|
|
|
map.Insert(p1);
|
|
EXPECT(*it.Next() == p1);
|
|
it.Reset();
|
|
|
|
map.Insert(p2);
|
|
map.Insert(p3);
|
|
map.Insert(p4);
|
|
map.Insert(p5);
|
|
intptr_t count = 0;
|
|
intptr_t sum = 0;
|
|
while (true) {
|
|
IntptrPair* p = it.Next();
|
|
if (p == NULL) {
|
|
break;
|
|
}
|
|
count++;
|
|
sum += p->second();
|
|
}
|
|
|
|
EXPECT(count == 5);
|
|
EXPECT(sum == 15);
|
|
}
|
|
|
|
TEST_CASE(CStringMap) {
|
|
const char* const kConst1 = "test";
|
|
const char* const kConst2 = "test 2";
|
|
|
|
char* const str1 = OS::SCreate(nullptr, "%s", kConst1);
|
|
char* const str2 = OS::SCreate(nullptr, "%s", kConst2);
|
|
char* const str3 = OS::SCreate(nullptr, "%s", kConst1);
|
|
|
|
// Make sure these strings are pointer-distinct, but C-string-equal.
|
|
EXPECT_NE(str1, str3);
|
|
EXPECT_STREQ(str1, str3);
|
|
|
|
const intptr_t i1 = 1;
|
|
const intptr_t i2 = 2;
|
|
|
|
CStringMap<intptr_t> map;
|
|
EXPECT(map.IsEmpty());
|
|
|
|
map.Insert({str1, i1});
|
|
EXPECT_NOTNULL(map.Lookup(str1));
|
|
EXPECT_EQ(i1, map.LookupValue(str1));
|
|
EXPECT_NULLPTR(map.Lookup(str2));
|
|
EXPECT_NOTNULL(map.Lookup(str3));
|
|
EXPECT_EQ(i1, map.LookupValue(str3));
|
|
|
|
map.Insert({str2, i2});
|
|
EXPECT_NOTNULL(map.Lookup(str1));
|
|
EXPECT_EQ(i1, map.LookupValue(str1));
|
|
EXPECT_NOTNULL(map.Lookup(str2));
|
|
EXPECT_EQ(i2, map.LookupValue(str2));
|
|
EXPECT_NOTNULL(map.Lookup(str3));
|
|
EXPECT_EQ(i1, map.LookupValue(str3));
|
|
|
|
EXPECT(map.Remove(str3));
|
|
EXPECT_NULLPTR(map.Lookup(str1));
|
|
EXPECT_NOTNULL(map.Lookup(str2));
|
|
EXPECT_EQ(i2, map.LookupValue(str2));
|
|
EXPECT_NULLPTR(map.Lookup(str3));
|
|
|
|
EXPECT(!map.Remove(str3));
|
|
EXPECT(map.Remove(str2));
|
|
EXPECT(map.IsEmpty());
|
|
|
|
free(str3);
|
|
free(str2);
|
|
free(str1);
|
|
}
|
|
|
|
TEST_CASE(CStringMapUpdate) {
|
|
const char* const kConst1 = "test";
|
|
const char* const kConst2 = "test 2";
|
|
|
|
char* str1 = OS::SCreate(nullptr, "%s", kConst1);
|
|
char* str2 = OS::SCreate(nullptr, "%s", kConst2);
|
|
char* str3 = OS::SCreate(nullptr, "%s", kConst1);
|
|
char* str4 = OS::SCreate(nullptr, "%s", kConst1); // Only used for lookup.
|
|
|
|
// Make sure these strings are pointer-distinct, but C-string-equal.
|
|
EXPECT_NE(str1, str3);
|
|
EXPECT_NE(str1, str4);
|
|
EXPECT_NE(str3, str4);
|
|
EXPECT_STREQ(str1, str3);
|
|
EXPECT_STREQ(str1, str4);
|
|
|
|
CStringKeyValueTrait<intptr_t>::Pair p1 = {str1, 1};
|
|
CStringKeyValueTrait<intptr_t>::Pair p2 = {str2, 2};
|
|
CStringKeyValueTrait<intptr_t>::Pair p3 = {str3, 3};
|
|
|
|
CStringMap<intptr_t> map;
|
|
EXPECT(map.IsEmpty());
|
|
|
|
map.Update(p1);
|
|
EXPECT_NOTNULL(map.Lookup(str1));
|
|
EXPECT_EQ(p1.value, map.LookupValue(str1));
|
|
EXPECT_NULLPTR(map.Lookup(str2));
|
|
EXPECT_NOTNULL(map.Lookup(str3));
|
|
EXPECT_EQ(p1.value, map.LookupValue(str3));
|
|
EXPECT_NOTNULL(map.Lookup(str4));
|
|
EXPECT_EQ(p1.value, map.LookupValue(str4));
|
|
|
|
map.Update(p2);
|
|
EXPECT_NOTNULL(map.Lookup(str1));
|
|
EXPECT_EQ(p1.value, map.LookupValue(str1));
|
|
EXPECT_NOTNULL(map.Lookup(str2));
|
|
EXPECT_EQ(p2.value, map.LookupValue(str2));
|
|
EXPECT_NOTNULL(map.Lookup(str3));
|
|
EXPECT_EQ(p1.value, map.LookupValue(str3));
|
|
EXPECT_NOTNULL(map.Lookup(str4));
|
|
EXPECT_EQ(p1.value, map.LookupValue(str4));
|
|
|
|
// Check Lookup after Update.
|
|
map.Update(p3);
|
|
EXPECT_NOTNULL(map.Lookup(str1));
|
|
EXPECT_EQ(p3.value, map.LookupValue(str1));
|
|
EXPECT_NOTNULL(map.Lookup(str2));
|
|
EXPECT_EQ(p2.value, map.LookupValue(str2));
|
|
EXPECT_NOTNULL(map.Lookup(str3));
|
|
EXPECT_EQ(p3.value, map.LookupValue(str3));
|
|
EXPECT_NOTNULL(map.Lookup(str4));
|
|
EXPECT_EQ(p3.value, map.LookupValue(str4));
|
|
|
|
// Check that single Remove after only Updates ensures Lookup fails after.
|
|
EXPECT(map.Remove(str3));
|
|
EXPECT_NULLPTR(map.Lookup(str1));
|
|
EXPECT_NOTNULL(map.Lookup(str2));
|
|
EXPECT_EQ(p2.value, map.LookupValue(str2));
|
|
EXPECT_NULLPTR(map.Lookup(str3));
|
|
EXPECT_NULLPTR(map.Lookup(str4));
|
|
|
|
EXPECT(!map.Remove(str3));
|
|
EXPECT(map.Remove(str2));
|
|
EXPECT(map.IsEmpty());
|
|
|
|
// Quick double-check that these weren't side-effected by the implementation
|
|
// of hash maps (p1 especially).
|
|
EXPECT_EQ(str1, p1.key);
|
|
EXPECT_EQ(1, p1.value);
|
|
EXPECT_EQ(str2, p2.key);
|
|
EXPECT_EQ(2, p2.value);
|
|
EXPECT_EQ(str3, p3.key);
|
|
EXPECT_EQ(3, p3.value);
|
|
|
|
free(str4);
|
|
free(str3);
|
|
free(str2);
|
|
free(str1);
|
|
}
|
|
|
|
} // namespace dart
|