Know how much memory is in use by program?

[Sim085]

Is there a way how to know how much memory is currently being used by a program at some points during the execution of a program?

For example:

call_function_1();
print_memory_in_use();
call_function_2();
print_memory_in_use();
call_function_3();
print_memory_in_use();

[Thomas Richter]

The short answer is no. The problem is really that "being used by a program" is not well-defined, mostly because AmigaOs has no such concept as "memory used by a program". There is only "memory used".

C programs may use the standard C library for memory allocation via malloc(), and potentially, there is a vendor-specific function to find out how large the heap is. Unfortunately, the C language does not specify such a function, but maybe there is a vendor-specific extension that provides that function.

For AmigaOs, there is, as said, no such function since it is not so uncommon that memory allocated by your program is released by some other program, or vice versa, so one cannot really account memory to a particular program.

As an approximation, you may call AvailMem() before your program runs, and then while it runs, and compute the difference. However, that is only an approximation as other programs may have allocated and released memory in between, and memory may have been allocated as side effect of your program operation that may be eventually released, though not by your program.

Consider, for example, your program prints something on the console. This "something" needs to be put somewhere in case the console window is reprinted or resized, and hence needs to be stored. Thus, just "printing" may allocate memory, and this memory is probably only released after the console window is closed, or cleared.

[Karlos]

If it's your program, as in you are writing it, you could just declare your own allocation and deallocation wrappers that keeps track of the amount allocated. This only works with memory managed via your wrappers but implemented properly it's not a bad approximation.

[Sim085]

Originally Posted by Thomas Richter

The short answer is no...

Thought so as I could not find much when searching for a solution.

Originally Posted by Karlos

If it's your program, as in you are writing it, you could just declare your own allocation and deallocation wrappers that keeps track of the amount allocated. This only works with memory managed via your wrappers but implemented properly it's not a bad approximation.

I think in my current case this would work. I am only using malloc/free and that is the memory I want to keep track of, i.e - to ensure that all memory allocation is getting freed at specific points.

In summary, all looks fine, all is working fine, but trying to make sure there is no memory leak lurking somewhere.

Not sure if anyone has any other ideas?

[Thomas Richter]

For memory leak checking, you can try this program:

http://aminet.net/dev/debug/MemLog.lha

Note, however, that due to the above complications, it may not be perfectly accurate. There are some usage instructions in the archive.

[Sim085]

Originally Posted by Thomas Richter

For memory leak checking, you can try this program:

http://aminet.net/dev/debug/MemLog.lha

Note, however, that due to the above complications, it may not be perfectly accurate. There are some usage instructions in the archive.

Thank you for this. Will go through it

[tygre]

Hi Sim085!

I highly recommend using fortify: it very simple to use and it will detect many memory issues (overwrite, underwrite, multiple frees, etc.) *and* it will tell you exactly how much memory was allocated, even the largest allocations, etc.

Cheers!

[Sim085]

Originally Posted by tygre

Hi Sim085!

I highly recommend using fortify: it very simple to use and it will detect many memory issues (overwrite, underwrite, multiple frees, etc.) *and* it will tell you exactly how much memory was allocated, even the largest allocations, etc.

Cheers!

Thank you Will look into this.