Jaka jest wydajność obiektów/tablic w JavaScript? (specjalnie dla Google V8)

Na podstawowym poziomie, który pozostaje w sferze JavaScript, właściwości obiektów są znacznie bardziej złożonymi obiektami. Właściwości można tworzyć za pomocą setterów/getterów, różniących się wyliczalnością, pisowalnością i konfigurowalnością. Element w tablicy nie może być dostosowany w ten sposób: albo istnieje, albo nie. na podstawowym poziomie silnika pozwala to na dużo większą optymalizację pod względem organizacji pamięci, która reprezentuje strukturę.

Pod względem identyfikacji tablica z obiektu (słownik), silniki JS zawsze tworzyły wyraźne linie między nimi. Dlatego istnieje wiele artykułów na temat metod tworzenia pół-fałszywego obiektu przypominającego tablicę, który zachowuje się jak jeden, ale pozwala na inne funkcje. Powodem, dla którego ta separacja istnieje, jest to, że same silniki JS przechowują te dwa w różny sposób.

Właściwości mogą być przechowywane na obiekcie array, ale to po prostu pokazuje, jak JavaScript nalega na uczynienie wszystkiego obiektem. Wartości zindeksowane w tablicy są przechowywane inaczej niż jakiekolwiek właściwości, które zdecydujesz się ustawić w obiekcie array, który reprezentuje podstawowe dane tablicy.

Za każdym razem, gdy używasz legit array object I używasz jednej ze standardowych metod manipulowania tą tablicą, uderzasz w dane tablicy. W szczególności w wersji 8 są one zasadniczo takie same jak tablica C++, więc te reguły będą miały zastosowanie. Jeśli z jakiegoś powodu pracujesz z tablicą, której silnik nie jest w stanie określ z pewnością jest tablica, a następnie jesteś na znacznie bardziej wstrząsający Grunt. Z najnowszymi wersjami V8 jest jednak więcej miejsca do pracy. Na przykład, możliwe jest utworzenie klasy, która ma tablicę.prototype jako swój prototype i nadal zyskuje efektywny dostęp do różnych natywnych metod manipulacji tablicami. Ale to niedawna zmiana.

Przydatne mogą być konkretne linki do ostatnich zmian w manipulacji tablicami tutaj:

• http://code.google.com/p/v8/source/detail?r=10024
• http://code.google.com/p/v8/source/detail?r=9849
• http://code.google.com/p/v8/source/detail?r=9747

Jako dodatek, Oto Array Pop i Array Push bezpośrednio ze źródła V8, oba zaimplementowane w samym JS:

function ArrayPop() {
  if (IS_NULL_OR_UNDEFINED(this) && !IS_UNDETECTABLE(this)) {
    throw MakeTypeError("called_on_null_or_undefined",
                        ["Array.prototype.pop"]);
  }

  var n = TO_UINT32(this.length);
  if (n == 0) {
    this.length = n;
    return;
  }
  n--;
  var value = this[n];
  this.length = n;
  delete this[n];
  return value;
}


function ArrayPush() {
  if (IS_NULL_OR_UNDEFINED(this) && !IS_UNDETECTABLE(this)) {
    throw MakeTypeError("called_on_null_or_undefined",
                        ["Array.prototype.push"]);
  }

  var n = TO_UINT32(this.length);
  var m = %_ArgumentsLength();
  for (var i = 0; i < m; i++) {
    this[i+n] = %_Arguments(i);
  }
  this.length = n + m;
  return this.length;
}

Podczas pracy pod węzłem.js 0.10 (zbudowany na v8) widziałem użycie procesora, które wydawało się nadmierne dla obciążenia. Wyśledziłem jeden problem z wydajnością do funkcji, która sprawdzała istnienie ciągu znaków w tablicy. Więc zrobiłem kilka testów.

• załadowano 90 822 hostów
• Ładowanie config trwało 0.087 sekund (array)
• Ładowanie config trwało 0.152 sekund (obiekt)

