freeMemory | Firefox add-on to put memory operation | File Utils library

After a discussion with the OP on the comments (that were removed afterwards), we both came to the conclusion that:

You do not need to reduce the alpha variable, because outside the first parallel region it is initialized again to zero. Instead, make the alpha variable private.

• The largest primitive can hold 8 bytes.

• every Object has at least 12 bytes (with default 64 bit VMs and relatively small heap) of headers. Automatically making it bigger than a primitive.

There is a single good library that I am aware of that does correctly, called jol. here is a related question.

It is rather easy to get jol set-up and run the samples to understand the actual numbers you are interested in.

This example has a simple echo responder that will allow the server to initiate requests back to the client.

https://github.com/rsocket/rsocket-js/blob/c539b3a42d56780011392fc06ebd488d09f929da/packages/rsocket-examples/src/LeaseClientExample.js

From your own reference:

Assuming that reference is correct, I would interpret it as:

The bug is here

From the docs:

All soft references to softly-reachable objects are guaranteed to have been cleared before the virtual machine throws an OutOfMemoryError. Otherwise no constraints are placed upon the time at which a soft reference will be cleared or the order in which a set of such references to different objects will be cleared. Virtual machine implementations are, however, encouraged to bias against clearing recently-created or recently-used soft references.

Thus a sophisticated cache can, for example, prevent its most recently used entries from being discarded by keeping strong referents to those entries, leaving the remaining entries to be discarded at the discretion of the garbage collector.

This is from the JDK 11 java docs. In short, the answer is NO. I guess you could try to do crazy stuff with finalize but I would recommend against it. Your idea of using strong references might be the most viable.

First, str is uninitialized. There's no telling what it points to. You'll need to allocate some space with malloc or something and initialize str with that.

Second, your loop uses sizeof(str). While this is legal even with str uninitialized, it will not give you the length you are looking for. It will give you the size of the pointer, not what it points to. It would probably work better to call strlen(str).

The reason you see these differences is due to the Cloud Console displaying the actual size of the JVM process(which includes stack frames, perm gen space, direct buffers, machine code, etc.) where the memory limit that applies for instances refers to the JVM heap. The runtime uses some heap memory which counted against the total heap usage by the app.

Now, it is important to understand what do these methods do and how to calculate the available memory to allocate:

totalMemory():

All memory currently used by JVM. It's usually lower than maxMemory because JVM allocates memory lazily, "lazily" meaning that some memory is allocated initially and used, and, if a new chunk of memory is needed, another allocation is done, up to all available memory (maxMemory()).

maxMemory():

Maximum available heap memory (instance size is limited to this value).

freeMemory():

Portion of memory currently both allocated by JVM and not used.

The "real total memory" that can be allocated is:

Yes, you have to check that addr parameter must mactch one of the addr value in the allocList elements.