garbage-collector | Garbage collector implementation in Rust for Rust | Wrapper library

Can anyone explain why XX:G1HeapRegionSize must be power of 2 ?

Simply because that is how Oracle has implemented the G1 collector.

When implementing something like a garbage collector, you need to make design choices in order for it to work. There are probably a number of detailed reasons why the G1 designers made these particular choices. The general themes will be to optimize performance in critical G1 code paths (e.g. the write barriers) and/or to avoid unnecessary complexity in the G1 code base as a whole.

(For example, if the size of a region is a power of two, and if each one starts on an address that is divisible by the region size, then you can use masking to efficiently compute which region an address belongs in. If you can save some instructions in the write barrier code, that could mean a couple of percentage points of performance for the entire JVM. I won't go into more detail ... but you can look up the literature.)

But the reasons are moot. You either live with the G1 restriction, or you select a different garbage collector that is better for your use-case.

Is there any problem in setting 10m heap region for -Xmx12g ?

Well ... it won't work ... because of the restriction that you have already found.

The deinit is intended to release resources (such as freeing memory that is not under ARC).

(Thanks to Martin and Rob's input, we can conclude below)

Usually, when last strong-reference gets out of scope, deinit is called instantly (then deallocation happens).

• But if affected by autorelease feature, deinit is called significantly later, long after last reference gets out of scope (when autorelease pool is drained).
• And when App is terminating, deinit is guaranteed to never get called!? (if deinit was not already called).
• Also in extremely common cases, deinit is called before strong-ref-variable's scope ends:

  • In Swift unlike other languages, when we set a weak-reference equal to a strong-reference, it could result to nil (which is absolutely allowed by Swift).

  • This happens if compiler detects that the remaining lines of scope, have NOT any strong-reference.

  • Possible workaround is using withExtendedLifetime(_:_:) global-method, like:

If you want to make sure every single Visio COM object is dead before exiting, you could try this (on unload for example, i.e. in the ThisAddIn_Shutdown, twice to make sure all generations are killed).

Compile-time garbage collection is commonly defined as follows:

A complementary form of automatic memory management is compile-time memory management (CTGC), where the decisions for memory management are taken at compile-time instead of at run-time. The compiler determines the life-time of the variables that are created during the execution of the program, and thus also the memory that will be associated with these variables. Whenever the compiler can guarantee that a variable, or more precisely, parts of the memory resources that this variable points to at run-time, will never ever be accessed beyond a certain program instruction, then the compiler can add instructions to deallocate these resources at that particular instruction without compromising the correctness of the resulting code.

(From Compile-Time Garbage Collection for the Declarative Language Mercury by Nancy Mazur)

Rust handles memory by using a concept of ownership and borrow checking. Ownership and move semantics describe which variable owns a value. Borrowing describes which references are allowed to access a value. These two concepts allow the compiler to "drop" the value when it is no longer accessible, causing the program to call the dtop method from the Drop trait).

However, the compiler itself doesn't handle dynamically allocated memory at all. It only handles drop checking (figuring out when to call drop) and inserting the .drop() calls. The drop implementation is responsible for determining what happens at this point, whether that is deallocating some dynamic memory (which is what Box's drop does, for example), or doing anything else. The compiler therefore never really enforces garbage collection, and it doesn't enforce deallocating unused memory. So we can't claim that Rust implements compile-time garbage collection, even if what Rust has is very reminiscent of it.

I guess one way would be via shell substitution. Then you can put whatever calculation you want in there. For example, on my machine, something like this computes half the available memory:

The problem with increasing memory consumption in your code is that you have to delete the handle returned by GetHbitmap by calling DeleteObject, e.g. as explained here: https://stackoverflow.com/a/5827468/1136211

Besides that, in a WPF application you would implement the whole logic in a completely different way.

You would not use bitmap resources in Properties/Resources.resx but instead just add the image files to your Visual Studio project, e.g. in a project folder named "Images". Then set the Build Action of those files Resource as e.g. shown here: https://stackoverflow.com/a/12693661/1136211

On startup, load all those image resources into a list. Then start a DispatcherTimer that cyclically assigns them to the Source property of an Image element.

When I installed libgc on mac, as you did, the files were installed to /usr/local/Cellar/bdw-gc/. Then, when it came time to compile my code I had to run:

I found the solution: I had to set the role kms.keys.encrypterDecrypter to the service account which is used to control Kubernetes cluster in the settings of Yandex.Cloud project catalog.

It's not possible to do what you're trying to do. Even on CPython, the list gc.garbage will by far not contain all objects that are reclaimed, even if you enable debug mode, but only the ones that have been found to be in cycles. That's unlikely to be relevant to anyone except the authors of the cycle-finding logic itself. And on PyPy, the notion of "being in a cycle" is even less relevant; as you have probably understood already from the various links you point to, PyPy's GC is quite different.

No, there is no way to inspect all objects that are dying. In fact PyPy's GC is optimized for objects that die young, and for all of these (which are typically 80%-90% of all objects in a program) then the structure of the GC is such that there is no way to even know what the dying objects are. These 80%-90% of objects occupy space that is reclaimed in bulk, not one by one.

In all likelihood, you're looking at your problem from the wrong end. If you can describe a bit more what your problem is, we can try to come up with better solutions. In the meantime, note that you can run pypy -X faulthandler to get at least some kind of traceback when you get a segfault.