Мені подобаються деякі функції D, але мені було б цікаво, якщо вони прийдуть зі штрафним виконанням?

Для порівняння я реалізував просту програму, яка обчислює скалярні продукти багатьох коротких векторів як у С ++, так і в D. Результат дивовижний:

• D: 18,9 с [див. Нижче для остаточного виконання]
• C ++: 3,8 с

Чи справді C ++ майже майже в п'ять разів швидше чи я помилився в програмі D?

Я компілював C ++ з g ++ -O3 (gcc-знімок 2011-02-19) і D з dmd -O (dmd 2.052) на помірному недавньому робочому столі Linux. Результати можна відтворити протягом декількох пробіжок, а стандартні відхилення незначні.

Ось програма C ++:

#include <iostream>
#include <random>
#include <chrono>
#include <string>

#include <vector>
#include <array>

typedef std::chrono::duration<long, std::ratio<1, 1000>> millisecs;
template <typename _T>
long time_since(std::chrono::time_point<_T>& time) {
      long tm = std::chrono::duration_cast<millisecs>( std::chrono::system_clock::now() - time).count();
  time = std::chrono::system_clock::now();
  return tm;
}

const long N = 20000;
const int size = 10;

typedef int value_type;
typedef long long result_type;
typedef std::vector<value_type> vector_t;
typedef typename vector_t::size_type size_type;

inline value_type scalar_product(const vector_t& x, const vector_t& y) {
  value_type res = 0;
  size_type siz = x.size();
  for (size_type i = 0; i < siz; ++i)
    res += x[i] * y[i];
  return res;
}

int main() {
  auto tm_before = std::chrono::system_clock::now();

  // 1. allocate and fill randomly many short vectors
  vector_t* xs = new vector_t [N];
  for (int i = 0; i < N; ++i) {
    xs[i] = vector_t(size);
      }
  std::cerr << "allocation: " << time_since(tm_before) << " ms" << std::endl;

  std::mt19937 rnd_engine;
  std::uniform_int_distribution<value_type> runif_gen(-1000, 1000);
  for (int i = 0; i < N; ++i)
    for (int j = 0; j < size; ++j)
      xs[i][j] = runif_gen(rnd_engine);
  std::cerr << "random generation: " << time_since(tm_before) << " ms" << std::endl;

  // 2. compute all pairwise scalar products:
  time_since(tm_before);
  result_type avg = 0;
  for (int i = 0; i < N; ++i)
    for (int j = 0; j < N; ++j) 
      avg += scalar_product(xs[i], xs[j]);
  avg = avg / N*N;
  auto time = time_since(tm_before);
  std::cout << "result: " << avg << std::endl;
  std::cout << "time: " << time << " ms" << std::endl;
}

І ось версія D:

import std.stdio;
import std.datetime;
import std.random;

const long N = 20000;
const int size = 10;

alias int value_type;
alias long result_type;
alias value_type[] vector_t;
alias uint size_type;

value_type scalar_product(const ref vector_t x, const ref vector_t y) {
  value_type res = 0;
  size_type siz = x.length;
  for (size_type i = 0; i < siz; ++i)
    res += x[i] * y[i];
  return res;
}

int main() {   
  auto tm_before = Clock.currTime();

  // 1. allocate and fill randomly many short vectors
  vector_t[] xs;
  xs.length = N;
  for (int i = 0; i < N; ++i) {
    xs[i].length = size;
  }
  writefln("allocation: %i ", (Clock.currTime() - tm_before));
  tm_before = Clock.currTime();

  for (int i = 0; i < N; ++i)
    for (int j = 0; j < size; ++j)
      xs[i][j] = uniform(-1000, 1000);
  writefln("random: %i ", (Clock.currTime() - tm_before));
  tm_before = Clock.currTime();

  // 2. compute all pairwise scalar products:
  result_type avg = cast(result_type) 0;
  for (int i = 0; i < N; ++i)
    for (int j = 0; j < N; ++j) 
      avg += scalar_product(xs[i], xs[j]);
  avg = avg / N*N;
  writefln("result: %d", avg);
  auto time = Clock.currTime() - tm_before;
  writefln("scalar products: %i ", time);

  return 0;
}

Щоб увімкнути всі оптимізації та відключити всі перевірки безпеки, скомпілюйте програму D із такими прапорами DMD:

-O -inline -release -noboundscheck

EDIT : Я спробував ваші програми з g ++, dmd та gdc. dmd відстає, але gdc досягає продуктивності дуже близької до g ++. Я використовував командний рядок gdmd -O -release -inline(gdmd - обгортка навколо gdc, яка приймає параметри dmd).

Дивлячись на лістинг асемблера, схоже, що ні dmd, ні gdc вбудовані scalar_product, але g ++ / gdc не випускає інструкцій MMX, тому вони можуть бути автоматично векторизованими циклом.

