Dlaczego pliki wykonywalne Rusta są tak ogromne?

Po znalezieniu Rusta i przeczytaniu dwóch pierwszych rozdziałów dokumentacji uważam, że podejście i sposób, w jaki zdefiniowali język, są szczególnie interesujące. Postanowiłem więc zmoczyć palce i zacząłem od Hello world ...

Zrobiłem to na Windows 7 x64, przy okazji.

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

Wydając cargo buildi patrząc na wynik w targets\debug, znalazłem wynikowy .exe3 MB. Po kilku poszukiwaniach (dokumentacja flag linii poleceń cargo jest trudna do znalezienia ...) znalazłem --releaseopcję i stworzyłem kompilację wydania. Ku mojemu zdziwieniu rozmiar .exe zmniejszył się tylko nieznacznie: 2,99 MB zamiast 3 MB.

Tak więc, wyznając, że jestem nowicjuszem w Rusta i jego ekosystemie, spodziewałem się, że język programowania systemów stworzy coś zwartego.

Czy ktoś może wyjaśnić, do czego Rust kompiluje się, jak to możliwe, że tworzy tak ogromne obrazy z programu 3-liniowego? Czy kompiluje się do maszyny wirtualnej? Czy istnieje polecenie strip, które przegapiłem (informacje o debugowaniu w kompilacji wydania?)? Coś jeszcze, co mogłoby pozwolić zrozumieć, co się dzieje?

Rust używa statycznego linkowania do kompilowania swoich programów, co oznacza, że ​​wszystkie biblioteki wymagane przez nawet najprostszy Hello world!program zostaną wkompilowane w plik wykonywalny. Obejmuje to również środowisko wykonawcze Rust.

Aby zmusić Rusta do dynamicznego łączenia programów, użyj argumentów wiersza poleceń -C prefer-dynamic; spowoduje to znacznie mniejszy rozmiar pliku, ale będzie również wymagać, aby biblioteki Rust (w tym jego środowisko wykonawcze) były dostępne dla programu w czasie wykonywania. Zasadniczo oznacza to, że będziesz musiał je podać, jeśli komputer ich nie ma, zajmując więcej miejsca niż zajmuje oryginalny statycznie połączony program.

Ze względu na przenośność zalecałbym statyczne połączenie bibliotek Rust i środowiska uruchomieniowego w sposób, w jaki miałbyś kiedykolwiek rozprowadzać swoje programy wśród innych.

Nie mam żadnych systemów Windows do wypróbowania, ale w Linuksie statycznie skompilowany świat Rust hello jest w rzeczywistości mniejszy niż odpowiednik C.Jeśli widzisz ogromną różnicę w rozmiarze, prawdopodobnie dzieje się tak dlatego, że łączysz plik wykonywalny Rusta statycznie, a C dynamicznie.

W przypadku łączenia dynamicznego należy wziąć pod uwagę rozmiar wszystkich bibliotek dynamicznych, a nie tylko plików wykonywalnych.

Tak więc, jeśli chcesz porównać jabłka z jabłkami, upewnij się, że oba są dynamiczne lub oba są statyczne. Różne kompilatory będą miały różne wartości domyślne, więc nie możesz po prostu polegać na domyślnych ustawieniach kompilatora, aby uzyskać ten sam wynik.

Jeśli jesteś zainteresowany, oto moje wyniki:

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

Zostały one skompilowane za pomocą gcc (Debian 4.9.2-10) 4.9.2 i rustc 1.0.0-nightly (d17d6e7f1 2015-04-02) (zbudowany 2015-04-03), zarówno z domyślnymi opcjami, jak i -staticdla gcc i -C prefer-dynamicdla rustc.

Miałem dwie wersje świata C hello, ponieważ pomyślałem, że użycie puts()może łączyć się w mniejszej liczbie jednostek kompilacji.

Jeśli chcesz spróbować odtworzyć go w systemie Windows, oto źródła, z których korzystałem:

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!");
}

Należy również pamiętać, że różne ilości informacji debugowania lub różne poziomy optymalizacji również miałyby znaczenie. Ale spodziewam się, że jeśli widzisz ogromną różnicę, jest to spowodowane łączeniem statycznym i dynamicznym.

Podczas kompilacji z Cargo możesz użyć dynamicznego łączenia:

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

Spowoduje to radykalne zmniejszenie rozmiaru pliku binarnego, ponieważ jest on teraz dynamicznie połączony.

Przynajmniej w Linuksie możesz również usunąć plik binarny symboli za pomocą strippolecenia:

strip target/release/<binary>

Spowoduje to zmniejszenie o około połowę rozmiaru większości plików binarnych.

Przegląd wszystkich sposobów zmniejszania rozmiaru pliku binarnego Rusta można znaleźć w min-sized-rustrepozytorium.

Obecne kroki mające na celu zmniejszenie rozmiaru plików binarnych to:

1. Użyj Rust 1.32.0 lub nowszego (który nie obejmuje jemallocdomyślnie)
2. Dodaj następujące elementy do 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. Kompiluj w trybie wydania przy użyciu cargo build --release
4. Uruchom stripwynikowy plik binarny.

Za pomocą nightlyRusta można zrobić więcej , ale zostawię tę informację, min-sized-rustponieważ zmienia się ona w czasie z powodu użycia niestabilnych funkcji.

Możesz także użyć #![no_std]do usunięcia Rdzy libstd. Zobacz min-sized-rustszczegóły.

To jest funkcja, a nie błąd!

Możesz określić wersje biblioteki (w powiązanym z projektem pliku Cargo.toml ) używanej w programie (nawet te niejawne), aby zapewnić zgodność wersji biblioteki. To z drugiej strony wymaga, aby określona biblioteka była statycznie połączona z plikiem wykonywalnym, generując duże obrazy w czasie wykonywania.

Hej, to już nie 1978 - wiele osób ma więcej niż 2 MB RAM w swoich komputerach :-)