Чи погана практика писати код, який спирається на оптимізацію компілятора?

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

Тепер я відчуваю, що синтаксис набагато зрозуміліший, коли об'єкт явно повертається за значенням, і компілятор, як правило, використовує RVO і зробить процес більш ефективним. Чи погана практика покладатися на цю оптимізацію? Це робить код більш зрозумілим і читабельним для користувача, що надзвичайно важливо, але чи варто насторожитися, якщо компілятор зможе скористатися можливістю RVO?

Це мікрооптимізація чи щось я маю пам’ятати при розробці коду?

Використовуйте принцип найменшого здивування .

Це ти і тільки коли-небудь ти будеш використовувати цей код, і ти впевнений, що той самий, який ти і через 3 роки, не здивуєш тим, що робиш?

Тоді йти вперед.

У всіх інших випадках використовуйте стандартний спосіб; інакше ви та ваші колеги зіткнетесь із важкими помилками.

Наприклад, мій колега скаржився на те, що мій код спричинив помилки. Виявилося, він вимкнув булеву оцінку короткого замикання в налаштуваннях компілятора. Я ледве не вдарив його.

У цьому конкретному випадку, безумовно, просто повернутись на значення.

• RVO та NRVO - це добре відомі та надійні оптимізації, які справді повинен бути зроблений будь-яким порядним компілятором, навіть у режимі C ++ 03.

• Семантика переміщення забезпечує виведення об'єктів з функцій, якщо (N) RVO не відбулося. Це тільки корисно , якщо ваш об'єкт використовує динамічні дані всередині (як std::vectorробить), але це повинно бути дійсно в разі , якщо це що велике - переповнення стеки є ризиком , пов'язаним з великими автоматичними об'єктами.

• C ++ 17 виконує RVO. Тож не хвилюйтесь, він не зникне на вас і закінчить утверджуватися повністю після того, як компілятори будуть оновлені.

І врешті-решт, змушуючи додатковий динамічний розподіл повернути вказівник або змусити тип результату бути конфігуруваним за замовчуванням просто для того, щоб ви могли передавати його як вихідний параметр - це некрасиві та неідіоматичні рішення проблеми, яку, ймовірно, ніколи не буде мати.

Просто напишіть код, який має сенс, і подякуйте авторам-компіляторам за правильну оптимізацію коду, який має сенс.

Тепер я відчуваю, що синтаксис набагато зрозуміліший, коли об'єкт явно повертається за значенням, і компілятор, як правило, використовує RVO і зробить процес більш ефективним. Чи погана практика покладатися на цю оптимізацію? Це робить код більш зрозумілим і читабельним для користувача, що надзвичайно важливо, але чи варто насторожитися, якщо компілятор зможе скористатися можливістю RVO?

Це не мало відома, люб’язна мікро-оптимізація, про яку ви читали в невеликому блозі, що перебуває під загрозою торгівлі людьми, і тоді ви відчуваєте себе розумним та чудовим у використанні.

Після C ++ 11 RVO - це стандартний спосіб написання цього коду коду. Зазвичай, очікуване, викладене, згадане в переговорах, згадане в блогах, згадане в стандарті, повідомлятиметься про помилку компілятора, якщо не буде реалізовано. У мові C ++ 17 мова йде на крок далі і вимагає копіювати елісію в певних сценаріях.

Ви повинні абсолютно покладатися на цю оптимізацію.

Крім того, повернення за значенням просто призводить до набагато простішого читання та управління кодом, ніж код, який повертається за посиланням. Семантична цінність - це потужна річ, яка сама по собі може призвести до збільшення можливостей для оптимізації.

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

Однак те, про що ви говорите, - це скоріше питання ефективності. Ваш код працює краще, якщо він оптимізований за допомогою компілятора оптимізації RVO. Це добре, з усіх причин, зазначених в інших відповідях.

Однак якщо вам потрібна ця оптимізація (наприклад, якщо конструктор копій насправді призведе до відмови вашого коду), тепер ви перебуваєте в примхах компілятора.

Я думаю, що найкращим прикладом цього в моїй власній практиці є оптимізація хвостових викликів:

   int sillyAdd(int a, int b)
   {
      if (b == 0)
          return a;
      return sillyAdd(a + 1, b - 1);
   }

