AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity
6d2a51965a
v8/test/cctest/test-ordered-hash-table.cc

245 lines
9.9 KiB
C++
Raw Normal View History

OrderedHashTable implementation with Set and Map interfaces OrderedHashTable is an insertion-ordered HashTable based on Jason Orendorff's writeup of a data structure attributed to Tyler Close: https://wiki.mozilla.org/User:Jorend/Deterministic_hash_tables It is intended as the new backing store for JSSet/JSMap, as ES6 requires insertion-order-based iteration. Note, however, that in the interest of keeping the initial check-in small this patch does not yet include any iteration support. This change also doesn't yet touch any existing behavior, but in a branch I've verified that these structures pass the existing JSSet/JSMap mjsunit tests. BUG=v8:1793 LOG=N R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/220293002 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20522 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-04 20:41:57 +00:00
// Copyright 2014 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <stdlib.h>
#include "v8.h"
#include "cctest.h"
#include "factory.h"
namespace {
using namespace v8::internal;
ES6: Add support for Map/Set forEach This implements MapIterator and SetIterator which matches the same constructs in the ES6 spec. However, these 2 iterators are not exposed to user code yet. They are only used internally to implement Map.prototype.forEach and Set.prototype.forEach. Each iterator has a reference to the OrderedHashTable where it directly accesses the hash table's entries. The OrderedHashTable has a reference to the newest iterator and each iterator has a reference to the next and previous iterator, effectively creating a double linked list. When the OrderedHashTable is mutated (or replaced) all the iterators are updated. When the iterator iterates passed the end of the data table it closes itself. Closed iterators no longer have a reference to the OrderedHashTable and they are removed from the double linked list. In the case of Map/Set forEach, we manually call Close on the iterator in case an exception was thrown so that the iterator never reached the end. At this point the OrderedHashTable keeps all the non finished iterators alive but since the only thing we currently expose is forEach there are no unfinished iterators outside a forEach call. Once we expose the iterators to user code we will need to make the references from the OrderedHashTable to the iterators weak and have some mechanism to close an iterator when it is garbage collected. BUG=1793, 2323 LOG=Y R=adamk@chromium.org TBR=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/238063009 Patch from Erik Arvidsson <arv@chromium.org>. git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20857 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-17 17:45:32 +00:00
void CheckIterResultObject(Isolate* isolate,
Handle<JSObject> result,
Handle<Object> value,
bool done) {
Fix breakage on V8 Linux - nosse2 This was introduced by https://code.google.com/p/v8/source/detail?r=20857 R=adamk@chromium.org TBR=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/241433002 Patch from Erik Arvidsson <arv@chromium.org>. git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20858 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-17 19:39:48 +00:00
Handle<Object> value_object =
Object::GetProperty(isolate, result, "value").ToHandleChecked();
Handle<Object> done_object =
Object::GetProperty(isolate, result, "done").ToHandleChecked();
CHECK_EQ(*value_object, *value);
CHECK(done_object->IsBoolean());
CHECK_EQ(done_object->BooleanValue(), done);
ES6: Add support for Map/Set forEach This implements MapIterator and SetIterator which matches the same constructs in the ES6 spec. However, these 2 iterators are not exposed to user code yet. They are only used internally to implement Map.prototype.forEach and Set.prototype.forEach. Each iterator has a reference to the OrderedHashTable where it directly accesses the hash table's entries. The OrderedHashTable has a reference to the newest iterator and each iterator has a reference to the next and previous iterator, effectively creating a double linked list. When the OrderedHashTable is mutated (or replaced) all the iterators are updated. When the iterator iterates passed the end of the data table it closes itself. Closed iterators no longer have a reference to the OrderedHashTable and they are removed from the double linked list. In the case of Map/Set forEach, we manually call Close on the iterator in case an exception was thrown so that the iterator never reached the end. At this point the OrderedHashTable keeps all the non finished iterators alive but since the only thing we currently expose is forEach there are no unfinished iterators outside a forEach call. Once we expose the iterators to user code we will need to make the references from the OrderedHashTable to the iterators weak and have some mechanism to close an iterator when it is garbage collected. BUG=1793, 2323 LOG=Y R=adamk@chromium.org TBR=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/238063009 Patch from Erik Arvidsson <arv@chromium.org>. git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20857 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-17 17:45:32 +00:00
}
OrderedHashTable implementation with Set and Map interfaces OrderedHashTable is an insertion-ordered HashTable based on Jason Orendorff's writeup of a data structure attributed to Tyler Close: https://wiki.mozilla.org/User:Jorend/Deterministic_hash_tables It is intended as the new backing store for JSSet/JSMap, as ES6 requires insertion-order-based iteration. Note, however, that in the interest of keeping the initial check-in small this patch does not yet include any iteration support. This change also doesn't yet touch any existing behavior, but in a branch I've verified that these structures pass the existing JSSet/JSMap mjsunit tests. BUG=v8:1793 LOG=N R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/220293002 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20522 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-04 20:41:57 +00:00
TEST(Set) {
ES6: Add support for Map/Set forEach This implements MapIterator and SetIterator which matches the same constructs in the ES6 spec. However, these 2 iterators are not exposed to user code yet. They are only used internally to implement Map.prototype.forEach and Set.prototype.forEach. Each iterator has a reference to the OrderedHashTable where it directly accesses the hash table's entries. The OrderedHashTable has a reference to the newest iterator and each iterator has a reference to the next and previous iterator, effectively creating a double linked list. When the OrderedHashTable is mutated (or replaced) all the iterators are updated. When the iterator iterates passed the end of the data table it closes itself. Closed iterators no longer have a reference to the OrderedHashTable and they are removed from the double linked list. In the case of Map/Set forEach, we manually call Close on the iterator in case an exception was thrown so that the iterator never reached the end. At this point the OrderedHashTable keeps all the non finished iterators alive but since the only thing we currently expose is forEach there are no unfinished iterators outside a forEach call. Once we expose the iterators to user code we will need to make the references from the OrderedHashTable to the iterators weak and have some mechanism to close an iterator when it is garbage collected. BUG=1793, 2323 LOG=Y R=adamk@chromium.org TBR=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/238063009 Patch from Erik Arvidsson <arv@chromium.org>. git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20857 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-17 17:45:32 +00:00
i::FLAG_harmony_collections = true;
OrderedHashTable implementation with Set and Map interfaces OrderedHashTable is an insertion-ordered HashTable based on Jason Orendorff's writeup of a data structure attributed to Tyler Close: https://wiki.mozilla.org/User:Jorend/Deterministic_hash_tables It is intended as the new backing store for JSSet/JSMap, as ES6 requires insertion-order-based iteration. Note, however, that in the interest of keeping the initial check-in small this patch does not yet include any iteration support. This change also doesn't yet touch any existing behavior, but in a branch I've verified that these structures pass the existing JSSet/JSMap mjsunit tests. BUG=v8:1793 LOG=N R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/220293002 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20522 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-04 20:41:57 +00:00
LocalContext context;
Isolate* isolate = CcTest::i_isolate();
Factory* factory = isolate->factory();
HandleScope scope(isolate);
Handle<OrderedHashSet> ordered_set = factory->NewOrderedHashSet();
CHECK_EQ(2, ordered_set->NumberOfBuckets());
CHECK_EQ(0, ordered_set->NumberOfElements());
CHECK_EQ(0, ordered_set->NumberOfDeletedElements());
ES6: Add support for Map/Set forEach This implements MapIterator and SetIterator which matches the same constructs in the ES6 spec. However, these 2 iterators are not exposed to user code yet. They are only used internally to implement Map.prototype.forEach and Set.prototype.forEach. Each iterator has a reference to the OrderedHashTable where it directly accesses the hash table's entries. The OrderedHashTable has a reference to the newest iterator and each iterator has a reference to the next and previous iterator, effectively creating a double linked list. When the OrderedHashTable is mutated (or replaced) all the iterators are updated. When the iterator iterates passed the end of the data table it closes itself. Closed iterators no longer have a reference to the OrderedHashTable and they are removed from the double linked list. In the case of Map/Set forEach, we manually call Close on the iterator in case an exception was thrown so that the iterator never reached the end. At this point the OrderedHashTable keeps all the non finished iterators alive but since the only thing we currently expose is forEach there are no unfinished iterators outside a forEach call. Once we expose the iterators to user code we will need to make the references from the OrderedHashTable to the iterators weak and have some mechanism to close an iterator when it is garbage collected. BUG=1793, 2323 LOG=Y R=adamk@chromium.org TBR=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/238063009 Patch from Erik Arvidsson <arv@chromium.org>. git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20857 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-17 17:45:32 +00:00
Handle<JSSetIterator> value_iterator =
JSSetIterator::Create(ordered_set, JSSetIterator::kKindValues);
Handle<JSSetIterator> value_iterator_2 =
JSSetIterator::Create(ordered_set, JSSetIterator::kKindValues);
OrderedHashTable implementation with Set and Map interfaces OrderedHashTable is an insertion-ordered HashTable based on Jason Orendorff's writeup of a data structure attributed to Tyler Close: https://wiki.mozilla.org/User:Jorend/Deterministic_hash_tables It is intended as the new backing store for JSSet/JSMap, as ES6 requires insertion-order-based iteration. Note, however, that in the interest of keeping the initial check-in small this patch does not yet include any iteration support. This change also doesn't yet touch any existing behavior, but in a branch I've verified that these structures pass the existing JSSet/JSMap mjsunit tests. BUG=v8:1793 LOG=N R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/220293002 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20522 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-04 20:41:57 +00:00
Handle<Map> map = factory->NewMap(JS_OBJECT_TYPE, JSObject::kHeaderSize);
Handle<JSObject> obj = factory->NewJSObjectFromMap(map);
OrderedHashTable::FindEntry() handlified. R=yangguo@chromium.org Review URL: https://codereview.chromium.org/260313003 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@21057 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-29 14:16:38 +00:00
CHECK(!ordered_set->Contains(obj));
OrderedHashTable implementation with Set and Map interfaces OrderedHashTable is an insertion-ordered HashTable based on Jason Orendorff's writeup of a data structure attributed to Tyler Close: https://wiki.mozilla.org/User:Jorend/Deterministic_hash_tables It is intended as the new backing store for JSSet/JSMap, as ES6 requires insertion-order-based iteration. Note, however, that in the interest of keeping the initial check-in small this patch does not yet include any iteration support. This change also doesn't yet touch any existing behavior, but in a branch I've verified that these structures pass the existing JSSet/JSMap mjsunit tests. BUG=v8:1793 LOG=N R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/220293002 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20522 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-04 20:41:57 +00:00
ordered_set = OrderedHashSet::Add(ordered_set, obj);
CHECK_EQ(1, ordered_set->NumberOfElements());
OrderedHashTable::FindEntry() handlified. R=yangguo@chromium.org Review URL: https://codereview.chromium.org/260313003 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@21057 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-29 14:16:38 +00:00
CHECK(ordered_set->Contains(obj));
OrderedHashTable implementation with Set and Map interfaces OrderedHashTable is an insertion-ordered HashTable based on Jason Orendorff's writeup of a data structure attributed to Tyler Close: https://wiki.mozilla.org/User:Jorend/Deterministic_hash_tables It is intended as the new backing store for JSSet/JSMap, as ES6 requires insertion-order-based iteration. Note, however, that in the interest of keeping the initial check-in small this patch does not yet include any iteration support. This change also doesn't yet touch any existing behavior, but in a branch I've verified that these structures pass the existing JSSet/JSMap mjsunit tests. BUG=v8:1793 LOG=N R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/220293002 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20522 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-04 20:41:57 +00:00
ordered_set = OrderedHashSet::Remove(ordered_set, obj);
CHECK_EQ(0, ordered_set->NumberOfElements());
OrderedHashTable::FindEntry() handlified. R=yangguo@chromium.org Review URL: https://codereview.chromium.org/260313003 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@21057 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-29 14:16:38 +00:00
CHECK(!ordered_set->Contains(obj));
OrderedHashTable implementation with Set and Map interfaces OrderedHashTable is an insertion-ordered HashTable based on Jason Orendorff's writeup of a data structure attributed to Tyler Close: https://wiki.mozilla.org/User:Jorend/Deterministic_hash_tables It is intended as the new backing store for JSSet/JSMap, as ES6 requires insertion-order-based iteration. Note, however, that in the interest of keeping the initial check-in small this patch does not yet include any iteration support. This change also doesn't yet touch any existing behavior, but in a branch I've verified that these structures pass the existing JSSet/JSMap mjsunit tests. BUG=v8:1793 LOG=N R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/220293002 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20522 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-04 20:41:57 +00:00
// Test for collisions/chaining
Handle<JSObject> obj1 = factory->NewJSObjectFromMap(map);
ordered_set = OrderedHashSet::Add(ordered_set, obj1);
Handle<JSObject> obj2 = factory->NewJSObjectFromMap(map);
ordered_set = OrderedHashSet::Add(ordered_set, obj2);
Handle<JSObject> obj3 = factory->NewJSObjectFromMap(map);
ordered_set = OrderedHashSet::Add(ordered_set, obj3);
CHECK_EQ(3, ordered_set->NumberOfElements());
OrderedHashTable::FindEntry() handlified. R=yangguo@chromium.org Review URL: https://codereview.chromium.org/260313003 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@21057 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-29 14:16:38 +00:00
CHECK(ordered_set->Contains(obj1));
CHECK(ordered_set->Contains(obj2));
CHECK(ordered_set->Contains(obj3));
OrderedHashTable implementation with Set and Map interfaces OrderedHashTable is an insertion-ordered HashTable based on Jason Orendorff's writeup of a data structure attributed to Tyler Close: https://wiki.mozilla.org/User:Jorend/Deterministic_hash_tables It is intended as the new backing store for JSSet/JSMap, as ES6 requires insertion-order-based iteration. Note, however, that in the interest of keeping the initial check-in small this patch does not yet include any iteration support. This change also doesn't yet touch any existing behavior, but in a branch I've verified that these structures pass the existing JSSet/JSMap mjsunit tests. BUG=v8:1793 LOG=N R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/220293002 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20522 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-04 20:41:57 +00:00
ES6: Add support for Map/Set forEach This implements MapIterator and SetIterator which matches the same constructs in the ES6 spec. However, these 2 iterators are not exposed to user code yet. They are only used internally to implement Map.prototype.forEach and Set.prototype.forEach. Each iterator has a reference to the OrderedHashTable where it directly accesses the hash table's entries. The OrderedHashTable has a reference to the newest iterator and each iterator has a reference to the next and previous iterator, effectively creating a double linked list. When the OrderedHashTable is mutated (or replaced) all the iterators are updated. When the iterator iterates passed the end of the data table it closes itself. Closed iterators no longer have a reference to the OrderedHashTable and they are removed from the double linked list. In the case of Map/Set forEach, we manually call Close on the iterator in case an exception was thrown so that the iterator never reached the end. At this point the OrderedHashTable keeps all the non finished iterators alive but since the only thing we currently expose is forEach there are no unfinished iterators outside a forEach call. Once we expose the iterators to user code we will need to make the references from the OrderedHashTable to the iterators weak and have some mechanism to close an iterator when it is garbage collected. BUG=1793, 2323 LOG=Y R=adamk@chromium.org TBR=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/238063009 Patch from Erik Arvidsson <arv@chromium.org>. git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20857 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-17 17:45:32 +00:00
// Test iteration
CheckIterResultObject(
isolate, JSSetIterator::Next(value_iterator), obj1, false);
CheckIterResultObject(
isolate, JSSetIterator::Next(value_iterator), obj2, false);
CheckIterResultObject(
isolate, JSSetIterator::Next(value_iterator), obj3, false);
CheckIterResultObject(isolate,
JSSetIterator::Next(value_iterator),
factory->undefined_value(),
true);
OrderedHashTable implementation with Set and Map interfaces OrderedHashTable is an insertion-ordered HashTable based on Jason Orendorff's writeup of a data structure attributed to Tyler Close: https://wiki.mozilla.org/User:Jorend/Deterministic_hash_tables It is intended as the new backing store for JSSet/JSMap, as ES6 requires insertion-order-based iteration. Note, however, that in the interest of keeping the initial check-in small this patch does not yet include any iteration support. This change also doesn't yet touch any existing behavior, but in a branch I've verified that these structures pass the existing JSSet/JSMap mjsunit tests. BUG=v8:1793 LOG=N R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/220293002 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20522 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-04 20:41:57 +00:00
// Test growth
ordered_set = OrderedHashSet::Add(ordered_set, obj);
Handle<JSObject> obj4 = factory->NewJSObjectFromMap(map);
ordered_set = OrderedHashSet::Add(ordered_set, obj4);
OrderedHashTable::FindEntry() handlified. R=yangguo@chromium.org Review URL: https://codereview.chromium.org/260313003 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@21057 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-29 14:16:38 +00:00
CHECK(ordered_set->Contains(obj));
CHECK(ordered_set->Contains(obj1));
CHECK(ordered_set->Contains(obj2));
CHECK(ordered_set->Contains(obj3));
CHECK(ordered_set->Contains(obj4));
OrderedHashTable implementation with Set and Map interfaces OrderedHashTable is an insertion-ordered HashTable based on Jason Orendorff's writeup of a data structure attributed to Tyler Close: https://wiki.mozilla.org/User:Jorend/Deterministic_hash_tables It is intended as the new backing store for JSSet/JSMap, as ES6 requires insertion-order-based iteration. Note, however, that in the interest of keeping the initial check-in small this patch does not yet include any iteration support. This change also doesn't yet touch any existing behavior, but in a branch I've verified that these structures pass the existing JSSet/JSMap mjsunit tests. BUG=v8:1793 LOG=N R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/220293002 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20522 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-04 20:41:57 +00:00
CHECK_EQ(5, ordered_set->NumberOfElements());
CHECK_EQ(0, ordered_set->NumberOfDeletedElements());
CHECK_EQ(4, ordered_set->NumberOfBuckets());
ES6: Add support for Map/Set forEach This implements MapIterator and SetIterator which matches the same constructs in the ES6 spec. However, these 2 iterators are not exposed to user code yet. They are only used internally to implement Map.prototype.forEach and Set.prototype.forEach. Each iterator has a reference to the OrderedHashTable where it directly accesses the hash table's entries. The OrderedHashTable has a reference to the newest iterator and each iterator has a reference to the next and previous iterator, effectively creating a double linked list. When the OrderedHashTable is mutated (or replaced) all the iterators are updated. When the iterator iterates passed the end of the data table it closes itself. Closed iterators no longer have a reference to the OrderedHashTable and they are removed from the double linked list. In the case of Map/Set forEach, we manually call Close on the iterator in case an exception was thrown so that the iterator never reached the end. At this point the OrderedHashTable keeps all the non finished iterators alive but since the only thing we currently expose is forEach there are no unfinished iterators outside a forEach call. Once we expose the iterators to user code we will need to make the references from the OrderedHashTable to the iterators weak and have some mechanism to close an iterator when it is garbage collected. BUG=1793, 2323 LOG=Y R=adamk@chromium.org TBR=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/238063009 Patch from Erik Arvidsson <arv@chromium.org>. git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20857 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-17 17:45:32 +00:00
// Test iteration after growth
CheckIterResultObject(
isolate, JSSetIterator::Next(value_iterator_2), obj1, false);
CheckIterResultObject(
isolate, JSSetIterator::Next(value_iterator_2), obj2, false);
CheckIterResultObject(
isolate, JSSetIterator::Next(value_iterator_2), obj3, false);
CheckIterResultObject(
isolate, JSSetIterator::Next(value_iterator_2), obj, false);
CheckIterResultObject(
isolate, JSSetIterator::Next(value_iterator_2), obj4, false);
CheckIterResultObject(isolate,
JSSetIterator::Next(value_iterator_2),
factory->undefined_value(),
true);
OrderedHashTable implementation with Set and Map interfaces OrderedHashTable is an insertion-ordered HashTable based on Jason Orendorff's writeup of a data structure attributed to Tyler Close: https://wiki.mozilla.org/User:Jorend/Deterministic_hash_tables It is intended as the new backing store for JSSet/JSMap, as ES6 requires insertion-order-based iteration. Note, however, that in the interest of keeping the initial check-in small this patch does not yet include any iteration support. This change also doesn't yet touch any existing behavior, but in a branch I've verified that these structures pass the existing JSSet/JSMap mjsunit tests. BUG=v8:1793 LOG=N R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/220293002 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20522 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-04 20:41:57 +00:00
// Test shrinking
ordered_set = OrderedHashSet::Remove(ordered_set, obj);
ordered_set = OrderedHashSet::Remove(ordered_set, obj1);
ordered_set = OrderedHashSet::Remove(ordered_set, obj2);
ordered_set = OrderedHashSet::Remove(ordered_set, obj3);
CHECK_EQ(1, ordered_set->NumberOfElements());
CHECK_EQ(2, ordered_set->NumberOfBuckets());
}
TEST(Map) {
ES6: Add support for Map/Set forEach This implements MapIterator and SetIterator which matches the same constructs in the ES6 spec. However, these 2 iterators are not exposed to user code yet. They are only used internally to implement Map.prototype.forEach and Set.prototype.forEach. Each iterator has a reference to the OrderedHashTable where it directly accesses the hash table's entries. The OrderedHashTable has a reference to the newest iterator and each iterator has a reference to the next and previous iterator, effectively creating a double linked list. When the OrderedHashTable is mutated (or replaced) all the iterators are updated. When the iterator iterates passed the end of the data table it closes itself. Closed iterators no longer have a reference to the OrderedHashTable and they are removed from the double linked list. In the case of Map/Set forEach, we manually call Close on the iterator in case an exception was thrown so that the iterator never reached the end. At this point the OrderedHashTable keeps all the non finished iterators alive but since the only thing we currently expose is forEach there are no unfinished iterators outside a forEach call. Once we expose the iterators to user code we will need to make the references from the OrderedHashTable to the iterators weak and have some mechanism to close an iterator when it is garbage collected. BUG=1793, 2323 LOG=Y R=adamk@chromium.org TBR=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/238063009 Patch from Erik Arvidsson <arv@chromium.org>. git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20857 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-17 17:45:32 +00:00
i::FLAG_harmony_collections = true;
OrderedHashTable implementation with Set and Map interfaces OrderedHashTable is an insertion-ordered HashTable based on Jason Orendorff's writeup of a data structure attributed to Tyler Close: https://wiki.mozilla.org/User:Jorend/Deterministic_hash_tables It is intended as the new backing store for JSSet/JSMap, as ES6 requires insertion-order-based iteration. Note, however, that in the interest of keeping the initial check-in small this patch does not yet include any iteration support. This change also doesn't yet touch any existing behavior, but in a branch I've verified that these structures pass the existing JSSet/JSMap mjsunit tests. BUG=v8:1793 LOG=N R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/220293002 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20522 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-04 20:41:57 +00:00
LocalContext context;
Isolate* isolate = CcTest::i_isolate();
Factory* factory = isolate->factory();
HandleScope scope(isolate);
Handle<OrderedHashMap> ordered_map = factory->NewOrderedHashMap();
CHECK_EQ(2, ordered_map->NumberOfBuckets());
CHECK_EQ(0, ordered_map->NumberOfElements());
CHECK_EQ(0, ordered_map->NumberOfDeletedElements());
ES6: Add support for Map/Set forEach This implements MapIterator and SetIterator which matches the same constructs in the ES6 spec. However, these 2 iterators are not exposed to user code yet. They are only used internally to implement Map.prototype.forEach and Set.prototype.forEach. Each iterator has a reference to the OrderedHashTable where it directly accesses the hash table's entries. The OrderedHashTable has a reference to the newest iterator and each iterator has a reference to the next and previous iterator, effectively creating a double linked list. When the OrderedHashTable is mutated (or replaced) all the iterators are updated. When the iterator iterates passed the end of the data table it closes itself. Closed iterators no longer have a reference to the OrderedHashTable and they are removed from the double linked list. In the case of Map/Set forEach, we manually call Close on the iterator in case an exception was thrown so that the iterator never reached the end. At this point the OrderedHashTable keeps all the non finished iterators alive but since the only thing we currently expose is forEach there are no unfinished iterators outside a forEach call. Once we expose the iterators to user code we will need to make the references from the OrderedHashTable to the iterators weak and have some mechanism to close an iterator when it is garbage collected. BUG=1793, 2323 LOG=Y R=adamk@chromium.org TBR=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/238063009 Patch from Erik Arvidsson <arv@chromium.org>. git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20857 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-17 17:45:32 +00:00
Handle<JSMapIterator> value_iterator =
JSMapIterator::Create(ordered_map, JSMapIterator::kKindValues);
Handle<JSMapIterator> key_iterator =
JSMapIterator::Create(ordered_map, JSMapIterator::kKindKeys);
OrderedHashTable implementation with Set and Map interfaces OrderedHashTable is an insertion-ordered HashTable based on Jason Orendorff's writeup of a data structure attributed to Tyler Close: https://wiki.mozilla.org/User:Jorend/Deterministic_hash_tables It is intended as the new backing store for JSSet/JSMap, as ES6 requires insertion-order-based iteration. Note, however, that in the interest of keeping the initial check-in small this patch does not yet include any iteration support. This change also doesn't yet touch any existing behavior, but in a branch I've verified that these structures pass the existing JSSet/JSMap mjsunit tests. BUG=v8:1793 LOG=N R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/220293002 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20522 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-04 20:41:57 +00:00
Handle<Map> map = factory->NewMap(JS_OBJECT_TYPE, JSObject::kHeaderSize);
Handle<JSObject> obj = factory->NewJSObjectFromMap(map);
Handle<JSObject> val = factory->NewJSObjectFromMap(map);
OrderedHashMap::Lookup() and ObjectHashTable::Lookup() handlified. R=yangguo@chromium.org Review URL: https://codereview.chromium.org/256743008 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@21055 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-29 14:09:14 +00:00
CHECK(ordered_map->Lookup(obj)->IsTheHole());
OrderedHashTable implementation with Set and Map interfaces OrderedHashTable is an insertion-ordered HashTable based on Jason Orendorff's writeup of a data structure attributed to Tyler Close: https://wiki.mozilla.org/User:Jorend/Deterministic_hash_tables It is intended as the new backing store for JSSet/JSMap, as ES6 requires insertion-order-based iteration. Note, however, that in the interest of keeping the initial check-in small this patch does not yet include any iteration support. This change also doesn't yet touch any existing behavior, but in a branch I've verified that these structures pass the existing JSSet/JSMap mjsunit tests. BUG=v8:1793 LOG=N R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/220293002 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20522 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-04 20:41:57 +00:00
ordered_map = OrderedHashMap::Put(ordered_map, obj, val);
CHECK_EQ(1, ordered_map->NumberOfElements());
OrderedHashMap::Lookup() and ObjectHashTable::Lookup() handlified. R=yangguo@chromium.org Review URL: https://codereview.chromium.org/256743008 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@21055 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-29 14:09:14 +00:00
CHECK(ordered_map->Lookup(obj)->SameValue(*val));
OrderedHashTable implementation with Set and Map interfaces OrderedHashTable is an insertion-ordered HashTable based on Jason Orendorff's writeup of a data structure attributed to Tyler Close: https://wiki.mozilla.org/User:Jorend/Deterministic_hash_tables It is intended as the new backing store for JSSet/JSMap, as ES6 requires insertion-order-based iteration. Note, however, that in the interest of keeping the initial check-in small this patch does not yet include any iteration support. This change also doesn't yet touch any existing behavior, but in a branch I've verified that these structures pass the existing JSSet/JSMap mjsunit tests. BUG=v8:1793 LOG=N R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/220293002 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20522 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-04 20:41:57 +00:00
ordered_map = OrderedHashMap::Put(
ordered_map, obj, factory->the_hole_value());
CHECK_EQ(0, ordered_map->NumberOfElements());
OrderedHashMap::Lookup() and ObjectHashTable::Lookup() handlified. R=yangguo@chromium.org Review URL: https://codereview.chromium.org/256743008 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@21055 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-29 14:09:14 +00:00
CHECK(ordered_map->Lookup(obj)->IsTheHole());
OrderedHashTable implementation with Set and Map interfaces OrderedHashTable is an insertion-ordered HashTable based on Jason Orendorff's writeup of a data structure attributed to Tyler Close: https://wiki.mozilla.org/User:Jorend/Deterministic_hash_tables It is intended as the new backing store for JSSet/JSMap, as ES6 requires insertion-order-based iteration. Note, however, that in the interest of keeping the initial check-in small this patch does not yet include any iteration support. This change also doesn't yet touch any existing behavior, but in a branch I've verified that these structures pass the existing JSSet/JSMap mjsunit tests. BUG=v8:1793 LOG=N R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/220293002 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20522 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-04 20:41:57 +00:00
// Test for collisions/chaining
Handle<JSObject> obj1 = factory->NewJSObjectFromMap(map);
Handle<JSObject> obj2 = factory->NewJSObjectFromMap(map);
Handle<JSObject> obj3 = factory->NewJSObjectFromMap(map);
Handle<JSObject> val1 = factory->NewJSObjectFromMap(map);
Handle<JSObject> val2 = factory->NewJSObjectFromMap(map);
Handle<JSObject> val3 = factory->NewJSObjectFromMap(map);
ordered_map = OrderedHashMap::Put(ordered_map, obj1, val1);
ordered_map = OrderedHashMap::Put(ordered_map, obj2, val2);
ordered_map = OrderedHashMap::Put(ordered_map, obj3, val3);
CHECK_EQ(3, ordered_map->NumberOfElements());
OrderedHashMap::Lookup() and ObjectHashTable::Lookup() handlified. R=yangguo@chromium.org Review URL: https://codereview.chromium.org/256743008 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@21055 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-29 14:09:14 +00:00
CHECK(ordered_map->Lookup(obj1)->SameValue(*val1));
CHECK(ordered_map->Lookup(obj2)->SameValue(*val2));
CHECK(ordered_map->Lookup(obj3)->SameValue(*val3));
OrderedHashTable implementation with Set and Map interfaces OrderedHashTable is an insertion-ordered HashTable based on Jason Orendorff's writeup of a data structure attributed to Tyler Close: https://wiki.mozilla.org/User:Jorend/Deterministic_hash_tables It is intended as the new backing store for JSSet/JSMap, as ES6 requires insertion-order-based iteration. Note, however, that in the interest of keeping the initial check-in small this patch does not yet include any iteration support. This change also doesn't yet touch any existing behavior, but in a branch I've verified that these structures pass the existing JSSet/JSMap mjsunit tests. BUG=v8:1793 LOG=N R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/220293002 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20522 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-04 20:41:57 +00:00
ES6: Add support for Map/Set forEach This implements MapIterator and SetIterator which matches the same constructs in the ES6 spec. However, these 2 iterators are not exposed to user code yet. They are only used internally to implement Map.prototype.forEach and Set.prototype.forEach. Each iterator has a reference to the OrderedHashTable where it directly accesses the hash table's entries. The OrderedHashTable has a reference to the newest iterator and each iterator has a reference to the next and previous iterator, effectively creating a double linked list. When the OrderedHashTable is mutated (or replaced) all the iterators are updated. When the iterator iterates passed the end of the data table it closes itself. Closed iterators no longer have a reference to the OrderedHashTable and they are removed from the double linked list. In the case of Map/Set forEach, we manually call Close on the iterator in case an exception was thrown so that the iterator never reached the end. At this point the OrderedHashTable keeps all the non finished iterators alive but since the only thing we currently expose is forEach there are no unfinished iterators outside a forEach call. Once we expose the iterators to user code we will need to make the references from the OrderedHashTable to the iterators weak and have some mechanism to close an iterator when it is garbage collected. BUG=1793, 2323 LOG=Y R=adamk@chromium.org TBR=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/238063009 Patch from Erik Arvidsson <arv@chromium.org>. git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20857 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-17 17:45:32 +00:00
// Test iteration
CheckIterResultObject(
isolate, JSMapIterator::Next(value_iterator), val1, false);
CheckIterResultObject(
isolate, JSMapIterator::Next(value_iterator), val2, false);
CheckIterResultObject(
isolate, JSMapIterator::Next(value_iterator), val3, false);
CheckIterResultObject(isolate,
JSMapIterator::Next(value_iterator),
factory->undefined_value(),
true);
OrderedHashTable implementation with Set and Map interfaces OrderedHashTable is an insertion-ordered HashTable based on Jason Orendorff's writeup of a data structure attributed to Tyler Close: https://wiki.mozilla.org/User:Jorend/Deterministic_hash_tables It is intended as the new backing store for JSSet/JSMap, as ES6 requires insertion-order-based iteration. Note, however, that in the interest of keeping the initial check-in small this patch does not yet include any iteration support. This change also doesn't yet touch any existing behavior, but in a branch I've verified that these structures pass the existing JSSet/JSMap mjsunit tests. BUG=v8:1793 LOG=N R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/220293002 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20522 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-04 20:41:57 +00:00
// Test growth
ordered_map = OrderedHashMap::Put(ordered_map, obj, val);
Handle<JSObject> obj4 = factory->NewJSObjectFromMap(map);
Handle<JSObject> val4 = factory->NewJSObjectFromMap(map);
ordered_map = OrderedHashMap::Put(ordered_map, obj4, val4);
OrderedHashMap::Lookup() and ObjectHashTable::Lookup() handlified. R=yangguo@chromium.org Review URL: https://codereview.chromium.org/256743008 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@21055 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-29 14:09:14 +00:00
CHECK(ordered_map->Lookup(obj)->SameValue(*val));
CHECK(ordered_map->Lookup(obj1)->SameValue(*val1));
CHECK(ordered_map->Lookup(obj2)->SameValue(*val2));
CHECK(ordered_map->Lookup(obj3)->SameValue(*val3));
CHECK(ordered_map->Lookup(obj4)->SameValue(*val4));
OrderedHashTable implementation with Set and Map interfaces OrderedHashTable is an insertion-ordered HashTable based on Jason Orendorff's writeup of a data structure attributed to Tyler Close: https://wiki.mozilla.org/User:Jorend/Deterministic_hash_tables It is intended as the new backing store for JSSet/JSMap, as ES6 requires insertion-order-based iteration. Note, however, that in the interest of keeping the initial check-in small this patch does not yet include any iteration support. This change also doesn't yet touch any existing behavior, but in a branch I've verified that these structures pass the existing JSSet/JSMap mjsunit tests. BUG=v8:1793 LOG=N R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/220293002 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20522 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-04 20:41:57 +00:00
CHECK_EQ(5, ordered_map->NumberOfElements());
CHECK_EQ(4, ordered_map->NumberOfBuckets());
ES6: Add support for Map/Set forEach This implements MapIterator and SetIterator which matches the same constructs in the ES6 spec. However, these 2 iterators are not exposed to user code yet. They are only used internally to implement Map.prototype.forEach and Set.prototype.forEach. Each iterator has a reference to the OrderedHashTable where it directly accesses the hash table's entries. The OrderedHashTable has a reference to the newest iterator and each iterator has a reference to the next and previous iterator, effectively creating a double linked list. When the OrderedHashTable is mutated (or replaced) all the iterators are updated. When the iterator iterates passed the end of the data table it closes itself. Closed iterators no longer have a reference to the OrderedHashTable and they are removed from the double linked list. In the case of Map/Set forEach, we manually call Close on the iterator in case an exception was thrown so that the iterator never reached the end. At this point the OrderedHashTable keeps all the non finished iterators alive but since the only thing we currently expose is forEach there are no unfinished iterators outside a forEach call. Once we expose the iterators to user code we will need to make the references from the OrderedHashTable to the iterators weak and have some mechanism to close an iterator when it is garbage collected. BUG=1793, 2323 LOG=Y R=adamk@chromium.org TBR=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/238063009 Patch from Erik Arvidsson <arv@chromium.org>. git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20857 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-17 17:45:32 +00:00
// Test iteration after growth
CheckIterResultObject(
isolate, JSMapIterator::Next(key_iterator), obj1, false);
CheckIterResultObject(
isolate, JSMapIterator::Next(key_iterator), obj2, false);
CheckIterResultObject(
isolate, JSMapIterator::Next(key_iterator), obj3, false);
CheckIterResultObject(
isolate, JSMapIterator::Next(key_iterator), obj, false);
CheckIterResultObject(
isolate, JSMapIterator::Next(key_iterator), obj4, false);
CheckIterResultObject(isolate,
JSMapIterator::Next(key_iterator),
factory->undefined_value(),
true);
OrderedHashTable implementation with Set and Map interfaces OrderedHashTable is an insertion-ordered HashTable based on Jason Orendorff's writeup of a data structure attributed to Tyler Close: https://wiki.mozilla.org/User:Jorend/Deterministic_hash_tables It is intended as the new backing store for JSSet/JSMap, as ES6 requires insertion-order-based iteration. Note, however, that in the interest of keeping the initial check-in small this patch does not yet include any iteration support. This change also doesn't yet touch any existing behavior, but in a branch I've verified that these structures pass the existing JSSet/JSMap mjsunit tests. BUG=v8:1793 LOG=N R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/220293002 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20522 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-04-04 20:41:57 +00:00
// Test shrinking
ordered_map = OrderedHashMap::Put(
ordered_map, obj, factory->the_hole_value());
ordered_map = OrderedHashMap::Put(
ordered_map, obj1, factory->the_hole_value());
ordered_map = OrderedHashMap::Put(
ordered_map, obj2, factory->the_hole_value());
ordered_map = OrderedHashMap::Put(
ordered_map, obj3, factory->the_hole_value());
CHECK_EQ(1, ordered_map->NumberOfElements());
CHECK_EQ(2, ordered_map->NumberOfBuckets());
}
}
Reference in New Issue Copy Permalink