Viewing profile — pebal

RC is a GC method and the least efficient one.

The C++ standard has never included a garbage collector. It only provided mechanisms intended to facilitate the implementation of a GC, but they were useless.

This isn't fully concurrent GC. It pauses mutators threads and delegates them to perform some of the work for the GC.

> I haven't seen a C++ programmer carefully opt into GC for a subset of their allocations even though there are GC libraries written for the language. Can you give an example of su…

But that's why Swift generates slower code. Memory is cheap, also for Apple, although Apple would like to hide that fact.

It doesn't matter at all. C4 uses STW.

Azul C4 is not a pauseless GC. In the documentation it says "C4 uses a 4-stage concurrent execution mechanism that eliminates almost all stop-the-world pauses."

There are no production implementations of GC algorithms that don't stop the world at all. I know this because I have some expertise in GC algorithms.

There are none, at least not production grade.

Yes, SGCL is my project. You can't write concurrent code without atomic operations — you need them to ensure memory consistency, and concurrent GCs for Java also rely on them. Howe…

Java currently has no fully concurrent GC, and due to the volume of garbage it manages and the fact that it moves objects, a truly fully concurrent GC for this language is unlikely…

That time may seem negligible, since the OS can context switch threads anyway, but it’s still additional time during which your code isn’t doing its actual work. Generations are us…

First, there are no Java GCs that completely eliminate stop-the-world pauses. ZGC and Shenandoah reduce them to very short, sub-millisecond windows — but they still exist. Even the…

As I mentioned earlier, take a look at the Golang. It's newer than Java, yet it uses a non-moving GC. Are you assuming its creators are intentionally making slower this language?

There isn’t a single truly pause-less GC for Java — and I’ve already proven that to you before. If such a GC exists for any other language, name it. And no, SGCL doesn’t introduce …

Compaction doesn't necessarily guarantee cache friendliness. While it does ensure contiguity, object layout can still be arbitrary. True cache performance often depends on the loca…

It doesn't matter if objects die young — the other objects on the heap are still moved around periodically, which reduces performance. When you're using a moving GC, you also have …

SGCL introduces the `tracked_ptr` smart pointer, which is used similarly to `shared_ptr`. The collector doesn't move data, which makes it highly efficient and — perhaps surprisingl…

C++ isn't hostile toward garbage collection — it's more the programmers using C++ who are . C++ is the only language that can have an optional, totally pause-less, concurrent GC en…

If you have a moving, generational GC, then all the benefits of fast allocation are lost due to data moving and costly memory barriers.

You can't call GC pauseless if it introduces pauses. We don't say something is free if you have to pay little for it. We say it's cheap.

This is some weird way of counting. A system pause plus a GC pause is two pauses. Just because one pause can't be avoided doesn't mean you can introduce more pauses.

Please don't write pauseless if there are short pauses. Pauseless in the Java GC context is a marketing scam.

Here you have a GC engine that is completely pauseless: https://github.com/pebal/sgcl It is available as a C++ library, so you can easily compare its performance to the reference c…

The reference counting also causes pauses when freeing large object graphs. Fully concurrent GC does not cause any pauses and it's more efficient. It also has less memory overhead …