Одна велика річ, яка сповільнює D - це реалізація сміття з підрозділу. Орієнтовні показники, які не сильно підкреслюють GC, демонструватимуть дуже схожу ефективність з кодом C та C ++, зібраним з тим самим доповненням компілятора. Орієнтовні показники, які сильно напружують GC, покажуть, що D виконує безвідмовно. Будьте впевнені, однак, це єдине (хоч і серйозне) питання якості впровадження, а не гарантія повільності. Крім того, D надає можливість відмовитися від GC та налаштувати управління пам’яттю на критичні для продуктивності біти, при цьому все ще використовуючи його в менш критичних для продуктивності 95% коду.

Останнім часом я доклав певних зусиль для покращення ефективності роботи GC, і результати були досить драматичними, принаймні, щодо синтетичних орієнтирів. Сподіваємось, ці зміни будуть інтегровані в один з наступних кількох випусків і пом’якшать проблему.

Це дуже повчальна нитка, дякую за всю роботу ОП та помічникам.

Одне зауваження - цей тест не оцінює загальне питання абстракції / покарання функції або навіть питання про якість резервного копіювання. Він зосереджений на практично одній оптимізації (циклічна оптимізація). Я вважаю, що справедливо сказати, що бекенд Gcc дещо вишуканіший, ніж dmd, але було б помилкою вважати, що розрив між ними такий же великий для всіх завдань.

Однозначно здається, що питання якості реалізації.

