Deal with OOM conditions

Imagine the following sci-fi scenario: your code is in the middle of aborting a nuclear missiles launch fired by mistake, it needs to allocate some memory and unfortunately the BOFH is using all the physical and virtual memory because, he just can.

What shall we do?

The life of thousand people depends on that function you need to call, passing to it some fresh allocated memory. The operator new (unless the placement one is called) deals with OOM condition throwing a bad_alloc or returning a null-pointer in case the nothrow version of it is used.

But as programmer what can you do when a bad_alloc is thrown or a null-pointer is returned?

There are several options, but the most "nifty" one is the following.

When the operator new is not able to allocate the required memory it calls a function, at this point the function can try to free some memory, throwing an exception or exit the program. Exiting the program is not a good option I have to say, indeed the caller of the operator new (or operator new [] for the matter) expects a bad_alloc (or a derivation of it) or a nullptr (in case the nothrow was used).

A programmer is able to specify the function to be call in case of OOM with the following function:

new_handler set_new_handler (new_handler new_p) noexcept;

view raw set_new_handler hosted with ❤ by GitHub

the operator new will keep calling the specified function every time it tries to allocate memory and it doesn't succeeded. A programmer can exploit this mechanism in the following way:

1. Allocate a the programming startup a bunch of memory reserving it for future uses.
2. Install the new handler that will free the reserved memory, in case the reserved memory was already release then throw bad_alloc. 

The following code does exactly what described:

	#include <iostream>
	class ReservedMemory {
	public:
	ReservedMemory()
	: theMemoryReserved(new char[80000*1024])
	{}
	~ReservedMemory() { delete []theMemoryReserved; }
	void release() {
	if (theMemoryReserved) {
	std::cout << "FREEING SOME MEMORY" << std::endl;
	delete []theMemoryReserved;
	theMemoryReserved = nullptr;
	} else {
	std::cout << "NO MORE MEMORY TO FREE" << std::endl;
	throw std::bad_alloc();
	}
	}
	private:
	const char* theMemoryReserved;
	};
	ReservedMemory rm;
	int main(int argc, char** argv) {
	std::set_new_handler([](){ rm.release(); });
	char * ptr = new char[50000*1024];
	std::cout << "SUCCEEDED" << std::endl;
	char * ptra = new char[50000*1024];
	}

view raw ExampleNewHanlder hosted with ❤ by GitHub

issuing a ulimit -v 100000 before to run it (in order to decrease the memory that can be used), the output is the following:

FREEING SOME MEMORY

SUCCEEDED

NO MORE MEMORY TO FREE

terminate called after throwing an instance of 'std::bad_alloc'

  what():  std::bad_alloc

Aborted (core dumped)

As you can see at least once we were able to free some memory and the first allocation after the OOM condition was able to allocate memory due the fact some was freed by us, unfortunately there were no more space on the second call. You have no excuse anymore to have a crash due to OOM condition, what you can do at least is to free the memory, launch a warning, writing in the logs, send a message to a pager or whatever action that soon the memory will be over for real!