parallel OMP with many "new" operators

[zarzor2010]

Hello All,

I have a code that uses multi threads using OMP.
However, Inside the code I allocate too many memory using "new".

I know that the memory allocation using new must be done in serial. Therefore I am not getting a good performance out of the multi-threaded program.

I thought about allocating a big memory only once, and then advance the pointer every time I need to allocate a small memory.

For example, if I need to allocate chunks of 7 doubles:

main_memory = new double [10000];
double* x1 = main_memory;
main_memory+= 7;
double* x2 = main_memory;
main_memory+= 7 

However, I do not know how to handle the memory deallocation. Beside, this is not thread safe method because main_memory is shared by all threads.

Anyone has an idea how to solve this. May be there is a boost library that does this, which I am not aware of.

Thank you in advance.

[viliml]

However, I do not know how to handle the memory deallocation.

Answer: delete[] main_memory;

[Moschops]

Do note that you've changed the pointer main_memory such that it's pointing somewhere else. When you get to deleteing the memory, you need to provide a pointer with the same value as the pointer you were given from new.

For example,

int main()
{
double* main_memory = new double [10000];
double* const deleteMe =  main_memory; // Now safe to change main_memory becasue we keep track of the value with deleteMe
double* x1 = main_memory;
main_memory+= 7;
double* x2 = main_memory;
 main_memory+= 7 ;
delete[] deleteMe;
}

[zarzor2010]

Thank you for your help,
What I meant is that I need to deallocate some of the small chunks not the complete main_memory.

Also, it turned out that it is not thread safe solution as well.

Thank

[Moschops]

Beside, this is not thread safe method because main_memory is shared by all threads.

Wait until all threads are done with it, then deallocate it.

[zarzor2010]

Wait until all threads are done with it, then deallocate it.

No, I mean the allocation itself is not thread-safe, because main_memory itself is shared by all the threads. So racing condition can easily happen

[helios]

I know that the memory allocation using new must be done in serial. Therefore I am not getting a good performance out of the multi-threaded program.

I've never heard of this. Are you certain memory allocation is what's consuming most of your time? Have you run the program through a profiler to find its hot spots?

[zarzor2010]

I've never heard of this. Are you certain memory allocation is what's consuming most of your time?

The heap uses sets of locks to control the memory allocation. Therefore threads have to wait for the lock to release in order to allocate a memory. The following url discuss this issue and gives a solution on windows intel compilers.

http://software.intel.com/en-us/articles/avoiding-heap-contention-among-threads/

But I am using linux with GCC compilers. So I was searching for a similar solution may be in Linux


Thank you

[helios]

I'm aware of that, but the way you said it seemed to imply that management had to be done in serial at the application level. I.e. that no more than one thread could safely call malloc() at the same time.

What you're suggesting in the OP isn't necessarily any faster than what malloc() does, since you'll still need to synchronize to move your pointer. Rather than this, would it be possible to reorder your allocations so you only need to allocate memory at the very beginning of the thread?

I ask again, though: are you certain this is what's consuming most of your time?

[modoran]

This is the only implementation that I am aware of which is available for free:
http://code.google.com/p/gperftools/?redir=1

There are also more commercial libraries that do the same thing.

[zarzor2010]

Thank you for your help guys,

I ask again, though: are you certain this is what's consuming most of your time?

Yes, I ran a profiler and this seems to be the issue.

This is the only implementation that I am aware of which is available for free:
http://code.google.com/p/gperftools/?redir=1

Do you mean the tcmalloc library there?

thank you
Mina

[zarzor2010]

Any help please?

Thanks

[rapidcoder]

What I meant is that I need to deallocate some of the small chunks not the complete main_memory

It is not possible. You can only deallocate it once and fully.

Any help please?

Why not allocate a private memory region for each thread? I mean - don't share memory between threads.

[modoran]

Do you mean the tcmalloc library there?

Yes.