opportunistic memory allocation

Nobody has claimed this yet.

It's hard to detect when we run out of memory!

See https://stackoverflow.com/questions/11779042/sigkill-while-allocating-memory-in-c
for an explanation of "opportunistic memory allocation" and how to disable it under Linux
with ` echo 2 > /proc/sys/vm/overcommit_memory `

The experiment below shows that with opportunistic memory allocation, the process
just gets killed with signal 9 (SIGKILL) when it runs out of memory, both
under Linux (64 bit) and under Mac OS X (64 bit). But under Debian (32 bit),
memory allocation is not opportunistic by default, and a null pointer is returned when
memory is exhausted.

Notice that when a process gets killed, there is no explanation for the user about why it got killed.
What we want to achieve is to give an error message : "out of memory".

```c
// run with gcc foo.c -o foo && ( ./foo ; echo $? )

#include
#include
#include
int main () {
int n = 0;
while (1) {
size_t size = 100000000L;
char *p = (char *)malloc(size);
// char *p = new char[size];
/* char *p = (char *)sbrk(size); */
n++;
printf("%4d: %p\n",n,p);
if (0 == p) exit(2);
if (-1 == p) exit(3);
memset(p,0,size);
}
return 0;
}
```

The issue names no repository files or tests; begin by reproducing the provided foo.c experiment with gcc on the stated Linux and macOS environments, then locate the project's memory-allocation entry point. Done means allocation exhaustion produces an "out of memory" error rather than an unexplained SIGKILL.

Written by the indexing model from the issue text.