smaps | Analyze memory statistics in use of /proc/ pid /smaps | Analytics library

(gdb) dump memory ./dump_outputfile.dump 0x02511000 0x2e2548000

are you sure about the addresses ?

the area you want to dump is about 11Go !

is that too much for gdb ? try with a smaller size

of course check you have enough free disk space for the result

ASAN works by reserving one byte (known as a shadow byte) per 8 bytes of user memory. The shadow bytes are checked on every memory access and updated on every change in allocation status.

Processes running on Linux on x86_64 have about 2^47 bytes of addressable space available, so ASAN maps around 2^47*1/9 ~= 15TB for these shadow bytes.

This is the mapping you're seeing.

Java needs a lot a memory. JVM itself needs a lot of memory to run. The heap is the memory which is available inside the virtual machine, available to your application. Because JVM is a big bundle packed with all goodies possible it takes a lot of memory just to load.

Starting with java 9 you have something called project Jigsaw, which might reduce the memory used when you start a java app(along with start time). Project jigsaw and a new module system were not necessarily created to reduce the necessary memory, but if it's important you can give a try.

You can take a look at this example: https://steveperkins.com/using-java-9-modularization-to-ship-zero-dependency-native-apps/. By using the module system it resulted in CLI application of 21MB(with JRE embeded). JRE takes more than 200mb. That should translate to less allocated memory when the application is up(a lot of unused JRE classes will no longer be loaded).

Here is another nice tutorial: https://www.baeldung.com/project-jigsaw-java-modularity

If you don't want to spend time with this you can simply get allocate more memory. Sometimes it's the best.

GC does kill unused objects and frees memory for the Ruby process, but the Ruby process never releases this memory to OS. But this is not the same as a memory leak (because under normal circumstances at some point Ruby process has enough memory allocated and doesn't grow any more - very roughly speaking). Memory leaks happen when GC cannot release memory (due to bugs, bad code, etc) and Ruby process has to borrow more and more memory.

This is not the case with your code - it does not contain memory leaks, but it does contain an efficiency problem.

What happens when you do 100.times { /#{STR}/i } is that you

1. Create 100 very long strings (when interpolating the constant within the pattern literal)...

2. ... and then create 100 regexp from these strings.

All this requires unnecessary allocations making Ruby process use more memory (and degrading performance too - GC is quite expensive). Changing the class definition into

The definitive reference in these matters is POSIX, which in its rationale section for mmap has to say:

The mmap() function can be used to map a region of memory that is larger than the current size of the object. [... snip discussion on sending SIGBUS if possible, i.e. when accessing a page beyond the end of the file ...] written data may be lost and read data may not reflect actual data in the object.

So, POSIX says that doing this can result in lost data. Also, the portability is questionable at best (think about no-MMU systems, the interaction with hugepages, platforms with different pagesizes...)

Thanks @Amadan and @pitseeker, I checked the pstree of the parent process, and find that the strange process maybe the shellinabox process which in the docker container, Since I also run the shellinabox docker container.

It depends on what you are doing in the function. As long as you don't try to modify what test is pointing to, there is no problem. To indicate that it can't be changed, it is good to add const.

Like this the code is fine:

So I dug a bit deeper and found this tidbit about boost.io_service :

io_service.run() completes if it has no work to do - so by running it and then sending more async work to be done, the work was not getting completed.

This stemmed from an issue where someone had flipped the ioservice.run() and async read callback assignment to make to code look better - now there was no work piled up before running and ioservice could just complete it's job and return.

/proc/pid/pagemap can give such information. Documentation is here.