I have several classes that suffer from cache contention and are allocated with the "new" operator. Can I somehow make sure that "new" returns an address aligned to a cache line?
I am using GCC (if it's not portably possible).
Asked
Active
Viewed 1,160 times
9
-
1A cache line is typically 64 bytes. You must have some pretty small classes, and therefore must be performing lots of pretty small dynamic allocations? – Oliver Charlesworth Feb 19 '12 at 19:16
-
Some are small, but most are overlapping (in a cache line). – jk4736 Feb 19 '12 at 19:18
-
Do you allocate your instances individually or in an array? – Sergey Kalinichenko Feb 19 '12 at 19:19
-
They are allocated individually. (I guess the most critical parts could be refactored to be allocated in an array, however.) – jk4736 Feb 19 '12 at 19:20
-
4The only solution I can think of is to allocate `sizeof(myobj)+63`, and then use placement new at the address on the 64-byte boundary. – Sergey Kalinichenko Feb 19 '12 at 19:25
-
Thanks for the pointer to placement new. It solves the problem for now (though I'd prefer a non-hacky solution.) – jk4736 Feb 19 '12 at 19:29
-
dasblinkenlight, your solution seems to be the best right now (except that it's a comment, and instead of allocating more, I'd allocate with memalign) – jk4736 Feb 19 '12 at 19:38
3 Answers
3
You can use memalign or _aligned_alloc for glibc or windows CRT systems respectively. you can even use a custom allocator like nedmalloc and have it align the blocks, which could also give you some other added bonuses.
you should also mark them with __attribute__((aligned(64))), just in case they get statically allocated.
Necrolis
- 25,836
- 3
- 63
- 101
3
The easiest way to solve this would be to make the objects big enough, that they can't share a cacheline. Using gcc you could set the alignment of the classes (I'm assuming your objects are smaller then a cacheline since you suffer from contention):
class foo {} __attribute__((aligned(2 * CL)));
You need to insert the correct Cachelinesize for your architecture for CL of course (or put it into a macro an d use that there). I used twice the size of a cache line, because from what I remember new doesn't guarantee that it will actually ensure the alignment is preserved. Since the object is therefore not guaranteed to start at the beginning of a cacheline you could still get parts of different objects in the same cacheline (that is the end of one object, and the start of another one). If the alignement is always preserved, __attribute__((aligned(CL))) would be fine. Of course this will need you to change your structures and waste a lot of space.
You could also write your own new (look here for how to do that) based on memalign. For a more bandaid kind of solution you could also use memalign directly and put an object inside the allocated space using placement new. Of course it makes the code using those objects less nice.
1
You can use placement new to construct an object into a given region of memory:
// Instantiate object into a pre-allocated buffer
obj = new (buf) TheClass();
To get an aligned buffer buf, you can use memalign, sbrk or mmap.
-
I can not see the relation between the question and `mmap`. Why `mmap`? – Frunsi Feb 19 '12 at 19:59