Чому виконуючі іржі такі величезні?

Щойно знайшовши Руста і прочитавши перші два глави документації, я вважаю підхід і те, як вони визначили мову особливо цікавими. Тому я вирішив змочити пальці і почав з Hello world ...

Я робив це на Windows 7 x64, btw.

fn main() {
    println!("Hello, world!");
}

Видаючи cargo buildі дивлячись на результат, targets\debugя виявив, що отриманий .exe3MB. Після деяких пошуків (документацію вантажів прапор командного рядка важко знайти ...) я знайшов --releaseваріант і створив версію версії. На мій подив, розмір .exe став лише меншим на незначну суму: 2,99 Мб замість 3 МБ.

Тож, зізнавшись, я новачок у Расті та його екосистеми, я сподівався, що мова програмування систем створить щось компактне.

Хтось може детальніше розібратися з тим, до чого збирається Rust, як це можливо, вона створює такі величезні зображення з 3-х лайнерної програми? Це компіляція до віртуальної машини? Чи є команда стриппу, яку я пропустив (інформація про налагодження у складі релізу?)? Що ще, що могло б зрозуміти, що відбувається?

Rust використовує статичне посилання для компіляції своїх програм, тобто всі бібліотеки, необхідні навіть найпростішій Hello world!програмі, будуть зібрані у ваш виконуваний файл. Сюди входить також іржі.

Щоб змусити Руста динамічно зв’язувати програми, використовуйте аргументи командного рядка -C prefer-dynamic; це призведе до значно меншого розміру файлів, але також вимагатиме, щоб бібліотеки Rust (включаючи його час виконання) були доступні вашій програмі під час виконання програми. Це по суті означає, що вам потрібно буде їх надати, якщо на комп’ютері їх немає, зайнявши більше місця, ніж займає ваша первісна статично пов’язана програма.

Для портативності я рекомендую вам статично зв’язувати бібліотеки Rust та час виконання так, як ви робили, якщо ви коли-небудь розповсюджували свої програми іншим.

У мене немає жодних систем Windows, які можна було б приміряти, але в Linux статично складений світ привіт привіт Rust насправді менший, ніж еквівалент C. Якщо ви бачите величезну різницю в розмірах, це, мабуть, тому, що ви пов'язуєте виконуваний файл Rust статично, а С - динамічно.

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

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

Якщо ви зацікавлені, ось мої результати:

-rw-r - r-- 1 aij aij 63 квітня 5 14:26 printf.c
-rwxr-xr-x 1 aij aij 6696 5 квітня 14:27 printf.dyn
-rwxr-xr-x 1 aij aij 829344 5 квітня 14:27 printf.static
-rw-r - r-- 1 aij aij 59 квіт. 5 14:26 puts.c
-rwxr-xr-x 1 aij aij 6696 5 квітня 14:27 puts.dyn
-rwxr-xr-x 1 aij aij 829344 5 квітня 14:27 puts.static
-rwxr-xr-x 1 aij aij 8712 квітня 5 14:28 rust.dyn
-rw-r - r-- 1 aij aij 46 квітня 14 14:09 rust.rs
-rwxr-xr-x 1 aij aij 661496 5 квітня 14:28 rust.static

Вони були складені за допомогою gcc (Debian 4.9.2-10) 4.9.2 та rustc 1.0.0-nightly (d17d6e7f1 2015-04-02) (побудовано 2015-04-03), як із параметрами за замовчуванням, так і з -staticgcc та -C prefer-dynamicдля іржа.

У мене було дві версії світу привіт С, тому що я думав, що використання puts()може зв’язати в меншій кількості одиниць компіляції.

Якщо ви хочете спробувати відтворити його в Windows, ось джерела, які я використав:

printf.c:

#include <stdio.h>
int main() {
  printf("Hello, world!\n");
}

puts.c:

#include <stdio.h>
int main() {
  puts("Hello, world!");
}

rust.rs

fn main() {
    println!("Hello, world!");
}

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

Під час компіляції з Cargo ви можете використовувати динамічне посилання:

cargo rustc --release -- -C prefer-dynamic

Це різко зменшить розмір двійкового файлу, оскільки він зараз динамічно пов'язаний.

У Linux, принаймні, ви також можете викреслити двійкові символи за допомогою stripкоманди:

strip target/release/<binary>

Це приблизно вдвічі зменшить розмір більшості двійкових файлів.

Для огляду всіх способів зменшити розмір бінарного файлу іржі див. min-sized-rustСховище.

Поточні кроки високого рівня для зменшення бінарного розміру:

1. Використовуйте Rust 1.32.0 або новішу версію (яка не включає jemallocтипово)
2. Додайте до Cargo.toml

[profile.release]
opt-level = 'z'     # Optimize for size.
lto = true          # Enable Link Time Optimization
codegen-units = 1   # Reduce number of codegen units to increase optimizations.
panic = 'abort'     # Abort on panic

3. Побудувати в режимі випуску за допомогою cargo build --release
4. Виконати stripна отриманому бінарному.

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

Ви також #![no_std]можете видалити іржі libstd. Детальніше min-sized-rustдив.

Це особливість, а не помилка!

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

Гей, це вже не 1978 рік - багато людей мають більше 2 Мб оперативної пам’яті на своїх комп’ютерах :-)