3 ms·
I've always thought it was some kind of grand conspiracy to obfuscate the behaviors of closed source software but for some reason every single Linux distro that
by userbinator 4y ago
I've always thought it was some kind of grand conspiracy to obfuscate the behaviors of closed source software but for some reason every single Linux distro that claims to love freedom has to do this too.
That's quite a stretch, and I'm saying this as someone who probably believes in things others would consider conspiracy theories. Freedom is irrelevant when you already have the source and the binaries and can do whatever you want with them... and the latter applies even if you're analysing closed-source software.
All for a pointless ~1% performance boost.
I can rebut with "All for a pointless waste of a register for something that will only be useful the <1% of the time the code is actually run."
If I wanted to do the same with DWARF I'd need to link some GPL library or write 10,000 lines of byzantine code to figure out which function called the one that's crashing.
Or just learn how to read a memory dump. If your code is somehow crashing so often enough that it becomes such a burden, then I'd say the solution is elsewhere. It's not hard to walk the stack manually.
- kccqzy 4y ago> I can rebut with "All for a pointless waste of a register for something that will only be useful the <1% of the time the code is actually run." When I worked at Google, profiling was done so often that it certainly exceeded 1%. There's something called Google-Wide Profiling[1] but teams often opt into much more frequent profiling of important micro services they deploy. It's not just for identifying crashes, but more for performance optimization. It's liberating to debug performance bottlenecks when you can just pull up a flame graph from half an hour ago and compare that against a flame graph from one week ago without worrying about re-deploying the old version to get profiling data. Btw I think this is somewhat of a cultural bias depending on your previous experience. Some people simply value performance at all costs. Some people value more observability and debugability. [1]: https://research.google/pubs/pub36575/ https://research.google/pubs/pub36575/
- ilyt 4y ago> When I worked at Google, profiling was done so often that it certainly exceeded 1%. So a 10% use case for 0.001% of engineers out there. And I'm pretty sure you didn't run stock Fedora distro on servers either ? If you're that high end that profiling code for few % gains is worth millions you can just compile the stuff with whatever flags and optimization you need instead of relying on distro to reduce performance for everyone to appease to few engineers at big corp
- Annatar 4y ago[dead]
- msm_ 4y agoI have a similar, but different story. When I worked at Google, one rule for C++ code was to always write a namespace prefix (so std::vector<T> instead of vector<T>, to avoid dark corners of the language). One exception was `string` - for some reason it was not `std::string` but just string. I've read more about this inconsistency, and it turned out that at some point libc++ changed something in the string class and it caused a 1% performance regression in "an important google-wide benchmark". That 1% of performance was so important, that since that up to at least few years ago every C++ programmer had to put up with that. I guess it makes some sense - 1% of CPU cost across the whole Google fleet is a lot of saved CPU hours (and that equals money).
- jart 4y agoIt's a question of software consumers versus software developers. Disabling frame pointers basically shivs developers to hand out a 1% gain to the consumer class. Making that tradeoff might make sense for something like Windows, but I would have thought open source would be different. But nope. Tablet first GUI design, opaque binaries, and binary protocols with some misguided dream that normies will convert to the year of the Linux desktop and there shall be one laptop per child.
- viraptor 4y ago> Or just learn how to read a memory dump. This is a skill that is not only hard to learn, but also takes time to apply properly. Yes, I can read a memory dump. But I'd sacrifice more than 1% of performance to not do it manually. And the infra cost to account for that is also lower than the value of my time. Telling basically all devs without such experience to "just" learn an advanced skill is not a good solution.
- microtonal 4y agoAll for a pointless waste of a register for something that will only be useful the <1% of the time the code is actually run. That may be true, but having proper stack traces will probably cumulate to optimizations that gain much more than the 1% loss of enabling frame pointers [1]. Ideally, it would be much easier to rebuild whole Linux systems. Then people who need it could enable frame pointers. Sadly, rebuilding a mainstream Linux distribution is much harder than rebuilding e.g. Gentoo or NixOS. Though, in practice even rebuilding a NixOS system is fraught with issues. I have done large rebuilds, but it would often fail because e.g. unit tests have issues that only manifest themselves with enough build parallelism. [1] Note that on x86_32, the performance improvement was larger due to register pressure.
- getoverit 4y ago[flagged]