3 ms·
I'm surprised that the rust binary is 3.5 times bigger. D is already templated to the nth degree, what more is rust doing? On top of that D links in a whole GC
by mhh__ 6y ago
I'm surprised that the rust binary is 3.5 times bigger. D is already templated to the nth degree, what more is rust doing? On top of that D links in a whole GC whereas rust does not?
- nurettin 6y agoRust will generate a lot of guarding code similar to what ada does.
- kibwen 6y agoThe only "guarding code" that I can think of Rust generating would be for bounds checking on array access, which isn't going to be any significant contributor to binary size. When it comes to generated code, I can imagine the panic unwinding code being a noticeable contributor to the size of a Rust binary, but since D has exceptions I imagine the D binaries have comparable code for unwinding.
- nurettin 6y agoYes, it will generate Exception unwinding and bounds checks and godbolt seems to agree. Anything else you can think of? I think D is less strict when optimizing out exception code.
- mhh__ 6y agoException unwinding is not particularly cheap on the compiler although I think it's in the sense that it muddles the CFG and the register allocation rather than inserting huge amounts of code. The LLVM codebase has exceptions turned off for those reasons and binary size (it plays a role at their scale) although its quite hard to compare exceptions Vs error codes or monads for obvious reasons (LLVM's coding standards are rightly or wrongly a C++ sleuths dream with their custom dynamic casts etc.)
- mhh__ 6y agoD also generates significant amounts of said code (unless you turn it off, obviously) One feature D stole from Ada that is an absolutely inexcusable ommision in a modern programming is contract programming. Every time I start a new python script I end up writing helpers for function pre and postconditions because otherwise I can't rely on anything in the language's syntax. Invariant clauses in D (e.g. this integer in my struct must be less than 5 when the struct is in a valid state) are an absolute godsend although they do not aid compiler optimisations despite some people saying otherwise (it could have changed but last time I checked the invariant does not make it's way to LLVM or GCC)
- ponsin 6y agohow is that different than in c/c++ simply adding asserts at the start and end of functions?
- mhh__ 6y agoIt's the same but it's a different switch to turn it on and off. Having separate syntax is also very useful because it's much easier to see through my usual spaghetti to find what the code is actually supposed to do in the abstract (i.e. if the string should be a valid email, check it in the in {} clause rather than in the middle of the function)
- noch 6y ago> One feature D stole from Ada that is an absolutely inexcusable omission in a modern programming is contract programming. Incidentally, Walter Bright considers contracts to be a low value feature of D that he considered removing. [0][1] [0]: https://youtu.be/p22MM1wc7xQ?t=1h34m30s https://youtu.be/p22MM1wc7xQ?t=1h34m30s [1]: https://digitalmars.com/articles/hits.pdf https://digitalmars.com/articles/hits.pdf
- kibwen 6y agoRust, like Go, statically links everything by default, and only uses dynamic linking if you ask it to. Is D using dynamic linking here?
- PudgePacket 6y agoRust is statically linked by default, not sure how D works. Rust still includes some debug features that can give you a stack trace. Size will also depend on the compile options, if LTO was enabled, how much generics were used, how much string printing was used (print is a macro in Rust that generates code at the callsite), etc. Most, if not all, of these can be resolved. See https://github.com/johnthagen/min-sized-rust https://github.com/johnthagen/min-sized-rust for aiming for small binary size. This article shows a 93% size reduction, 2.7m -> 200kb, with some relatively simple modifications https://www.collabora.com/news-and-blog/blog/2020/04/28/reducing-size-rust-gstreamer-plugin/ https://www.collabora.com/news-and-blog/blog/2020/04/28/redu.... Here is someone using Rust for a 3kb demoscene program https://www.codeslow.com/2019/12/tiny-windows-executable-in-rust.html https://www.codeslow.com/2019/12/tiny-windows-executable-in-....
- mhh__ 6y agoD is usually dynamic although I try to be static for the most part. IIRC The runtime is linked statically (or not at all) but Phobos is dynamic by default Rust compiles seem to blow up pretty easily, e.g. I was cleaning out my SSD the other day an I noticed that a rust GUI framework (Iced?) was sat on about 2Gb of dependencies despite being significantly incomplete (but very promising)
- destructionator 6y ago> Phobos is dynamic by default That depends on your distro. The packages from dlang.org all do the static link config out-of-the-box, but some distro packages dynamic link by default instead. Given the size of that file, it looks static linked. It dynamic links libc, pthread, and a couple other OS-level things, but all D libs including druntime, phobos, etc, are statically linked. Might just be difference in dependencies.
- PudgePacket 6y agoOh boy I definitely understand you, in fact I built a Rust CLI tool to solve exactly that ;) https://github.com/tbillington/kondo https://github.com/tbillington/kondo
- cerebellum42 6y agoMost likely largely because of this: >Rust downloaded a lot of crates, but that's probably because the Rust version of the code has more features than mine has. For example, it fetched rpassword, a tool that hides password characters as you type them into a terminal, much like Python's getpass function. That's one of the many things I don't have in my code.