Це дурний приклад, але він показує хвостовий виклик, де функція називається рекурсивно правою в кінці функції. Віртуальна машина C ++ покаже, що цей код працює належним чином, хоча я можу викликати невелику плутанину з приводу того, чому я взагалі турбував писати таку процедуру додавання. Однак у практичних реалізаціях C ++ у нас є стек, і він має обмежений простір. Якщо це зробити педантично, ця функція повинна буде штовхати принаймні b + 1рамки стека на стек, як це робиться з її доповненням. Якщо я хочу порахувати sillyAdd(5, 7), це не велика справа. Якщо я хочу обчислити sillyAdd(0, 1000000000), я можу зіткнутися зі справжньою проблемою, викликаючи StackOverflow (а не хороший вид ).

Однак ми можемо побачити, що як тільки ми досягнемо останньої лінії повернення, ми дійсно готові до всього, що знаходиться в поточній рамці стека. Нам дійсно не потрібно тримати це навколо. Оптимізація виклику хвоста дозволяє "повторно використовувати" існуючий кадр стека для наступної функції. Таким чином нам потрібен лише 1 стек-кадр, а не b+1. (Нам залишається робити всі ці дурні додавання та віднімання, але вони не займають більше місця.) Насправді оптимізація перетворює код у:

   int sillyAdd(int a, int b)
   {
      begin:
      if (b == 0)
          return a;
      // return sillyAdd(a + 1, b - 1);
      a = a + 1;
      b = b - 1;
      goto begin;  
   }

У деяких мовах специфікація прямо вимагає оптимізацію хвостових викликів. C ++ не з таких. Я не можу розраховувати на компілятори C ++, щоб розпізнати цю можливість оптимізації хвостових викликів, якщо я не переходжу до кожного випадку. У моїй версії Visual Studio версія версії робить оптимізацію хвостового виклику, але версія для налагодження не робить (за задумом).

Таким чином, для мене було б погано залежати від можливості розрахувати sillyAdd(0, 1000000000).

На практиці програми C ++ очікують певних оптимізацій компілятора.

Особливо загляньте в стандартні заголовки ваших стандартних реалізацій контейнерів . За допомогою GCC ви можете запитати попередньо оброблену форму ( g++ -C -E) та внутрішнє представлення g++ -fdump-tree-gimpleGIMPLE ( або Gimple SSA з -fdump-tree-ssa) більшості вихідних файлів (технічно одиниць перекладу) за допомогою контейнерів. Ви будете здивовані кількістю оптимізації, яка зроблена (з g++ -O2). Таким чином, реалізатори контейнерів покладаються на оптимізацію (і в більшості випадків реалізатор стандартної бібліотеки C ++ знає, яка оптимізація відбудеться, і записує реалізацію контейнера, маючи на увазі; іноді він також записує пропуск для оптимізації в компілятор до мати справу з функціями, необхідними тоді стандартною бібліотекою C ++).

На практиці саме оптимізація компілятора робить C ++ та його стандартні контейнери досить ефективними. Тож можна покластися на них.

І так само у випадку з RVO, згаданим у вашому запитанні.

Стандарт C ++ був розроблений спільно (зокрема, експериментуючи досить хороші оптимізації, пропонуючи нові функції), щоб добре працювати з можливими оптимізаціями.

Наприклад, розгляньте програму нижче:

#include <algorithm>
#include <vector>

extern "C" bool all_positive(const std::vector<int>& v) {
  return std::all_of(v.begin(), v.end(), [](int x){return x >0;});
}

складіть його g++ -O3 -fverbose-asm -S. Ви дізнаєтесь, що створена функція не виконує жодної CALLінструкції з машини. Тож оптимізовано більшість кроків C ++ (побудова лямбда-замикання, його повторне застосування, отримання beginта endітераторів тощо). Машинний код містить лише цикл (який явно не відображається у вихідному коді). Без таких оптимізацій C ++ 11 не буде успішним.

доповнення

(Додано 31 грудня ^вул 2017)

Дивіться CppCon 2017: Метт Годбольт «Що зробив для мене останній час моїй компілятор? Розв’язання розмови про кришку компілятора » .

Кожного разу, коли ви використовуєте компілятор, розуміється, що він виробляє машинний чи байт-код для вас. Це нічого не гарантує, що таке генерований код, за винятком того, що він буде реалізовувати вихідний код відповідно до специфікації мови. Зауважте, що ця гарантія є однаковою незалежно від рівня оптимізації, що використовується, і, загалом, немає підстав вважати один вихід більш правильним, ніж інший.

