The combination of using gc.collect() and cache

[bakerwy]

From question #157

While using a complex vectorized model, memory usage was so large that I could only use a small number of model points, which caused significant slowdowns in model runs. The advantage of vectorization is performing large-scale operations at once, but I wasn't able to take full advantage of it. According to our tests, we need to handle about 2,000 model points at a time to be competitive compared to compiled languages.

Upon investigating the cause of the high memory usage, I realized that NumPy consumes a significant amount of memory compared to the size of the cached variables. (For example, 75% of the memory is used by NumPy and 25% by cached in exported model).

Modelx's export function explicitly uses caching. Therefore, I thought that if there were a way to use gc.collect for everything except the rest of the cached information in exported, it could solve the memory issue.

Here are the ideas I propose:

When there is a very large computation like BEL, split the calculation into intermediate steps. For example, BEL_sub1.
After calculating BEL_sub1, keep the cached function in exported, and use gc.collect to free up memory for the remainings.

(Currently, it seems impossible because gc.collect can be used in export, the entire class is removed).

Perform subsequent calculations for BEL using the cached information.

If there's any way to do this currently, it would be great to know.
Even if it becomes possible later, I believe this approach could dramatically reduce memory issues.

Thanks.

[fumitoh]

I think a similar idea has benn implemented already. Here's a post on this: https://modelx.io/blog/2022/03/26/running-model-while-saving-memory/

[bakerwy]

Thanks fumito, this one can be used with exported model?

[fumitoh]

No. To fine-tune the timing of memory release with exported models, you would need to control garbage collection manually.
For example,

import gc  # import the standard library for garbage collection
from BasicTerm_ME_nomx import BasicTerm_ME as m

gc.disable()   # disable gc so that you can manually trigger garbage collection

m.Projection.pv_claims()
gc.collect()   # manually collect garbage

m.Projection.pv_premiums()
gc.collect()   # manually collect garbage

m.Projection.pv_net_cf()

gc.enable()   # re-enable gc

[bakerwy]

Thanks for your reply! I will consider your suggestions

[AB-Athene]

@bakerwy, do you use generate_actions / execute_actions to save RAM?

[bakerwy]

I tried. but it is slower in complex model. Instead of using generate_actions, execute_actions, I used following strategy

1. When memory is full. Saved cached values by pickled file. and deleted model and gc.collection for the memory clear

2. Read spaces again and import saved pickle file and continues calculating values afterwards

it took only 1 or 2 seconds for the step one and two. I think it is not ideal but anyway it reduced some memory issue