NobleExpress

5 ms·

1.
by NobleExpress 2y ago
Probably. But they still write “On a side note, Oracle's ZGC Generational—GenZGC—is not supported in production yet.” GenZGC is supported on OpenJDK 21 onwards [1]. [1]: https://inside.java/2023/11/28/gen
2.
YouTube to start blocking third-party apps that don't show ads(arstechnica.com)
38 points by NobleExpress 2y ago|21 comments
3.
by NobleExpress 2y ago
Ah right. I assumed it was a native image.
4.
by NobleExpress 2y ago
-server is only a thing for HotSpot. They mention that HotSpot works perfectly fine. There is no option of "-server" for Graal native-image. It has "-O{0,1}" though for turning optimizations off and on respectively.
5.
by NobleExpress 2y ago
Interesting. Perhaps you can inspect the disassembly of the function in question when using Graal and HotSpot. It is likely related to that. Another debugging technique we use for heisenbugs is to see if `rr` [1] can reproduce it. If it can
6.
by NobleExpress 3y ago
Honestly, I was never convinced that concentrating all developer effort onto Wayland was the best idea. Wayland seemed like a massive over-correction from X11, where the protocol and core were "simple" in comparison to X11 which d
7.
by NobleExpress 3y ago
Using microbenchmarks to measure allocation performance is a bit misleading. The optimizations that occurred in the microbenchmarks may not actually occur for real-world code. Three branches vs two branches also makes no real difference as
8.
by NobleExpress 3y ago
They're (effectively) the same. Bump allocation is the term in GC literature and is the more general term. Arena allocation can be slightly more nuanced as you can throw an entire arena away after you're done with it (if your prob
9.
by NobleExpress 3y ago
Well page protection is expensive which is why the predominant way to implement concurrent copying/compaction until recently was using read barriers (and still is -- ART seems to be an exception). I will mention that concurrent compact
10.
by NobleExpress 3y ago
MESI cache coherency (and its derivatives) [1] means that you can have exclusive writes to cache if and only if no other core tries to access that data. I would think most if not all microarchitectures have moved to MESI (or equivalent) cac
11.
by NobleExpress 3y ago
> RC is super cheap. Seriously. You can do about several billion of them per second. Right. You bump allocate faster, however. RC is an additional operation to the allocation request. Given naive RC can't move objects, it necessaril
12.
by NobleExpress 3y ago
I will say that you seem to be stating "smearing that over total execution time tends to give better results" without proof as well. I certainly don't think using atomic operations everywhere and converting every pointer read
13.
by NobleExpress 3y ago
I'm aware. Rust isn't a conventional "managed language" which is why I consciously omitted it from the above list. In an increasingly multi-threaded world, you just have to use the synchronized version of RC (aka Arc<
14.
by NobleExpress 3y ago
Thanks for the links!
15.
by NobleExpress 3y ago
Yes and no. LXR is a highly optimized deferred and coalesced reference counting (amongst many other optimizations) GC and it looks nothing like the RC implementations you see in other languages like Python, Nim, Swift, etc. So yes, referenc
16.
by NobleExpress 3y ago
I've always heard of the "Swift elides reference counts" statements but I've never seen it substantiated. I don't claim to be a Swift GC expert by any means, but the impression I get from the two Swift GC papers I&#
17.
by NobleExpress 3y ago
Real time GCs exist such as the IBM Metronome GC. Though I'll be honest and say I haven't heard of many real-time GCs other than the Metronome one. Certainly many new GCs have reduced pause times dramatically but that's ortho
18.
by NobleExpress 3y ago
Certainly interesting, but there are no performance numbers mentioned in the white paper comparing userfaultfd to read barriers. So the actual benefit to switching to userfaultfd is unknown (at least in publically accessible documents -- I&
19.
by NobleExpress 3y ago
Great read. Reminds me of this checklist: https://www.sigplan.org/Resources/EmpiricalEvaluation/ There is a bunch of overlap with what Gernot talks about, but I think it's more general, and certainly useful t
20.
by NobleExpress 4y ago
Hm? G1 is a generational GC? And so is Serial/Parallel. And work on generational ZGC is ongoing [1]. Not sure what you're referring to here. [1]: https://openjdk.org/jeps/439
21.
by NobleExpress 4y ago
Ehh yes and no. Many languages indeed use conservative GCs, but that is because it is significantly easier to implement than precise GCs which require stack maps etc. I don't think it's exactly a question about languages and stati
22.
by NobleExpress 4y ago
Someone ported the G1 collector to JikesRVM [1], a research Java VM. It's not a production case-study of course, but interesting nonetheless. [1]: https://users.cecs.anu.edu.au/~steveb/pubs/papers/g1-vee-
23.
by NobleExpress 4y ago
C# has interior pointers as well and it is a language with a precise, moving garbage collector. The deal with Go is that is has a concurrent mark-sweep collector, so it is non-moving. Given the non-moving collector, it is significantly easi