Які застереження щодо реалізації фундаментальних типів (наприклад, int) як класів?

При проектуванні і implenting об'єктно-орієнтована мова програмування, в якій - то момент один повинен зробити вибір про реалізацію основних типів (як int, float, doubleабо їх еквіваленти) , як класи або що - то інше. Зрозуміло, що мови в сім'ї С мають тенденцію не визначати їх як класи (Java має спеціальні примітивні типи, C # реалізує їх як незмінні структури тощо).

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

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

Чи просторова ефективність (і поліпшена просторова локальність, особливо у великих масивах) є єдиною причиною, чому фундаментальні типи часто не є класами?

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

Чи є вищезгадане неправильним, чи щось мені не вистачає?

Так, це в значній мірі зводиться до ефективності. Але ви, здається, недооцінюєте вплив (або переоцінюєте, наскільки добре працюють різні оптимізації).

По-перше, це не просто "просторові накладні витрати". Перетворення примітивів у коробку / виділення купи також має витрати на продуктивність. Існує додатковий тиск на ГК для розподілу та збору цих об'єктів. Це подвоюється, якщо "примітивні об'єкти" незмінні, як це має бути. Тоді більше пропусків кешу (як через непрямість, так і тому, що менше даних вписується в задану кількість кешу). Плюс до того, що "завантажувати адресу об'єкта, а потім завантажувати фактичне значення з цієї адреси", потрібно більше інструкцій, ніж "завантажувати значення безпосередньо".

По-друге, аналіз втечі - це не швидкий казковий пил. Це стосується лише значень, які, ну, не уникають. Безумовно, приємно оптимізувати локальні обчислення (наприклад, лічильники циклу та проміжні результати обчислень), і це дасть вимірні переваги. Але набагато більша більшість цінностей живуть у полях об’єктів та масивів. Зрозуміло, що вони можуть бути предметом аналізу втечі самостійно, але оскільки вони, як правило, мінливі еталонні типи, будь-яке їх псевдонім представляє суттєвий виклик для аналізу евакуації, який тепер повинен довести, що ці псевдоніми (1) також не уникають , і (2) не змінюють значення для усунення виділень.

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

І тоді трапляються випадки, коли речі справді втечують і їх неможливо оптимізувати. Дуже багато з них, насправді, якщо врахувати, як часто програмісти C переживають проблеми, пов'язані з розподілом речей. Коли об'єкт, що містить int, втікає, аналіз втечі перестає застосовуватися і до int. Попрощайтеся з ефективними примітивними полями .

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

Тобто, такі мови не можуть бути життєздатними. Ясно, що вони є. Тільки не припускайте, що це буде рядок так швидко, як мови з виділеними примітивами. Іншими словами, не обманюйте себе уявленнями про досить розумний компілятор .

Чи просторова ефективність (і поліпшена просторова локальність, особливо у великих масивах) є єдиною причиною, чому фундаментальні типи часто не є класами?

Ні.

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

Такі операції також не дуже добре вкладаються в підтипи. Ви не можете відправити інструкцію процесора. Ви не можете відправити з інструкції процесора. Я маю на увазі, що вся суть підтипу полягає в тому, щоб ви могли використовувати a, Dде можете B. Інструкції до процесора не є поліморфними. Щоб зробити це примітивом, вам доведеться обробляти їхні операції з логікою відправки, яка коштує в кілька разів більше операцій як простого додавання (або будь-якого іншого). Користь від того, щоб intбути частиною ієрархії типу, стає невеликим спором, коли вона запечатана / остаточна. І це ігнорування всіх головних болів з логікою диспетчеризації бінарних операторів ...

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

Лише дуже мало випадків, коли для повноцінних об'єктів потрібні "фундаментальні типи" (тут об’єкт - це дані, які або містять вказівник на механізм відправки, або позначені типом, який може використовуватися диспетчерським механізмом):

• Ви хочете, щоб визначені користувачем типи мали можливість успадковувати від основних типів. Зазвичай цього не потрібно, оскільки він вводить головні болі, пов'язані з працездатністю та безпекою. Це проблема продуктивності, тому що компіляція не може припустити, що у документа intбуде визначений фіксований розмір або що жодних методів не було відмінено, і це проблема безпеки, оскільки семантика ints може бути перервана (розглянемо ціле число, яке дорівнює будь-якому номеру, або що змінює своє значення, а не незмінне).

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

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

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

• Ви не маєте статичного набору тексту. Змінна може містити будь-яке значення, включаючи примітивні типи або об'єкти. Тому всі примітивні типи потрібно завжди містити в коробках, щоб гарантувати сильне друкування.

Мови, які мають статичний набір тексту, добре застосовують примітивні типи, де це можливо, і лише в крайньому випадку повертаються до типів, розміщених у коробці. Хоча багато програм не дуже чутливі до продуктивності, є випадки, коли розмір і склад примітивних типів надзвичайно актуальні: подумайте про масштабне скорочення чисельності, де потрібно помістити мільярди точок даних у пам'ять. Перехід від doubleдоfloatможе бути життєздатною стратегією оптимізації простору в C, але це не мало би ефекту, якщо всі числові типи завжди знаходяться в коробці (і, отже, витрачайте принаймні половину своєї пам'яті на покажчик механізму відправки). Коли примітивні типи в коробці використовуються локально, видалити бокс досить просто, використовуючи властивості компілятора, але було б недалекоглядним зробити ставку на загальну продуктивність вашої мови на "достатньо просунутий компілятор".

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

• Незмінюваність
• Кінцевість (не може бути отримана з)
• Статичне введення тексту

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

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

У Smalltalk всі вони (int, float тощо) є об'єктами першого класу. Тільки особливий випадок, SmallIntegers кодифіковані і трактуються по- різному віртуальної машини заради ефективності, і , отже , клас SmallInteger не допустять підкласи (який не є практичним обмеження.) Зверніть увагу , що це не потребує будь - яких особливої уваги з боку програміста, так як відмінність обмежується автоматичними процедурами, такими як генерація коду або збирання сміття.

І компілятор Smalltalk (вихідний код -> VM байт-коди), і VM nativizer (байт-коди -> машинний код) оптимізують створений код (JIT), щоб зменшити штраф за елементарні операції з цими основними об'єктами.

Я розробляв OO ланцюг та час виконання (це не вдалося із зовсім іншого набору причин).

Немає нічого поганого в тому, щоб робити такі речі, як справжні класи; насправді це полегшує проектування GC, оскільки зараз існує лише два види заголовків купи (клас та масив), а не 3 (клас, масив та примітивний) [той факт, що ми можемо об'єднати клас та масив після цього, не має значення ].

Справжній важливий випадок, що примітивні типи повинні мати переважно остаточні / запечатані методи (+ насправді має значення, ToString не так багато). Це дозволяє компілятору статично вирішувати майже всі виклики самих функцій та вбудовувати їх. У більшості випадків це не має значення як поведінка при копіюванні (я вирішив зробити вбудовування доступним на мовному рівні [так зробив .NET]), але в деяких випадках, якщо методи не запечатані, компілятор буде змушений генерувати виклик в функція, що використовується для реалізації int + int.