Allocating a large memory block in C++

by

You forgot one dimension, and the overhead of allocating memory. The shown code allocates memory very inefficiently in the third dimension, resulting in way too much overhead.

float*** a = new float**[N];

This will allocate, roughly 22000 * sizeof(float **), which is rougly 176kb. Negligible.

a[m] = new float*[M - 1];

A single allocation here will be for 44099 * sizeof(float *), but you will grab 22000 of these. 22000 * 44099 * sizeof(float *), or roughly 7.7gb of additional memory. This is where you stopped counting, but your code isn’t done yet. It’s got a long ways to go.

a[m][n] = new float[2];

This is a single allocation of 8 bytes, but this allocation will be done 22000 * 44099 times. That’s another 7.7gb flushed down the drain. You’re now over 15 gigs of application-required memory, roughly, that needs to be allocated.

But each allocation does not come free, and new float[2] requires more than 8 bytes. Each individually allocated block must be tracked internally by your C++ library, so that it can be recycled by delete. The most simplistic link-list based implementation of heap allocation requires one forward pointer, one backward pointer, and the count of how many bytes are there in the allocated block. Assuming nothing needs to be padded for alignment purposes, this is at least 24 bytes of overhead per allocation, on a 64-bit platform.

Now, since your third dimension makes 22000 * 44099 allocations, 22000 allocations for the second dimension, and one allocation for the first dimension: if I count on my fingers, this will require (22000 * 44099 + 22000 + 1) * 24, or another 22 gigabytes of memory, just to consume the overhead of the most simple, basic memory allocation scheme.

We’re now up to about 38 gigabytes of RAM needed using the most simple, possible, heap allocation tracking, if I did my math right. Your C++ implementation is likely to use a slightly more sophisticated heap allocation logic, with larger overhead.

Get rid of the new float[2]. Compute your matrix’s size, and new a single 7.7gb chunk, then calculate where the rest of your pointers should be pointing to. Also, allocate a single chunk of memory for the second dimension of your matrix, and compute the pointers for the first dimension.

Your allocation code should execute exactly three new statements. One for the first dimension pointer, One for the second dimension pointers. And one more for the huge chunk of data that comprises your third dimension.

More Related Contents:

  1. Dynamic memory allocation in game server [closed]
  2. How do malloc() and free() work?
  3. What is the difference between new/delete and malloc/free?
  4. Is delete[] equal to delete?
  5. C++ new int[0] — will it allocate memory?
  6. Why is my program slow when looping over exactly 8192 elements?
  7. How could pairing new[] with delete possibly lead to memory leak only?
  8. Compelling examples of custom C++ allocators?
  9. How to get available memory C++/g++?
  10. Will new return NULL in any case?
  11. How does a C++ reference look, memory-wise?
  12. Any reason to overload global new and delete?
  13. Making std::vector allocate aligned memory
  14. Are memory leaks “undefined behavior” class problem in C++?
  15. How to know if a pointer points to the heap or the stack?
  16. Does delete on a pointer to a subclass call the base class destructor?
  17. What happens when you deallocate a pointer twice or more in C++?
  18. Check if a pointer points to allocated memory on the heap
  19. What is the behavior of “delete” with stack objects? [duplicate]
  20. Reason why not to have a DELETE macro for C++
  21. How is heap and stack memories managed, implemented, allocated?
  22. Does this type of memory get allocated on the heap or the stack?
  23. How do I call the original “operator new” if I have overloaded it?
  24. Why does this program crash: passing of std::string between DLLs
  25. Is global memory initialized in C++?
  26. What does “Memory allocated at compile time” really mean?
  27. When do programmers use Empty Base Optimization (EBO)
  28. vector memory allocation strategy
  29. Memory management patterns in C++
  30. Memory-efficient C++ strings (interning, ropes, copy-on-write, etc) [closed]

Leave a Comment