Question

I believe that you can’t force a running Memcached instance to de-allocate memory, short of terminating that Memcached instance (and freeing all of the memory it held). Does anyone know of a definitive piece of documentation, or even a mailing list or blog posting from a reliable source, that can confirm or deny this impression?

As I understand it, a Memcached process initially allocates a chunk of memory (the exact initial allocation size is configurable), and then monotonically increases its memory utilization over its lifetime, limited by the daemon’s maximum memory allocation size (also configurable). At no point does the Memcached daemon ever free any memory, regardless of whether the daemon has any ongoing need for the memory it holds.

I know that this question might sound a little whiny, with a tone of “I DEMAND that open source project X support my specific need!” That’s not it, at all–I’m purely interested in the exact technical answer, here, and I swear I’m not harshing on Memcached. For the curious, this question came out of a discussion about possible methods for gracefully juggling multiple Memcached instances on a single server, given an application where the cost of a cache flush can be quite high.

However, I’d appreciate it if you save your application suggestions/advice for a different question (re-architecting my application, using a different caching implementation, etc.). I do appreciate a good brainstorm, but I think this question will be most valuable if it stays focused on the technical specifics of how Memcached does and does not work. If you don’t have the answer to this specific question, there is probably still value in what you have to say, but I’d guess that there’s a different, better place to post the more speculative comments/suggestions/advice.

Answer 1

This is probably the hardest problem we have to solve for memcached currently (well, a variation of it, anyway).

Freeing a chunk of memory requires us to know that a) nothing within the chunk is in use and b) nothing will start using it while we’re in the process of purging it for reuse/freeing. I’ve heard some really good ideas for how we might solve our slab rebalancing problems which is basically the same, except we’re not trying to free the memory, but to give it to something else (a common problem in a few large installations).

Also, whether free actually reduces the RSS of your process is implementation dependent. In many cases, a malloc/fill/free will leave the memory mapped in (unless your allocator uses mmap instead of sbrk).