dynamic-memory-allocation

I'm doing a research on 2D Bin Packing algorithms. I've asked similar question regarding PHP's performance - it was too slow to pack - and now the code is converted to C++. It's still pretty slow. What my program does is consequently allocating blocks of dynamic memory and populating them with a character 'o' char* bin; bin = new (nothrow) char[area]; if (bin == 0) { cout << "Error: " << area << " bytes could not be allocated"; return false; } for (int i=0; i<area; i++) { bin[i]='o'; } (their size is between 1kb and 30kb for my datasets) Then the program checks different combinations of 'x'

If i make a loop that reserves 1kb integer arrays, int[1024], and i want it to allocate 10000 arrays, can i make it faster by running the memory allocations from multiple threads? I want them to be in the heap. Let's assume that i have a multi-core processor for the job. I already did try this, but it decreased the performance. I'm just wondering, did I just make bad code or is there something that i didn't know about memory allocation? Does the answer depend on the OS? please tell me how it works on different platforms if so. Edit: The integer array allocation loop was just a simplified

I had this bug today which turned out to be because I use a string allocated from inside my DLL after calling FreeLibrary() . This is a simple example reproducing the crash. This goes in DLL: void dllFunc(char **output) { *output = strdup("Hello"); // strdup uses malloc } This is in the EXE that loads the DLL: void exeFunc() { char *output; dllFunc(&output); std::string s1 = output; // This succeeds. FreeLibrary(dll); std::string s2 = output; // This crashes with access violation. } I read the documentation of FreeLibrary() but I couldn't find anything about memory becoming invalid after it's

In C ++ How to program there is a paragraph that say: A common programming practice is to allocate dynamic memory, assign the address of that memory to a pointer, use the pointer to manipulate the memory and deallocate the memory with delete when the memory is no longer needed. If an exception occurs after successful memory allocation but before the delete statement executes, a memory leak could occur. The C++ standard provides class template unique_ptr in header to deal with this situation. Any on could introduce me a real example that exception occur and memory will leak like this post ? Sam

I am writing a library for various mathematical computations in C. Several of these need some "scratch" space -- memory that is used for intermediate calculations. The space required depends on the size of the inputs, so it cannot be statically allocated. The library will typically be used to perform many iterations of the same type of calculation with the same size inputs, so I'd prefer not to malloc and free inside the library for each call; it would be much more efficient to allocate a large enough block once, re-use it for all the calculations, then free it. My intended strategy is to

Has anybody used SmallObjectAllocator from Modern C++ Design by Andrei Alexandrescu in a big project? I want to implement this allocator but I need some opinions about it before using it in my project. I made some tests and it seems very fast, but the tests were made in a small test environment. I want to know how fast it is when are lots of small objects(like events, smart pointers, etc) and how much extra memory it uses. Andrei Alexandrescu I suggest you ask Rich Sposato . He has done extensive work on Loki's small object allocator, including testing and benchmarks. Have you considered using

Title is self-explanatory. Very easy question. I think it's O(n) but wanted to verify before my final tomorrow. The short answer is... it depends. If Q is a pointer to an array of objects that have destructors, then delete[] Q will need to call all of those destructors. This will call O(n) destructors, where n is the number of elements in the array. On the other hand, if Q points to an array of objects that don't have destructors (for example, int s or simple struct s), then no destructors need to be called, which takes only O(1) time. Now note that those destructors don't have to run in O(1)