garbage-collection | SSM-based garbage sorting and recycling platform

See this page about configuring garbage collection. It provides examples of how to set and update garbage-collection policies when you use Cloud Bigtable client libraries or the cbt command-line tool.

The answer to your question is that you can view garbage collection policies of certain tables by running this cbt command:

You can use cache.modify for nested object.

You can add a custom colorbar with cm.ScalarMappable

Yes, it is possible to have concurrent DisposeAsync calls. It is also possible to have concurrent Dispose calls. Technically, implementations are supposed to handle this properly, but in real-world code, it's very rare to have concurrent Dispose or DisposeAsync calls, so most implementations do not handle this correctly.

If this is a source of concern, I recommend using my Disposables library, which ensures exactly-once semantics on disposal. However, it is written from the assumption that types want to implement IAsyncDisposable or IDisposable, and not both.

I am posting my understanding hope it helps, Background understanding: Simple way to understand this is to take an example of a Tomcat or any such application. Which is java based. Tomcat can run multiple webapps. Even if you deploy same application with different name they will be treated differently. Here these both applications will have same classes but still they are treated differently. So here comes the class loaders. So you can think in a way like Tomcat is creating a class loader for each application and loading them under it.

Reclaiming of loaders: above if Tomcat is holding reference to the loader object then the loader object will not be reclaimed. And unless loader gets garbage collected the classes loaded by it stays. So if you shutdown an application, Tomcat will ultimately drefrence it's respective loader so that gc can reclaim it an clean it including the classed loaded by it.

Quick links that may help: https://stackoverflow.com/questions/2433261/when-and-how-are-classes-garbage-collected-in-java#:~:text=A%20class%20in%20Java%20can,that%20class%20are%20still%20reachable.

https://www.dynatrace.com/resources/ebooks/javabook/class-loader-issues/#:~:text=Classloader%20Cannot%20Be%20Garbage-Collected,hold%20references%20to%20their%20classes.

You first need to read the garbage collection handbook.

You later need to document, in written English, the conventions and invariants of your garbage collector. Is it a generational GC? Is it multi-thread friendly? Is it precise or conservative?

The book by C.Queinnec Lisp In Small Pieces is helpful. It describes how to code various Lisp interpreters, and some Lisp to C compiler. Some chapters are related to garbage collection and their relation to generated C code.

The Dragon book (about compilation) has a chapter on GC.

A.Appel's book Compiling with Continuations is also helpful.

You then could document and probably define macros implementing your GC conventions.

Notice that malloc could be considered as a slow way of allocating garbage collected data. Read for example Appel's old paper Garbage Collection can be faster than Stack allocation (it was debated later, but it does give a good intuition). You could consider fetching large memory zones with mmap(2) and allocating inside them in some faster way. Then you won't free individual garbage values (if you adopt a copying GC strategy, using Cheney's algorithm), but will munmap(2) a large memory zone at once. Study also the C source code of malloc implementation inside GNU libc or musl libc.

See my Bismon project as an example of C code (open source, for Linux) with GC.

Look also inside the C code of Ocaml interpreter and compiler.

Or inside the C runtime of SBCL or of Chicken/Scheme.

Or inside the code of some open source JVM.

The Bigloo project is a Lisp to C compiler.

The GNU emacs editor contains a garbage collector. The GCC compiler also contains one.

Circular references are difficult to handle with reference counting schemes.

Consider also using Boehm conservative garbage collector open source library.

Your GC will be operating system specific, and probably target processor specific.

The RefPerSys project (in C++, with generation of C++ code at runtime) has a GC.

At last, the valgrind utility (a tool to detect memory leaks) is open source and can be considered as containing some GC.

Read also recent papers submitted to ACM SIGPLAN conferences. Several of them are related to garbage collection. Consider later submitting your own paper on GC.

PS. As an introduction, read the old paper by P.Wilson Uniprocessor Garbage Collection Techniques

I think the interviewer wanted to hear about String Intern Pool also as known as LargeHeapHandleTable.

One of the mistake is to assume that interned string is located in String Intern Pool in LOH.

In reality, an interned string has a hash, which is located in LargeHeapHandleTable, and then it references to Small Object Heap(SOH) or Large Object Heap(LOH).

if an interned string more than 85kb the string will be located in LOH, in other cases it will be in 2 generation in SOH and would be stored until the application has finished.

[The example of interned string] https://i.stack.imgur.com/fD0WR.png

It is described in chapter 4 Pro .Net Memory Management by Kondrad Kokosa

This isn't really a case of a memory leak. You're just indescrimely loading data off the table which will exhaust the available memory.

The solution is to load the data off the database in batches:

Okay, so I did some more research, and it turns out that the garbage collector does not call the finalizers synchronously. It does the following:

1. Freezes all running threads.
2. Adds items that need finalization to the finalizer queue.
3. Performs garbage collection on eligible objects (objects with no finalizers or with finalizers already called.)
4. Thaws the threads that it froze.

After that, the finalizer thread starts running in the background along with the rest of the application, and calls the finalizers of each object in its queue. This is where the issue I described arises. The Person objects in the heap have their references moved into the finalization queue, but their memory is not freed up until the finalization actually happens. The finalization takes place while the application is running (and more objects are created on the heap).

The garbage collector cannot reclaim the memory until finalization is over, thus, a race condition arises between the Main Thread (creating the objects) and the GC Finalizer Thread (calling the finalizers).

I have also confirmed this behaviour by debugging the IL code and seeing the execution switch between the two threads described above.

I have also found this question on SO which describes the same behaviour.