Крім того, у таких випадках, як RVO, де він вказаний мовою, здавалося б, безглуздо виходити зі свого шляху, щоб уникнути його використання, особливо якщо це спрощує вихідний код.

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

Можливо, існують причини використання неоптимізованого коду (наприклад, для налагодження), однак випадок, зазначений у цьому питанні, видається не одним (і якщо ваш код виходить з ладу лише при оптимізації, він не є наслідком якоїсь особливості пристрою, на якому ви його запускаєте, тоді десь є помилка, і навряд чи буде в компіляторі.)

Я думаю, що інші добре охопили конкретний кут щодо С ++ та RVO. Ось більш загальна відповідь:

Що стосується правильності, то не слід покладатися на оптимізацію компілятора чи поведінку, що стосується компілятора в цілому. На щастя, ви, здається, не робите цього.

Що стосується продуктивності, то ви повинні розраховувати на поведінку компілятора в цілому та оптимізацію компілятора зокрема. Компілятор, сумісний зі стандартами, може безкоштовно компілювати ваш код будь-яким способом, доки скомпільований код поводиться відповідно до мовної специфікації. І я не знаю жодної специфікації для мови мови, яка визначає, наскільки швидкою повинна бути кожна операція.

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

Прапори, які визначають, як виконуються конкретні операції (наприклад, індекс або переповнення), часто стикаються з оптимізаціями компілятора, але цього не повинно бути. Вони чітко впливають на результати розрахунків.

Якщо оптимізація компілятора викликає різні результати, то помилка - помилка у компіляторі. Покладаючись на помилку у компіляторі, в довгостроковій перспективі є помилкою - що відбувається, коли вона виправляється?

Використання прапорів компілятора, які змінюють спосіб роботи обчислень, повинні бути добре задокументовані, але використовуватися за потребою

Немає.

Цим я весь час займаюся. Якщо мені потрібно отримати доступ до довільного 16-бітового блоку в пам'яті, я це роблю

void *ptr = get_pointer();
uint16_t u16;
memcpy(&u16, ptr, sizeof(u16)); // ntohs omitted for simplicity

... і покладайтеся на те, що компілятор робить все можливе, щоб оптимізувати цей фрагмент коду. Код працює на ARM, i386, AMD64 і практично на кожній архітектурі. Теоретично, неоптимізуючий компілятор може насправді викликати memcpy, що призводить до абсолютно поганої продуктивності, але це не є проблемою для мене, оскільки я використовую оптимізації компілятора.

Розглянемо альтернативу:

void *ptr = get_pointer();
uint16_t *u16ptr = ptr;
uint16_t u16;
u16 = *u16ptr;  // ntohs omitted for simplicity

Цей альтернативний код не працює на машинах, які потребують належного вирівнювання, якщо get_pointer()повертає нерівневий покажчик. Крім того, можуть існувати альтернативні проблеми.

Різниця між -O2 та -O0 при використанні memcpyтрюку велика: 3,2 Гбіт / с продуктивність контрольної суми IP проти 67 Гбіт / с в якості контрольної суми IP. За порядок різниці величин!

Іноді вам може знадобитися допомогти компілятору. Так, наприклад, замість того, щоб покладатися на компілятор для розгортання циклів, ви можете зробити це самостійно. Або шляхом впровадження відомого пристрою Даффа , або більш чистим способом.

Недолік покладання на оптимізацію компілятора полягає в тому, що якщо ви запустите gdb для налагодження свого коду, ви можете виявити, що багато чого було оптимізовано. Таким чином, вам може знадобитися перекомпілювати з -O0, тобто продуктивність буде повністю смоктати при налагодженні. Я думаю, що це недолік, який варто врахувати, враховуючи переваги оптимізації компіляторів.

Що б ви не робили, будь ласка, переконайтеся, що ваш шлях насправді не є визначеним поведінкою. Безумовно, доступ до якогось випадкового блоку пам'яті як 16-бітного цілого числа є невизначеним поведінкою через проблеми з вивільненням та вирівнюванням.

