Commit f860d02f authored by darin's avatar darin
Browse files

JavaScriptCore:

        Reviewed by Maciej.

        - http://bugs.webkit.org/show_bug.cgi?id=15606
          make cut-off for sparse vs. dense arrays smarter for speed with large arrays

        Makes the morph test in SunSpider 26% faster, and the overall
        benchmark 3% faster.

        This also fixes some small problems we had with the distinction
        between nonexistent and undefined values in arrays.

        * kjs/array_instance.h: Tweaked formatting and naming.
        * kjs/array_instance.cpp: Copied from kjs/array_object.cpp.
        (KJS::storageSize): Added. Computes the size of the storage given a vector length.
        (KJS::increasedVectorLength): Added. Implements the rule for resizing the vector.
        (KJS::isDenseEnoughForVector): Added.
        (KJS::ArrayInstance::ArrayInstance): Initialize the new fields.
        (KJS::ArrayInstance::~ArrayInstance): Since m_storage is now never 0, delete it.
        (KJS::ArrayInstance::getItem): Updated for name changes.
        (KJS::ArrayInstance::lengthGetter): Ditto.
        (KJS::ArrayInstance::inlineGetOwnPropertySlot): Added. Allows both versions of
        getOwnPropertySlot to share more code.
        (KJS::ArrayInstance::getOwnPropertySlot): Just refactored, no code change.
        (KJS::ArrayInstance::put): Added logic for extending the vector as long as the
        array is dense enough. Also keep m_numValuesInVector up to date.
        (KJS::ArrayInstance::deleteProperty): Added code to keep m_numValuesInVector
        up to date.
        (KJS::ArrayInstance::getPropertyNames): Fixed bug where this would omit names
        for array indices with undefined values.
        (KJS::ArrayInstance::increaseVectorLength): Renamed from resizeStorage. Also
        simplified to only handle getting larger.
        (KJS::ArrayInstance::setLength): Added code to update m_numValuesInVector, to
        zero out the unused part of the vector and to delete the map if it's no longer
        needed.
        (KJS::ArrayInstance::mark): Tweaked formatting.
        (KJS::compareByStringForQSort): Ditto.
        (KJS::ArrayInstance::sort): Ditto.
        (KJS::CompareWithCompareFunctionArguments::CompareWithCompareFunctionArguments):
        Ditto.
        (KJS::compareWithCompareFunctionForQSort): Ditto.
        (KJS::ArrayInstance::compactForSorting): Fixed bug where this would turn
        undefined values into nonexistent values in some cases.

        * kjs/array_object.h: Removed MAX_ARRAY_INDEX.
        * kjs/array_object.cpp: Removed ArrayInstance. Moved to a separate file.

        * JavaScriptCore.pri: Added array_instance.cpp.
        * JavaScriptCore.xcodeproj/project.pbxproj: Ditto.
        * kjs/AllInOneFile.cpp: Ditto.

LayoutTests:

        * fast/js/kde/resources/Array.js: Added tests to cover missing value behavior
        (not the same as undefined values in arrays). This matches the ECMA JavaScript
        specification, but doesn't exactly match Firefox.
        * fast/js/kde/Array-expected.txt: Updated with results.



