Home/ Questions/Q 4081980
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-20T18:07:49+00:00

This is in C++ on CentOS 64bit using G++ 4.1.2. We’re writing a test

  • 0

This is in C++ on CentOS 64bit using G++ 4.1.2.

We’re writing a test application to load up the memory usage on a system by n Gigabytes. The idea being that the overall system load gets monitored through SNMP etc. So this is just a way of exercising the monitoring.

What we’ve seen however is that simply doing:

char* p = new char[1000000000];

doesn’t affect the memory used as shown in either top or free -m

The memory allocation only seems to become “real” once the memory is written to:

memcpy(p, 'a', 1000000000);   //shows an increase in mem usage of 1GB

But we have to write to all of the memory, simply writing to the first element does not show an increase in the used memory:

p[0] = 'a';    //does not show an increase of 1GB.

Is this normal, has the memory actually been allocated fully? I’m not sure if it’s the tools we are using (top and free -m) that are displaying incorrect values or whether there is something clever going on in the compiler or in the runtime and/or kernel.

This behavior is seen even in a debug build with optimizations turned off.

It was my understanding that a new[] allocated the memory immediately. Does the C++ runtime delay this actual allocation until later on when it is accessed. In that case can an out of memory exception be deferred until well after the actual allocation of the memory until the memory is accessed?

As it is it is not a problem for us, but it would be nice to know why this is occurring the way it is!

Cheers!

Edit:

I don’t want to know about how we should be using Vectors, this isn’t OO / C++ / the current way of doing things etc etc. I just want to know why this is happening the way it is, rather than have suggestions for alternative ways of trying it.

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    Please look up for overcommit. Linux by default doesn’t reserve memory until it is accessed. And if you end up by needing more memory than available, you don’t get an error but a random process is killed. You can control this behavior with /proc/sys/vm/*.

    IMO, overcommit should be a per process setting, not a global one. And the default should be no overcommit.

    • 0