News for hackers. Stuff that matters.

A comment on Zig self hosted compiler is now capable of building itself. Parent comment

Re:Zig self hosted compiler is now capable of building itself by elcritch on Saturday April 16, 2022 @05:33PM (#31056284)
Sort of left it to the readers and hopefully encourage people to investigate for themselves. It's far too easy to get into "this benchmark vs this benchmark", etc. Memory usage is overall a complicated topic, which I think Andrew's comment doesn't do justice to. Granted the Zig team has done some impressive work, much of the memory usage & bloat in the C++ world comes from real world programs and libraries and the inevitable drift in program architecture over time.

However, I could believe Zig's stdlib and culture encourages low memory footprints, but there isn't anything novel in the language that makes it inherently lower memory footprint. Though to name a few languages I'd say that can be directly comparable are Rust, D (esp. BetterC mode), and Nim. Even Julia & Go in the right context. Though honestly I often prefer wasting a few hundred bytes of RAM here and there, even on a microcontroller, for pure convenience.

edit: forgot Odin. Another comment mentioned it, though I've never used it. It looks like it's used in production.

[ Parent | on HN ]
Re:Zig self hosted compiler is now capable of building itself by dralley on Saturday April 16, 2022 @11:11PM (#31058117)
Zig has a few extra tricks up their sleeves compared to most languages. The ones that come to mind are

* MultiArrayList

* arbitrary size-integers that make it easy to pack data very tightly

* easy access to several special purpose allocators which reduce the need for strategies like reference counting

[ Parent | on HN ]
Re:Zig self hosted compiler is now capable of building itself by elcritch on Sunday April 17, 2022 @03:26AM (#31059159)
Perhaps, though nothing there that's not been available for a while. To be fair Zig has integrated some of these features well.

* MultiArrayList is convenient and easy to do in Rust, D, Nim. Odin seems built around it. * Arbitrary bit-size integers seem more gimmicky than anything and similar to struct bitfields in other languages (except Rust oddly). Most compilers don't even pack uint8/uint16's for performance reasons. * Special purpose allocators are a bit more interesting. Still they don't provide actual memory safety AFAICT and can have fragmentation and performance penalties.

It'll be interesting to see larger Zig code bases emerge in different fields and see how the memory footprint compares in practice.

[ Parent | on HN ]
Re:Zig self hosted compiler is now capable of building itself by bonzini on Sunday April 17, 2022 @03:44AM (#31059244)
What? 8- and 16-bit are never 32-bit aligned nor sized.
[ Parent | on HN ]
Re:Zig self hosted compiler is now capable of building itself by elcritch on Sunday April 17, 2022 @06:16AM (#31059815)
To clarify I meant comparing how int8/int16's are packed in structs vs struct bitfields. Can't recall about the stack rules. Here's more discussion:

http://www.catb.org/esr/structure-packing/

https://github.com/Twon/Alignment/blob/master/docs/alignment...

Also ARM for example doesn't have 8/16 bit registers so int8 or int16 will use a 32bit register:

https://stackoverflow.com/a/23716920

Curiosity got to me, perhaps Zig had improved significantly. So I compared the first benchmark I found (kostya/benchmarks/bf) with Zig with Nim. For the smaller input (bench.b) Zig did run with ~22% less RAM (about 20kB less).

However, for the larger input (mandel.b) Nim+ARC used ~33% less RAM in safe mode: Nim 2.163mb -d:release; Zig 2.884mb -O ReleaseSafe; Zig 2.687mb -O ReleaseFast. The Nim requires 0.5mb less ram and the code is ~40% shorter. I don't have time to try out the Rust or Go versions though.

edit: grammar

[ Parent | on HN ]
Re:Zig self hosted compiler is now capable of building itself by dralley on Sunday April 17, 2022 @02:59PM (#31063287)
Are the two using the exact same algorithm?
[ Parent | on HN ]
Re:Zig self hosted compiler is now capable of building itself by elcritch on Sunday April 17, 2022 @05:33PM (#31064688)
Yes, as far as I can tell [1]. It's a simple Tape algorithm. Neither had any crazy SIMD, threads, no custom containers, etc. They use almost the same function names (and look the same as the Go version too). I used `time -l` https://stackoverflow.com/a/30124747 for memory usage.

Note I ran the benchmarks locally (MacBook Air M1) because the reported benchmark uses the older (default) Nim GC while I only use Nim+ARC. I also had to fix the Zig code and it took a few tries to get the signed/unsigned int conversions working. I tried tweaking flags for both a bit as well to see how stable they were. Zig's memory usage was pretty constant. Nim had a small speed vs memory tradeoff that could be tweak-able, but the defaults used the least memory.

Overall I'd expect exact memory usage by language(s) to vary some by benchmark and one random benchmark isn't conclusive. Still I didn't find anything to indicate Zig is clearly better than other new generation languages. Manual memory management might actually be worse than letting a compiler manage it in some cases.

1: https://github.com/kostya/benchmarks/tree/master/brainfuck

[ Parent | on HN ]
Re:Zig self hosted compiler is now capable of building itself by Tozen on Thursday April 21, 2022 @12:17PM (#31111442)
In that category (of C/C++ alternatives) is also Vlang (https://vlang.io/). It would be closer to Odin, than Julia, Go, or Nim. Although Vlang and Odin have a strong Go influence.
[ Parent | on HN ]
Re:Zig self hosted compiler is now capable of building itself by blippage on Sunday April 17, 2022 @12:50PM (#31062220)
Odin doesn't work on 32-bit ARM, which was a disappointment to me.
[ Parent | on HN ]
Re:Zig self hosted compiler is now capable of building itself by elcritch on Sunday April 17, 2022 @05:33PM (#31064690)
Bummer, looks like an intriguing language.
[ Parent | on HN ]