动态分配在堆中的随机位置存储数据？

Question

I know that local variables will be stored on the stack orderly.

but, when i dynamically allocate variable in the heap memory in c++ like this.

int * a = new int{1};
int * a2 = new int{2};
int * a3 = new int{3};
int * a4 = new int{4};

Question 1 : are these variable stored in contiguous memory location? Question 2 : if not, is it because dynamic allocation store variables in random location in the heap memory? Question3 : so does dynamic allocation increase possibility of cache miss and has low spatial locality?

Answer 1

Part 1: Are separate allocations contiguous?

The answer is probably not . How dynamic allocation occurs is implementation dependent. If you allocate memory like in the above example, two separate allocations might be contiguous, but there is no guarantee of this happening (and it should never be relied on to occur).

Different implementations of c++ use different algorithms for deciding how memory is allocated.

Part 2: Is allocation random?

Somewhat; but not entirely. Memory doesn't get allocated in an intentionally random fashion. Oftentimes memory allocators will try to allocate blocks of memory near each other in order to minimize page faults and cache misses, but it's not always possible to do so.

Allocation happens in two stages:

1. The allocator asks for a large chunk of memory from the OS
2. The takes pieces of that large chunk and returns them whenever you call new, until you ask for more memory than it has to give, in which case it asks for another large chunk from the OS.

This second stage is where an implementation can make attempts to give things you memory that's near other recent allocations, however it has little control over the first stage (and the OS usually just provides whatever memory is available, without any knowledge of other allocations by your program).

Part 3: avoiding cache misses

If cache misses are a bottleneck in your code,

• Try to reduce the amount of indirection (by having arrays store objects by value, rather than by pointer);
• Ensure that the memory you're operating on is as contiguous as the design permits (so use a std::array or std::vector, instead of a linked list, and prefer a few big allocations to lots of small ones); and
• Try to design the algorithm so that it has to jump around in memory as little as possible.

A good general principle is to just use a std::vector of objects, unless you have a good reason to use something fancier. Because they have better cache locality, std::vector is faster at inserting and deleting elements than std::list, even up to dozens or even hundreds of elements.

Finally: try to take advantage of the stack. Unless there's a good reason for something to be a pointer, just declare as a variable that lives on the stack. When possible,

• Prefer to use MyClass x{}; instead of MyClass* x = new MyClass{}; , and
• Prefer std::vector<MyClass> instead of std::vector<MyClass*> .

By extension, if you can use static polymorphism (ie, templates), use that instead of dynamic polymorphism.

Answer 2

IMHO this is Operating System specific / C++ standard library implementation.

new ultimately uses lower-level virtual memory allocation services and allocating several pages at once, using system calls like mmap and munmap. The implementation of new could reuse previously freed memory space when relevant. The implementation of new could use various and different strategies for "large" and "small" allocations.

In the example you gave the first new results in a system call for memory allocation (usually several pages), the allocated memory could be large enough so that subsequent new calls results in contiguous allocation..But this depends on the implementation

Answer 3

In short:

1. not at all (there is padding due to alignment, heap housekeeping data, allocated chunks may be reused, etc.),

2. not at all (AFAIK, heap algorithms are deterministic without any randomness),

3. generally yes (eg, memory pooling might help here).