Я провів кілька тестів з кодом ОП і вніс деякі зміни. Насправді я D швидше йшов для LDC / clang ++, працюючи на припущенні, що масиви повинні бути розподілені динамічно ( xsта пов'язані з ними скаляри). Дивіться нижче деякі номери.

Питання до ОП

Чи є навмисним використання одного і того ж насіння для кожної ітерації C ++, тоді як для D не так?

Налаштування

Я переробив оригінальне джерело D (охрещене scalar.d), щоб зробити його портативним між платформами. Це стосувалося лише зміни типу чисел, які використовуються для доступу та зміни розміру масивів.

Після цього я вніс такі зміни:

• Використовується uninitializedArrayдля уникнення inits за замовчуванням для скалярів у xs (мабуть, це зробило найбільше значення) Це важливо, оскільки D зазвичай за замовчуванням вводить усе безшумно, чого C ++ не робить.

• Факторний код друку і замінений writeflnнаwriteln

• Змінив імпорт на вибірковий
• Використовується оператор pow ( ^^) замість ручного множення для останнього кроку обчислення середнього
• Вилучено size_typeта замінено належним чином новим index_typeпсевдонімом

... таким чином отримуємоscalar2.cpp ( пастбін ):

    import std.stdio : writeln;
    import std.datetime : Clock, Duration;
    import std.array : uninitializedArray;
    import std.random : uniform;

    alias result_type = long;
    alias value_type = int;
    alias vector_t = value_type[];
    alias index_type = typeof(vector_t.init.length);// Make index integrals portable - Linux is ulong, Win8.1 is uint

    immutable long N = 20000;
    immutable int size = 10;

    // Replaced for loops with appropriate foreach versions
    value_type scalar_product(in ref vector_t x, in ref vector_t y) { // "in" is the same as "const" here
      value_type res = 0;
      for(index_type i = 0; i < size; ++i)
        res += x[i] * y[i];
      return res;
    }

    int main() {
      auto tm_before = Clock.currTime;
      auto countElapsed(in string taskName) { // Factor out printing code
        writeln(taskName, ": ", Clock.currTime - tm_before);
        tm_before = Clock.currTime;
      }

      // 1. allocate and fill randomly many short vectors
      vector_t[] xs = uninitializedArray!(vector_t[])(N);// Avoid default inits of inner arrays
      for(index_type i = 0; i < N; ++i)
        xs[i] = uninitializedArray!(vector_t)(size);// Avoid more default inits of values
      countElapsed("allocation");

      for(index_type i = 0; i < N; ++i)
        for(index_type j = 0; j < size; ++j)
          xs[i][j] = uniform(-1000, 1000);
      countElapsed("random");

      // 2. compute all pairwise scalar products:
      result_type avg = 0;
      for(index_type i = 0; i < N; ++i)
        for(index_type j = 0; j < N; ++j)
          avg += scalar_product(xs[i], xs[j]);
      avg /= N ^^ 2;// Replace manual multiplication with pow operator
      writeln("result: ", avg);
      countElapsed("scalar products");

      return 0;
    }

Після тестування scalar2.d(який по пріоритетам оптимізації швидкості), з цікавості я замінив петлю в mainс foreachеквівалентами, і назвав його scalar3.d( Pastebin ):

    import std.stdio : writeln;
    import std.datetime : Clock, Duration;
    import std.array : uninitializedArray;
    import std.random : uniform;

    alias result_type = long;
    alias value_type = int;
    alias vector_t = value_type[];
    alias index_type = typeof(vector_t.init.length);// Make index integrals portable - Linux is ulong, Win8.1 is uint

    immutable long N = 20000;
    immutable int size = 10;

    // Replaced for loops with appropriate foreach versions
    value_type scalar_product(in ref vector_t x, in ref vector_t y) { // "in" is the same as "const" here
      value_type res = 0;
      for(index_type i = 0; i < size; ++i)
        res += x[i] * y[i];
      return res;
    }

    int main() {
      auto tm_before = Clock.currTime;
      auto countElapsed(in string taskName) { // Factor out printing code
        writeln(taskName, ": ", Clock.currTime - tm_before);
        tm_before = Clock.currTime;
      }

      // 1. allocate and fill randomly many short vectors
      vector_t[] xs = uninitializedArray!(vector_t[])(N);// Avoid default inits of inner arrays
      foreach(ref x; xs)
        x = uninitializedArray!(vector_t)(size);// Avoid more default inits of values
      countElapsed("allocation");

      foreach(ref x; xs)
        foreach(ref val; x)
          val = uniform(-1000, 1000);
      countElapsed("random");

      // 2. compute all pairwise scalar products:
      result_type avg = 0;
      foreach(const ref x; xs)
        foreach(const ref y; xs)
          avg += scalar_product(x, y);
      avg /= N ^^ 2;// Replace manual multiplication with pow operator
      writeln("result: ", avg);
      countElapsed("scalar products");

      return 0;
    }

Я склав кожен з цих тестів, використовуючи компілятор на основі LLVM, оскільки LDC є найкращим варіантом для компіляції D з точки зору продуктивності. У моїй установці x86_64 Arch Linux я використав такі пакети:

• clang 3.6.0-3
• ldc 1:0.15.1-4
• dtools 2.067.0-2

Я використовував наступні команди для складання кожної:

• C ++: clang++ scalar.cpp -o"scalar.cpp.exe" -std=c++11 -O3
• D: rdmd --compiler=ldc2 -O3 -boundscheck=off <sourcefile>

Результати

Результати ( скріншот вихідного консольного виводу ) кожної версії джерела такі:

1. scalar.cpp (оригінальний C ++):

   allocation: 2 ms
   
   random generation: 12 ms
   
   result: 29248300000
   
   time: 2582 ms

   C ++ встановлює стандарт на рівні 2582 мс .

2. scalar.d (змінене джерело ОП):

   allocation: 5 ms, 293 μs, and 5 hnsecs 
   
   random: 10 ms, 866 μs, and 4 hnsecs 
   
   result: 53237080000
   
   scalar products: 2 secs, 956 ms, 513 μs, and 7 hnsecs 

   Це тривало ~ 2957 мс . Повільніше, ніж реалізація C ++, але не дуже.

3. scalar2.d (зміна типу індексу / довжини та неініціалізована оптимізація масиву):

   allocation: 2 ms, 464 μs, and 2 hnsecs
   
   random: 5 ms, 792 μs, and 6 hnsecs
   
   result: 59
   
   scalar products: 1 sec, 859 ms, 942 μs, and 9 hnsecs

   Іншими словами, ~ 1860 мс . Поки що це лідирує.

4. scalar3.d (передвіщає):

   allocation: 2 ms, 911 μs, and 3 hnsecs
   
   random: 7 ms, 567 μs, and 8 hnsecs
   
   result: 189
   
   scalar products: 2 secs, 182 ms, and 366 μs

   ~ 2182 мс повільніше scalar2.d, але швидше, ніж версія C ++.

Висновок

При правильних оптимізаціях реалізація D фактично пішла швидше, ніж її еквівалентна C ++ реалізація, використовуючи доступні компілятори на основі LLVM. Поточний розрив між D та C ++ для більшості програм видається лише заснованим на обмеженнях поточних реалізацій.

dmd є базовою реалізацією мови, і тому більшість робіт вкладається у фронтенд, щоб виправити помилки, а не оптимізувати бекенд.

"in" у вашому випадку швидше, тому що ви використовуєте динамічні масиви, які є еталонними типами. З посиланням ви вводите інший рівень непрямості (який зазвичай використовується для зміни самого масиву, а не лише вмісту).

Зазвичай вектори реалізуються з конструкціями, де const ref має ідеальний сенс. Див. SmallptD vs. smallpt на прикладі реального світу, що містить навантаження векторних операцій та випадковості.

Зауважте, що 64-розрядні можуть також змінити значення. Я колись пропустив, що на x64 gcc компілює 64-розрядний код, тоді як dmd все ще за замовчуванням до 32 (зміниться, коли 64-розрядний кодеген дозріває). Відбулося надзвичайне прискорення з "dmd -m64 ...".

Чи швидше C ++ чи D, швидше за все, буде сильно залежати від того, що ви робите. Я б подумав, що, порівнюючи добре написаний C ++ з добре написаним кодом D, вони, як правило, або мають однакову швидкість, або C ++ будуть швидшими, але те, що конкретний компілятор вдається оптимізувати, може мати великий ефект цілком осторонь мови себе.

Однак є кілька випадків, коли D має великі шанси перемогти С ++ за швидкість. Основним, що спадає на думку, буде обробка рядків. Завдяки можливостям нарізки масиву D рядки (і масиви взагалі) можуть бути оброблені набагато швидше, ніж ви легко можете зробити в C ++. Що стосується D1, XML-процесор Tango надзвичайно швидкий , насамперед завдяки можливостям нарізки масиву D (і, сподіваємось, D2 матиме аналогічно швидкий аналізатор XML після того, як буде завершено те, що зараз працює над Phobos). Отже, в кінцевому підсумку, чи буде D або C ++ швидше, буде дуже залежно від того, що ви робите.

Тепер я буду здивований , що ви бачите таку різницю в швидкості в даному конкретному випадку, але це така справа , що я б очікувати поліпшення , як DMD поліпшується. Використання gdc може принести кращі результати і, швидше за все, буде більш детальним порівнянням мови (а не бекенда), враховуючи, що вона заснована на gcc. Але мене це зовсім не здивує, якщо є ряд речей, які можна зробити для прискорення коду, який генерує dmd. Я не думаю, що в цьому моменті є багато питань, що gcc зріліший ніж dmd. А оптимізація коду є одним із головних плодів зрілості коду.

Зрештою, важливим є те, наскільки добре працює dmd для вашої конкретної програми, але я погоджуюся, що було б непогано знати, наскільки добре C ++ і D порівнюються загалом. Теоретично вони повинні бути майже однаковими, але це реально залежить від реалізації. Я думаю, що для того, щоб перевірити, наскільки добре вони в даний час, вони потрібні для вичерпного набору орієнтирів.

Ви можете написати C-код D, наскільки це швидше, це залежатиме від багатьох речей:

• Який компілятор ви використовуєте
• Яку функцію ви використовуєте
• як агресивно ви оптимізуєте

Відмінності у першому не є справедливим для перетягування. Другий може дати перевагу C ++, оскільки він, якщо що, має менше важких особливостей. Третє - найцікавіше: D-код в чомусь легше оптимізувати, оскільки загалом його легше зрозуміти. Крім того, він має можливість робити велику ступінь генеративного програмування, що дозволяє такі речі, як багатослівний та повторюваний, але швидкий код, записуватись у коротших формах.

Схоже, питання якості впровадження. Наприклад, ось що я тестував:

import std.datetime, std.stdio, std.random;

version = ManualInline;

immutable N = 20000;
immutable Size = 10;

alias int value_type;
alias long result_type;
alias value_type[] vector_type;

result_type scalar_product(in vector_type x, in vector_type y)
in
{
    assert(x.length == y.length);
}
body
{
    result_type result = 0;

    foreach(i; 0 .. x.length)
        result += x[i] * y[i];

    return result;
}

void main()
{   
    auto startTime = Clock.currTime();

    // 1. allocate vectors
    vector_type[] vectors = new vector_type[N];
    foreach(ref vec; vectors)
        vec = new value_type[Size];

    auto time = Clock.currTime() - startTime;
    writefln("allocation: %s ", time);
    startTime = Clock.currTime();

    // 2. randomize vectors
    foreach(ref vec; vectors)
        foreach(ref e; vec)
            e = uniform(-1000, 1000);

    time = Clock.currTime() - startTime;
    writefln("random: %s ", time);
    startTime = Clock.currTime();

    // 3. compute all pairwise scalar products
    result_type avg = 0;

    foreach(vecA; vectors)
        foreach(vecB; vectors)
        {
            version(ManualInline)
            {
                result_type result = 0;

                foreach(i; 0 .. vecA.length)
                    result += vecA[i] * vecB[i];

                avg += result;
            }
            else
            {
                avg += scalar_product(vecA, vecB);
            }
        }

    avg = avg / (N * N);

    time = Clock.currTime() - startTime;
    writefln("scalar products: %s ", time);
    writefln("result: %s", avg);
}

З ManualInlineпевним значенням я отримую 28 секунд, але без мене стає 32. Тож компілятор навіть не вбудовує цю просту функцію, що, я думаю, зрозуміло, що має бути.

(Мій командний рядок є dmd -O -noboundscheck -inline -release ....)