git-svn-id: http://svn.webkit.org/repository/webkit/trunk@26881 268f45cc-cd09-0410-ab3c-d52691b4dbfc
parent 625dc693
2007-10-22 Darin Adler <darin@apple.com>
Reviewed by Maciej.
- http://bugs.webkit.org/show_bug.cgi?id=15606
make cut-off for sparse vs. dense arrays smarter for speed with large arrays
Makes the morph test in SunSpider 26% faster, and the overall
benchmark 3% faster.
This also fixes some small problems we had with the distinction
between nonexistent and undefined values in arrays.
* kjs/array_instance.h: Tweaked formatting and naming.
* kjs/array_instance.cpp: Copied from kjs/array_object.cpp.
(KJS::storageSize): Added. Computes the size of the storage given a vector length.
(KJS::increasedVectorLength): Added. Implements the rule for resizing the vector.
(KJS::isDenseEnoughForVector): Added.
(KJS::ArrayInstance::ArrayInstance): Initialize the new fields.
(KJS::ArrayInstance::~ArrayInstance): Since m_storage is now never 0, delete it.
(KJS::ArrayInstance::getItem): Updated for name changes.
(KJS::ArrayInstance::lengthGetter): Ditto.
(KJS::ArrayInstance::inlineGetOwnPropertySlot): Added. Allows both versions of
getOwnPropertySlot to share more code.
(KJS::ArrayInstance::getOwnPropertySlot): Just refactored, no code change.
(KJS::ArrayInstance::put): Added logic for extending the vector as long as the
array is dense enough. Also keep m_numValuesInVector up to date.
(KJS::ArrayInstance::deleteProperty): Added code to keep m_numValuesInVector
up to date.
(KJS::ArrayInstance::getPropertyNames): Fixed bug where this would omit names
for array indices with undefined values.
(KJS::ArrayInstance::increaseVectorLength): Renamed from resizeStorage. Also
simplified to only handle getting larger.
(KJS::ArrayInstance::setLength): Added code to update m_numValuesInVector, to
zero out the unused part of the vector and to delete the map if it's no longer
needed.
(KJS::ArrayInstance::mark): Tweaked formatting.
(KJS::compareByStringForQSort): Ditto.
(KJS::ArrayInstance::sort): Ditto.
(KJS::CompareWithCompareFunctionArguments::CompareWithCompareFunctionArguments):
Ditto.
(KJS::compareWithCompareFunctionForQSort): Ditto.
(KJS::ArrayInstance::compactForSorting): Fixed bug where this would turn
undefined values into nonexistent values in some cases.
* kjs/array_object.h: Removed MAX_ARRAY_INDEX.
* kjs/array_object.cpp: Removed ArrayInstance. Moved to a separate file.
* JavaScriptCore.pri: Added array_instance.cpp.
* JavaScriptCore.xcodeproj/project.pbxproj: Ditto.
* kjs/AllInOneFile.cpp: Ditto.
2007-10-22 Andrew Wellington <proton@wiretapped.net>
Reviewed by Mark Rowe.
......
......@@ -56,6 +56,7 @@ SOURCES += \
kjs/DateMath.cpp \
kjs/JSWrapperObject.cpp \
kjs/PropertyNameArray.cpp \
kjs/array_instance.cpp \
kjs/array_object.cpp \
kjs/bool_object.cpp \
kjs/collector.cpp \
......
......@@ -174,6 +174,10 @@
<Filter
Name="KJS"
>
<File
RelativePath="..\..\kjs\array_instance.cpp"
>
</File>
<File
RelativePath="..\..\kjs\array_instance.h"
>
......
......@@ -574,6 +574,7 @@
938C4F690CA06BC700D9310A /* ASCIICType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ASCIICType.h; sourceTree = "<group>"; };
938C4F6B0CA06BCE00D9310A /* DisallowCType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DisallowCType.h; sourceTree = "<group>"; };
93AA4F770957251F0084B3A7 /* AlwaysInline.h */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = AlwaysInline.h; sourceTree = "<group>"; tabWidth = 8; };
93ADFCE60CCBD7AC00D30B08 /* array_instance.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = array_instance.cpp; sourceTree = "<group>"; };
93B6A0DE0AA64DA40076DE27 /* GetPtr.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = GetPtr.h; sourceTree = "<group>"; };
93E26BC908B1511900F85226 /* pcre_ord2utf8.c */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.c.c; name = pcre_ord2utf8.c; path = pcre/pcre_ord2utf8.c; sourceTree = "<group>"; tabWidth = 8; };
93E26BD308B1514100F85226 /* pcre_xclass.c */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.c.c; name = pcre_xclass.c; path = pcre/pcre_xclass.c; sourceTree = "<group>"; tabWidth = 8; };
......@@ -951,6 +952,7 @@
65400C0F0A69BAF200509887 /* PropertyNameArray.cpp */,
65400C100A69BAF200509887 /* PropertyNameArray.h */,
938772E5038BFE19008635CE /* array_instance.h */,
93ADFCE60CCBD7AC00D30B08 /* array_instance.cpp */,
659126BC0BDD1728001921FB /* AllInOneFile.cpp */,
F692A84D0255597D01FF60F7 /* array_object.cpp */,
F692A84E0255597D01FF60F7 /* array_object.h */,
......
......@@ -28,6 +28,7 @@
#include "function.cpp"
#include "debugger.cpp"
#include "array_instance.cpp"
#include "array_object.cpp"
#include "bool_object.cpp"
#include "collector.cpp"
......
/*
* Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
* Copyright (C) 2003, 2007 Apple Inc. All rights reserved.
* Copyright (C) 2003 Peter Kelly (pmk@post.com)
* Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
#include "config.h"
#include "array_instance.h"
#include "PropertyNameArray.h"
#include <wtf/Assertions.h>
namespace KJS {
typedef HashMap<unsigned, JSValue*> SparseArrayValueMap;
struct ArrayStorage {
unsigned m_numValuesInVector;
SparseArrayValueMap* m_sparseValueMap;
JSValue* m_vector[1];
};
// 0xFFFFFFFF is a bit weird -- is not an array index even though it's an integer
static const unsigned maxArrayIndex = 0xFFFFFFFEU;
// Our policy for when to use a vector and when to use a sparse map.
// For all array indices under sparseArrayCutoff, we always use a vector.
// When indices greater than sparseArrayCutoff are involved, we use a vector
// as long as it is 1/8 full. If more sparse than that, we use a map.
static const unsigned sparseArrayCutoff = 10000;
static const unsigned minDensityMultiplier = 8;
static const unsigned mergeSortCutoff = 10000;
const ClassInfo ArrayInstance::info = {"Array", 0, 0, 0};
static inline size_t storageSize(unsigned vectorLength)
{
return sizeof(ArrayStorage) - sizeof(JSValue*) + vectorLength * sizeof(JSValue*);
}
static inline unsigned increasedVectorLength(unsigned newLength)
{
return (newLength * 3 + 1) / 2;
}
static inline bool isDenseEnoughForVector(unsigned length, unsigned numValues)
{
return length / minDensityMultiplier <= numValues;
}
ArrayInstance::ArrayInstance(JSObject* prototype, unsigned initialLength)
: JSObject(prototype)
{
unsigned initialCapacity = min(initialLength, sparseArrayCutoff);
m_length = initialLength;
m_vectorLength = initialCapacity;
m_storage = static_cast<ArrayStorage*>(fastCalloc(storageSize(initialCapacity), 1));
Collector::reportExtraMemoryCost(initialCapacity * sizeof(JSValue*));
}
ArrayInstance::ArrayInstance(JSObject* prototype, const List& list)
: JSObject(prototype)
{
unsigned length = list.size();
m_length = length;
m_vectorLength = length;
ArrayStorage* storage = static_cast<ArrayStorage*>(fastMalloc(storageSize(length)));
storage->m_numValuesInVector = length;
storage->m_sparseValueMap = 0;
ListIterator it = list.begin();
for (unsigned i = 0; i < length; ++i)
storage->m_vector[i] = it++;
m_storage = storage;
// When the array is created non-empty, its cells are filled, so it's really no worse than
// a property map. Therefore don't report extra memory cost.
}
ArrayInstance::~ArrayInstance()
{
delete m_storage->m_sparseValueMap;
fastFree(m_storage);
}
JSValue* ArrayInstance::getItem(unsigned i) const
{
ASSERT(i <= maxArrayIndex);
ArrayStorage* storage = m_storage;
if (i < m_vectorLength) {
JSValue* value = storage->m_vector[i];
return value ? value : jsUndefined();
}
SparseArrayValueMap* map = storage->m_sparseValueMap;
if (!map)
return jsUndefined();
JSValue* value = map->get(i);
return value ? value : jsUndefined();
}
JSValue* ArrayInstance::lengthGetter(ExecState*, JSObject*, const Identifier&, const PropertySlot& slot)
{
return jsNumber(static_cast<ArrayInstance*>(slot.slotBase())->m_length);
}
ALWAYS_INLINE bool ArrayInstance::inlineGetOwnPropertySlot(ExecState* exec, unsigned i, PropertySlot& slot)
{
ArrayStorage* storage = m_storage;
if (i >= m_length) {
if (i > maxArrayIndex)
return getOwnPropertySlot(exec, Identifier::from(i), slot);
return false;
}
if (i < m_vectorLength) {
JSValue*& valueSlot = storage->m_vector[i];
if (valueSlot) {
slot.setValueSlot(this, &valueSlot);
return true;
}
} else if (SparseArrayValueMap* map = storage->m_sparseValueMap) {
SparseArrayValueMap::iterator it = map->find(i);
if (it != map->end()) {
slot.setValueSlot(this, &it->second);
return true;
}
}
return false;
}
bool ArrayInstance::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
{
if (propertyName == exec->propertyNames().length) {
slot.setCustom(this, lengthGetter);
return true;
}
bool isArrayIndex;
unsigned i = propertyName.toArrayIndex(&isArrayIndex);
if (isArrayIndex)
return inlineGetOwnPropertySlot(exec, i, slot);
return JSObject::getOwnPropertySlot(exec, propertyName, slot);
}
bool ArrayInstance::getOwnPropertySlot(ExecState* exec, unsigned i, PropertySlot& slot)
{
return inlineGetOwnPropertySlot(exec, i, slot);
}
// ECMA 15.4.5.1
void ArrayInstance::put(ExecState* exec, const Identifier& propertyName, JSValue* value, int attributes)
{
bool isArrayIndex;
unsigned i = propertyName.toArrayIndex(&isArrayIndex);
if (isArrayIndex) {
put(exec, i, value, attributes);
return;
}
if (propertyName == exec->propertyNames().length) {
unsigned newLength = value->toUInt32(exec);
if (value->toNumber(exec) != static_cast<double>(newLength)) {
throwError(exec, RangeError, "Invalid array length.");
return;
}
setLength(newLength);
return;
}
JSObject::put(exec, propertyName, value, attributes);
}
void ArrayInstance::put(ExecState* exec, unsigned i, JSValue* value, int attributes)
{
if (i > maxArrayIndex) {
put(exec, Identifier::from(i), value, attributes);
return;
}
ArrayStorage* storage = m_storage;
unsigned length = m_length;
if (i >= length) {
length = i + 1;
m_length = length;
}
if (i < m_vectorLength) {
JSValue*& valueSlot = storage->m_vector[i];
storage->m_numValuesInVector += !valueSlot;
valueSlot = value;
return;
}
if (i < sparseArrayCutoff) {
increaseVectorLength(i + 1);
storage = m_storage;
++storage->m_numValuesInVector;
storage->m_vector[i] = value;
return;
}
SparseArrayValueMap* map = storage->m_sparseValueMap;
if (!map || map->isEmpty()) {
if (isDenseEnoughForVector(i + 1, storage->m_numValuesInVector + 1)) {
increaseVectorLength(i + 1);
storage = m_storage;
++storage->m_numValuesInVector;
storage->m_vector[i] = value;
return;
}
if (!map) {
map = new SparseArrayValueMap;
storage->m_sparseValueMap = map;
}
map->add(i, value);
return;
}
unsigned newNumValuesInVector = storage->m_numValuesInVector + 1;
if (!isDenseEnoughForVector(i + 1, newNumValuesInVector)) {
map->add(i, value);
return;
}
unsigned newVectorLength = increasedVectorLength(i + 1);
for (unsigned j = m_vectorLength; j < newVectorLength; ++j)
newNumValuesInVector += map->contains(j);
newNumValuesInVector -= map->contains(i);
if (isDenseEnoughForVector(newVectorLength, newNumValuesInVector)) {
unsigned proposedNewNumValuesInVector = newNumValuesInVector;
while (true) {
unsigned proposedNewVectorLength = increasedVectorLength(newVectorLength + 1);
for (unsigned j = newVectorLength; j < proposedNewVectorLength; ++j)
proposedNewNumValuesInVector += map->contains(j);
if (!isDenseEnoughForVector(proposedNewVectorLength, proposedNewNumValuesInVector))
break;
newVectorLength = proposedNewVectorLength;
newNumValuesInVector = proposedNewNumValuesInVector;
}
}
storage = static_cast<ArrayStorage*>(fastRealloc(storage, storageSize(newVectorLength)));
unsigned vectorLength = m_vectorLength;
if (newNumValuesInVector == storage->m_numValuesInVector + 1) {
for (unsigned j = vectorLength; j < newVectorLength; ++j)
storage->m_vector[j] = 0;
map->remove(i);
} else {
for (unsigned j = vectorLength; j < newVectorLength; ++j) {
SparseArrayValueMap::iterator it = map->find(j);
if (it == map->end())
storage->m_vector[j] = 0;
else {
storage->m_vector[j] = it->second;
map->remove(it);
}
}
}
storage->m_vector[i] = value;
m_vectorLength = newVectorLength;
storage->m_numValuesInVector = newNumValuesInVector;
}
bool ArrayInstance::deleteProperty(ExecState* exec, const Identifier& propertyName)
{
bool isArrayIndex;
unsigned i = propertyName.toArrayIndex(&isArrayIndex);
if (isArrayIndex)
return deleteProperty(exec, i);
if (propertyName == exec->propertyNames().length)
return false;
return JSObject::deleteProperty(exec, propertyName);
}
bool ArrayInstance::deleteProperty(ExecState* exec, unsigned i)
{
ArrayStorage* storage = m_storage;
if (i < m_vectorLength) {
JSValue*& valueSlot = storage->m_vector[i];
bool hadValue = valueSlot;
valueSlot = 0;
storage->m_numValuesInVector -= hadValue;
return hadValue;
}
if (SparseArrayValueMap* map = storage->m_sparseValueMap) {
SparseArrayValueMap::iterator it = map->find(i);
if (it != map->end()) {
map->remove(it);
return true;
}
}
if (i > maxArrayIndex)
return deleteProperty(exec, Identifier::from(i));
return false;
}
void ArrayInstance::getPropertyNames(ExecState* exec, PropertyNameArray& propertyNames)
{
// FIXME: Filling PropertyNameArray with an identifier for every integer
// is incredibly inefficient for large arrays. We need a different approach.
ArrayStorage* storage = m_storage;
unsigned usedVectorLength = min(m_length, m_vectorLength);
for (unsigned i = 0; i < usedVectorLength; ++i) {
if (storage->m_vector[i])
propertyNames.add(Identifier::from(i));
}
if (SparseArrayValueMap* map = storage->m_sparseValueMap) {
SparseArrayValueMap::iterator end = map->end();
for (SparseArrayValueMap::iterator it = map->begin(); it != end; ++it)
propertyNames.add(Identifier::from(it->first));
}
JSObject::getPropertyNames(exec, propertyNames);
}
void ArrayInstance::increaseVectorLength(unsigned newLength)
{
ArrayStorage* storage = m_storage;
unsigned vectorLength = m_vectorLength;
ASSERT(newLength > vectorLength);
unsigned newVectorLength = increasedVectorLength(newLength);
storage = static_cast<ArrayStorage*>(fastRealloc(storage, storageSize(newVectorLength)));
m_vectorLength = newVectorLength;
for (unsigned i = vectorLength; i < newVectorLength; ++i)
storage->m_vector[i] = 0;
m_storage = storage;
}
void ArrayInstance::setLength(unsigned newLength)
{
ArrayStorage* storage = m_storage;
unsigned length = m_length;
if (newLength < length) {
unsigned usedVectorLength = min(length, m_vectorLength);
for (unsigned i = newLength; i < usedVectorLength; ++i) {
JSValue*& valueSlot = storage->m_vector[i];
bool hadValue = valueSlot;
valueSlot = 0;
storage->m_numValuesInVector -= hadValue;
}
if (SparseArrayValueMap* map = storage->m_sparseValueMap) {
SparseArrayValueMap copy = *map;
SparseArrayValueMap::iterator end = copy.end();
for (SparseArrayValueMap::iterator it = copy.begin(); it != end; ++it) {
if (it->first >= newLength)
map->remove(it->first);
}
if (map->isEmpty()) {
delete map;
storage->m_sparseValueMap = 0;
}
}
}
m_length = newLength;
}
void ArrayInstance::mark()
{
JSObject::mark();
ArrayStorage* storage = m_storage;
unsigned usedVectorLength = min(m_length, m_vectorLength);
for (unsigned i = 0; i < usedVectorLength; ++i) {
JSValue* value = storage->m_vector[i];
if (value && !value->marked())
value->mark();
}
if (SparseArrayValueMap* map = storage->m_sparseValueMap) {
SparseArrayValueMap copy = *map;
SparseArrayValueMap::iterator end = copy.end();
for (SparseArrayValueMap::iterator it = copy.begin(); it != end; ++it) {
JSValue* value = it->second;
if (!value->marked())
value->mark();
}
}
}
static ExecState* execForCompareByStringForQSort = 0;
static int compareByStringForQSort(const void* a, const void* b)
{
ExecState* exec = execForCompareByStringForQSort;
JSValue* va = *static_cast<JSValue* const*>(a);
JSValue* vb = *static_cast<JSValue* const*>(b);
ASSERT(!va->isUndefined());
ASSERT(!vb->isUndefined());
return compare(va->toString(exec), vb->toString(exec));
}
void ArrayInstance::sort(ExecState* exec)
{
unsigned lengthNotIncludingUndefined = compactForSorting();
ExecState* oldExec = execForCompareByStringForQSort;
execForCompareByStringForQSort = exec;
#if HAVE(MERGESORT)
// Because mergesort usually does fewer compares, it is faster than qsort here.
// However, because it requires extra copies of the storage buffer, don't use it for very
// large arrays.
// FIXME: Since we sort by string value, a fast algorithm might be to convert all the
// values to string once up front, and then use a radix sort. That would be O(N) rather
// than O(N log N).
if (lengthNotIncludingUndefined < mergeSortCutoff) {
// During the sort, we could do a garbage collect, and it's important to still
// have references to every object in the array for ArrayInstance::mark.
// The mergesort algorithm does not guarantee this, so we sort a copy rather
// than the original.
size_t size = storageSize(m_vectorLength);
ArrayStorage* copy = static_cast<ArrayStorage*>(fastMalloc(size));
memcpy(copy, m_storage, size);
mergesort(copy->m_vector, lengthNotIncludingUndefined, sizeof(JSValue*), compareByStringForQSort);
fastFree(m_storage);
m_storage = copy;
execForCompareByStringForQSort = oldExec;
return;
}
#endif
qsort(m_storage->m_vector, lengthNotIncludingUndefined, sizeof(JSValue*), compareByStringForQSort);
execForCompareByStringForQSort = oldExec;
}
struct CompareWithCompareFunctionArguments {
CompareWithCompareFunctionArguments(ExecState *e, JSObject *cf)
: exec(e)
, compareFunction(cf)
, globalObject(e->dynamicInterpreter()->globalObject())
{
}
ExecState *exec;
JSObject *compareFunction;
List arguments;
JSObject *globalObject;
};
static CompareWithCompareFunctionArguments* compareWithCompareFunctionArguments = 0;