Aske Simon Christensen
cec963f028
I collected statistics for the sizes and capacities of growable arrays which are promoted to old-space or survive an old-space gc when running dart2js and Fasta. For these applications, the vast majority of arrays stay empty. More than half of the total object size of promoted backing arrays is backing for empty growable arrays. Furthermore, since the overhead for an array is 3 words (header, type parameters and length), and object sizes are rounded up to an even number of words, we waste one word for all even-sized arrays. This CL changes the growth strategy so that empty growable arrays are created with a shared, zero-sized array as backing, avoiding the allocation of a backing array if no elements are added. When the array needs to grow, it starts out at 3 and grows to double size plus one each time: 7, 15, 31, ... A few places in the VM code need to handle these shared, zero-sized arrays specially. In particular, the Array::MakeArray function needs to allocate a new, empty array if its result is to be returned to Dart code. Benchmarks suggest that the change improves memory usage by a few percent overall and does not significantly affect run time. BUG= R=erikcorry@google.com Review-Url: https://codereview.chromium.org/2949803002 .
81 lines
2.5 KiB
Dart
81 lines
2.5 KiB
Dart
// 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.
|
|
|
|
// The _GrowableArrayMarker class is used to signal to the List() factory
|
|
// whether a parameter was passed.
|
|
class _GrowableArrayMarker implements int {
|
|
const _GrowableArrayMarker();
|
|
}
|
|
|
|
const _GROWABLE_ARRAY_MARKER = const _GrowableArrayMarker();
|
|
|
|
@patch
|
|
class List<E> {
|
|
@patch
|
|
factory List([int length]) = List<E>._internal;
|
|
|
|
@patch
|
|
factory List.filled(int length, E fill, {bool growable: false}) {
|
|
// All error handling on the length parameter is done at the implementation
|
|
// of new _List.
|
|
var result = growable ? new _GrowableList<E>(length) : new _List<E>(length);
|
|
if (fill != null) {
|
|
for (int i = 0; i < length; i++) {
|
|
result[i] = fill;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@patch
|
|
factory List.from(Iterable elements, {bool growable: true}) {
|
|
if (elements is EfficientLengthIterable) {
|
|
int length = elements.length;
|
|
var list = growable ? new _GrowableList<E>(length) : new _List<E>(length);
|
|
if (length > 0) {
|
|
// Avoid creating iterator unless necessary.
|
|
int i = 0;
|
|
for (var element in elements) {
|
|
list[i++] = element;
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
List<E> list = new _GrowableList<E>(0);
|
|
for (E e in elements) {
|
|
list.add(e);
|
|
}
|
|
if (growable) return list;
|
|
return makeListFixedLength(list);
|
|
}
|
|
|
|
@patch
|
|
factory List.unmodifiable(Iterable elements) {
|
|
List result = new List<E>.from(elements, growable: false);
|
|
return makeFixedListUnmodifiable(result);
|
|
}
|
|
|
|
// The List factory constructor redirects to this one so that we can change
|
|
// length's default value from the one in the SDK's implementation.
|
|
factory List._internal([int length = _GROWABLE_ARRAY_MARKER]) {
|
|
if (identical(length, _GROWABLE_ARRAY_MARKER)) {
|
|
return new _GrowableList<E>(0);
|
|
}
|
|
// All error handling on the length parameter is done at the implementation
|
|
// of new _List.
|
|
return new _List<E>(length);
|
|
}
|
|
|
|
// Factory constructing a mutable List from a parser generated List literal.
|
|
// [elements] contains elements that are already type checked.
|
|
factory List._fromLiteral(List elements) {
|
|
if (elements.isEmpty) {
|
|
return new _GrowableList<E>(0);
|
|
}
|
|
var result = new _GrowableList<E>.withData(elements);
|
|
result._setLength(elements.length);
|
|
return result;
|
|
}
|
|
}
|