Няколко глупави бенчмарка за проверка на разликите в производителността между версиите на Dart.

Имайте предвид, че това не е някакъв сложен бенчмаркинг. Просто исках да видя тези числа и си помислих, че някой друг може да ги сметне за интересни. Освен това просто исках да видя разликата между Dart версии 2.19.6 и Dart 3.0.0 и разликата между double и int types, които също ще бъдат 64-битово число на Mac.

Тези бенчмаркове са напълно безсмислени в реалния живот и са просто забавно нещо за правене след мигриране към новата версия на Dart.

Освен това, ако се интересувате, следете, защото следващото нещо, което планирам да споделя, са показателите за FFI повиквания.

Предпоставка

Имаме само две функции за тестване на Фибоначи:

double fib(double n) {
  if (n < 2) {
    return n;
  }
  return fibd(n - 2) + fibd(n - 1);
}

int fib(int n) {
  if (n < 2) {
    return n;
  }
  return fibd(n - 2) + fibd(n - 1);
}

И сума:

double sum(double a, double b) {
  return a + b;
}

int sum(int a, int b) {
  return a + b;
}

Всеки ще бъде извикан 10 пъти, за да получи средната стойност.

Също така за моя изненада операциите с цели числа са два пъти по-бързи, когато извикате dart run в сравнение с компилираната версия. Възможно ли е Dart JIT все още да е много по-оптимизиран от AOT? Моля, уведомете ме, ако знаете отговора или знаете как да създадете по-бърза компилация.

Фибоначи

Просто исках да проверя някои функции, които имат повече от основни аритметични операции, в идеалния случай условие и рекурсия, които Фибоначи покрива доста добре.

Dart 2.19.6: „бягане на стрели“

Double fib: 7381, Fib: 1134903170.0
Int fib: 3661, Fib: 1134903170

Dart 3.0.0: „бягане на дартс“

Double fib: 7357, Fib: 1134903170.0
Int fib: 3341, Fib: 1134903170

В тези резултати можем да видим, че integer рекурсията е завършила два пъти по-бързо. На пръв поглед бихме могли да приемем, че просто целочислената производителност е два пъти по-добра, но мисля, че най-голямата цена на производителността идва от извиквания на функции, но не и от тези аритметични операции. Станах още по-уверен в това след сравнителен анализ на обажданията на FFI.

Освен това няма разлика в производителността между версиите на Dart в double comparisons, което според мен има смисъл. Екипът на Dart поддържа JIT за бързи итерации на разработката и не мисля, че имат някакви цели да го направят по-бърз.

Сега нека проверим компилираните изпълними файлове:

Dart 2.19.6: „dart compile exe“

Double fib: 6629, Fib: 1134903170.0
Int fib: 6726, Fib: 1134903170

Dart 3.0.0: „dart compile exe“

Double fib: 5946, Fib: 1134903170.0
Int fib: 5799, Fib: 1134903170

Както можете да видите, получаваме доста приятна изненада, въпреки че екипът на Dart не го спомена по време на презентацията си — и двете версии double и int станаха с около 10% по-бързи, което е хубаво.

Въпреки това можете също да видите, че по някаква причина integer производителността в компилираната компилация е същата като double един и два пъти по-бавна от JIT версията. Както вече споменах, не съм сигурен, че е свързано с производителността на integer. Изглежда най-големият разход в примерите на Фибоначи идва от извиквания на функции. От много години не съм се фокусирал върху суровата производителност, затова е доста интересно колко скъпи могат да бъдат извикванията на функции на различни езици.

Да преминем към финалната част

Сума

Просто исках сурови изчисления без условия. Мисля, че тези обаждания могат да бъдат вградени в производствените компилации.

Dart 2.19.6: „бягане на стрели“

Double add: 979, sum: 200000000.0
Int add: 569, sum: 200000000

Dart 3.0.0: „бягане на дартс“

Double add: 979, sum: 200000000.0
Int add: 551, sum: 200000000

Както можете да видите, картината е доста сходна. Отново, int версията е два пъти по-бърза от double и цялостната производителност в режим JIT е почти същата.

Dart 2.19.6: „dart compile exe“

Double add: 185, sum: 200000000.0
Int add: 91, sum: 200000000

Dart 3.0.0: „dart compile exe“

Double add: 182, sum: 200000000.0
Int add: 92, sum: 200000000

В компилиран режим можем да видим много интересна картина:

  1. Производителността между версиите е еднаква. Отново предполагам, но мисля, че простите аритметични операции вече са толкова бързи, колкото биха могли да бъдат, и подобренията в резултатите на Фибоначи идват от други подобрения, като разходите за извикване на функция.
  2. Като се има предвид колко по-бързо е производственото изграждане, мисля, че компилаторът просто е вградил тези функции, елиминирайки напълно разходите за извикване на функции.
  3. И int сега е два пъти по-бърз в сравнение с double, както и в JIT.

Този малък тест ме насърчи да науча повече за представянето на Dart и се надявам, че може да подхрани нечие любопитство, както подхранва моето. Наистина търся поредица от статии „Dart performance“, изготвена от екипа на Dart.

наздраве!