Ładowanie 91K wpisów do tablicy (z validate & push) jest szybsze niż ustawienie obj[klucz] = wartość.

W następnym teście, sprawdziłem każdą nazwę hosta na liście jeden raz (91K iteracji, aby uśrednić czas wyszukiwania):

• wyszukiwanie config trwało 87.56 sekund (array)
• wyszukiwanie config trwało 0.21 sekund (obiekt)

Tutaj aplikacja to Haraka (serwer SMTP) i ładuje host_list raz przy starcie (i po zmianach), a następnie wykonuje to wyszukiwanie miliony razy podczas operacji. Przejście na obiekt było ogromnym zwycięstwo w wydajności.

Chciałbym uzupełnić istniejące odpowiedzi o badanie na pytanie, jak implementacje zachowują się w odniesieniu do rosnących tablic: jeśli zaimplementują je w "zwykły" sposób, można by zobaczyć wiele szybkich wypychań z rzadkimi, przeplatanymi powolnymi wypychaniami, w którym to momencie implementacja kopiuje wewnętrzną reprezentację tablicy z jednego bufora do większego.

Bardzo ładnie widać ten efekt, to jest z Chrome:

16: 4ms
40: 8ms 2.5
76: 20ms 1.9
130: 31ms 1.7105263157894737
211: 14ms 1.623076923076923
332: 55ms 1.5734597156398105
514: 44ms 1.5481927710843373
787: 61ms 1.5311284046692606
1196: 138ms 1.5196950444726811
1810: 139ms 1.5133779264214047
2731: 299ms 1.5088397790055248
4112: 341ms 1.5056755767118273
6184: 681ms 1.5038910505836576
9292: 1324ms 1.5025873221216042

Mimo że każde naciśnięcie jest profilowane, wyjście zawiera tylko te, które zajmują czas powyżej określonego progu. Dla każdego testu dostosowałem próg, aby wykluczyć wszystkie pchnięcia, które wydają się reprezentować szybkie pchnięcia.

Tak więc pierwsza liczba oznacza, który element został wstawiony (pierwsza linia jest dla 17 elementu), druga to ile czasu zajęło (dla wielu tablic porównywanie jest wykonywane równolegle), a ostatnia wartość jest podziałem pierwszej liczby przez tę w poprzedniej linii.

Wszystkie linie dla Chrome czas wykonania krótszy niż 2 ms jest wykluczony.

Widać, że Chrome zwiększa rozmiar tablicy w potęgach 1.5, plus pewne przesunięcie, aby uwzględnić małe tablice.

Dla Firefoksa to potęga dwóch:

126: 284ms
254: 65ms 2.015873015873016
510: 28ms 2.0078740157480315
1022: 58ms 2.003921568627451
2046: 89ms 2.0019569471624266
4094: 191ms 2.0009775171065494
8190: 364ms 2.0004885197850513

Musiałem trochę podwyższyć próg w Firefoksie, dlatego zaczynamy od #126.

Z IE otrzymujemy mix:

256: 11ms 256
512: 26ms 2
1024: 77ms 2
1708: 113ms 1.66796875
2848: 154ms 1.6674473067915691
4748: 423ms 1.6671348314606742
7916: 944ms 1.6672283066554338

To moc dwóch na początku, a potem przechodzi do mocy pięciu trzecich.

Więc wszystkie wspólne implementacje użyj "normalnego" sposobu dla tablic (zamiast szaleć na przykład linami ).

Oto kod benchmarka ioto skrzypce jest w środku.

var arrayCount = 10000;

var dynamicArrays = [];

for(var j=0;j<arrayCount;j++)
    dynamicArrays[j] = [];

var lastLongI = 1;

for(var i=0;i<10000;i++)
{
    var before = Date.now();
    for(var j=0;j<arrayCount;j++)
        dynamicArrays[j][i] = i;
    var span = Date.now() - before;
    if (span > 10)
    {
      console.log(i + ": " + span + "ms" + " " + (i / lastLongI));
      lastLongI = i;
    }
}