What we discussed:

• Be able to run Julia with a fixed heap size: it means there will be no GC triggered before reaching the fixed heap size, the heap size won't get resized in any way, the heap will never grow larger than the given heap size (the process aborts if out-of-memory). So in this way, you can hold the heap size as a constant, and measure the performance/utilization changes from other factors (such as GC algorithms etc). This is not intended for running workloads in production, but it is generally a very useful way to measure GC performance. This is also useful to determine how much memory you need to run a workload.
• Be able to run Julia GC on every X bytes/KB/MB allocation. The heap size may change and may grow, but it guarantees to trigger GCs frequently based on the application volume. This is useful for some cases. However, overall, this is less important than the fixed heap size option.

It is unclear to me how these two flags would deliver the above behaviors.

it means there will be no GC triggered before reaching the fixed heap size, the heap size won't get resized in any way, the heap will never grow larger than the given heap size (the process aborts if out-of-memory)

--hard-heap-limit seems to be doing precisely this. Could you clarify your comment?

Be able to run Julia GC on every X bytes/KB/MB allocation

Right now, we are letting MemBalancer compute the heap target for the next GC, and if we see that the heap size increment is greater than --upper-bound-for-heap-target-increment, then we cap it.

Should be a fairly easy change to make the heap size increment exactly --upper-bound-for-heap-target-increment, though.

it means there will be no GC triggered before reaching the fixed heap size, the heap size won't get resized in any way, the heap will never grow larger than the given heap size (the process aborts if out-of-memory)

--hard-heap-limit seems to be doing precisely this. Could you clarify your comment?

The heap target is initialized as the default_collect_interval:

And a GC is triggered based on the heap target:

The first GC is triggered by the default_collect_interval rather than the fixed heap size. Did I miss anything?

Be able to run Julia GC on every X bytes/KB/MB allocation

Right now, we are letting MemBalancer compute the heap target for the next GC, and if we see that the heap size increment is greater than --upper-bound-for-heap-target-increment, then we cap it.

Should be a fairly easy change to make the heap size increment exactly --upper-bound-for-heap-target-increment, though.

It is not about heap target, or about resizing. It is an additional way to control the GC triggering. For example, if a workload allocates 10 MB in total and we set the option to 2MB, we expect to see ~5 GCs. If we set the option to 0.1MB, we expect to see ~100 GCs. It is not related with the heap size, or heap resizing.

However, I am not sure if we urgently need this for Julia's stock GC, as we can do so with MMTk, and we can use MMTk to understand a workload's behavior. Maybe @udesou can clarify if he plans to evaluate the stock GC using this feature.

Tried to add some of your suggestions in the last commit (but still need to adjust docstrings and flag names).

The code looks fine. I don’t think ifdefs are needed because it looks like it’s not in any performance sensitive piece of code. I’m still concerned that adding flags just for benchmarking against a target that the GC itself doesn’t really care about but we can remove them in the future