Усі спроби ефективного коду, написаного в чому завгодно, крім складання, дуже і дуже покладаються на оптимізацію компілятора, починаючи з найпростішого, наприклад ефективного розподілу реєстру, щоб уникнути зайвих розсипань стека в усьому місці і, принаймні, досить хорошого, якщо не відмінного, вибору інструкцій. Інакше ми повернемося до 80-х років, де нам довелося розміщувати registerпідказки всюди і використовувати мінімальну кількість змінних у функції, щоб допомогти архаїчним компіляторам C або навіть раніше, коли gotoбула корисною оптимізацією розгалуження.

Якщо б нам не здалося, що ми можемо розраховувати на здатність нашого оптимізатора оптимізувати наш код, ми все-таки кодуємо критичні для продуктивності шляхи виконання в зборі.

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

RVO - це те, що існує протягом багатьох століть, і, принаймні, виключаючи дуже складні випадки, - це те, що компілятори надійно застосовують протягом століть. Однозначно не варто працювати над проблемою, яка не існує.

Помилка на стороні того, що покладатися на оптимізатор, не боячись цього

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

Ви добре впираєтесь в оптимізатор. Так тримати. Не ставте таким, як хлопець, який починає явно просити вбудувати кожну функцію, викликану в циклі, перш ніж навіть профайлювати з помилкового страху перед недоліками оптимізатора.

Профілювання

Профілювання - це справді кругла, але остаточна відповідь на ваше запитання. Новачки, які прагнуть написати ефективний код, часто борються не з тим, що оптимізувати, це з тим, що не оптимізувати, оскільки вони розробляють всілякі помилкові помилки щодо неефективності, які, хоча людино інтуїтивно зрозумілі, обчислювально помиляються. Розробка досвіду роботи з профілером почне справді давати вам належну оцінку не тільки можливостям оптимізації ваших компіляторів, на які ви можете впевнено спиратися, але й можливостям (а також обмеженням) вашого обладнання. Можливо, ще більше значення має профілювання у вивченні того, чого не варто оптимізувати, ніж вивчати те, що було.

Програмне забезпечення можна писати на C ++ на дуже різних платформах і для безлічі різних цілей.

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

Я думаю, нудна відповідь на це: «це залежить».

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

Чи погана практика писати код, який спирається на оптимізацію компілятора, яка , швидше за все, не буде вимкнена , тобто документально підтверджена і перевірена одиницею ? Можливо, не.

Якщо ви не скажете нам більше, це погана практика, але не з тієї причини, яку ви пропонуєте.

Можливо, на відміну від інших мов, якими ви користувалися раніше, повернення значення об'єкта в C ++ дає копію об'єкта. Якщо ви потім модифікуєте об'єкт, ви змінюєте інший об'єкт . Тобто, якщо я маю Obj a; a.x=1;і Obj b = a;, то роблю b.x += 2; b.f();, то a.xвсе одно дорівнює 1, а не 3.

Отже, ні, використання об'єкта як значення замість посилання або вказівника не забезпечує однакову функціональність, і ви можете виявити помилки у вашому програмному забезпеченні.

Можливо, ви це знаєте, і це не впливає негативно на конкретний випадок використання. Однак, виходячи з формулювання у вашому запитанні, виявляється, що ви можете не знати про відмінність; формулювання типу "створити об'єкт у функції".

"створити об'єкт у функції" звучить так, як звучить new Obj;"повернення об'єкта за значенням"Obj a; return a;

Obj a;і Obj* a = new Obj;це дуже, дуже різні речі; перший може призвести до пошкодження пам’яті, якщо її не правильно використовувати і не зрозуміти, а другий може призвести до витоку пам’яті, якщо її не правильно використовувати і не зрозуміти.

Пітер В абсолютно коректний, рекомендуючи щонайменше здивування.

Щоб відповісти на ваше конкретне запитання, що це (швидше за все) означає в C ++, що ви повинні повернути a std::unique_ptrдо побудованого об'єкта.

Причина в тому, що для розробника C ++ це зрозуміліше, що відбувається.

Хоча ваш підхід, швидше за все, спрацює, ви ефективно сигналізуєте про те, що об'єкт є типом малого значення, коли насправді це не так. Крім того, ви відкидаєте будь-яку можливість абстрагування інтерфейсу. Це може бути нормально для ваших поточних цілей, але часто дуже корисно при роботі з матрицями.

Я вдячний, що якщо ви прийшли з інших мов, всі сигіли можуть спочатку заплутатися. Але будьте обережні, щоб не припускати, що, не використовуючи їх, ви зробите свій код більш зрозумілим. На практиці, навпаки, вірно.