numa

I am currently working on a NUMA machine. I am using numa_free to free my allocated memory. However, unlike free , numa_free needs to know how many bytes are to be freed. Is there any way to know that how many bytes are pointed to by a pointer without tracing it out? There is no way to obtain memory size using underlying API. You must remember size during the allocation somewhere. For Example, You may write your own allocator, that allocates 4 extra bytes, stores in first 4 bytes size of buffer, and during deallocation you can read size of buffer from it: void *my_alloc(size_t size) { void

There are many resources describing the architecture of NUMA from a hardware perspective and the performance implications of writing software that is NUMA-aware, but I have not yet found information regarding the how the mapping between virtual pages and physical frames is decided with respect to NUMA. More specifically, the application running on modern Linux still sees a single contiguous virtual address space. How can the application tell which parts of the address space are mapped onto local memory and which are mapped onto the memory of another NUMA node? If the answer is that the

According to wiki : Non-uniform memory access (NUMA) is a computer memory design used in multiprocessing, where the memory access time depends on the memory location relative to a processor. But it is not clear whether it is about any memory including caches or about main memory only. For example Xeon Phi processor have next architecture: Memory access to main memory (GDDR) is same for all cores. Meanwhile memory access to L2 cache is different for different cores, since first native L2 cache is checked, then L2 cache of other cores is checked via ring. Is it NUMA or UMA architecture?

The Windows API offers the CreateFileMappingNuma function ( http://msdn.microsoft.com/en-us/library/windows/desktop/aa366539(v=vs.85).aspx ) to create a named shared memory space on a specific NUMA node. So far, I have not found an equivalent function for Linux. My current approach looks like this: Allocate named shared memory (using shm_open(...)) Determine current NUMA node (using numa_move_pages(...)) Move pages to target Node (using numa_move_pages(...) again) Does anyone know a better approach? EDIT: For the record: My proposed implementation does work as expected! That sounds right. Note

We've just bought a 32-core Opteron machine, and the speedups we get are a little disappointing: beyond about 24 threads we see no speedup at all (actually gets slower overall) and after about 6 threads it becomes significantly sub-linear. Our application is very thread-friendly: our job breaks down into about 170,000 little tasks which can each be executed separately, each taking 5-10 seconds. They all read from the same memory-mapped file of size about 4Gb. They make occasional writes to it, but it might be 10,000 reads to each write - we just write a little bit of data at the end of each of

Context: I'm programming a software system that consists of multiple processes. It is programmed in C++ under Linux. and they communicate among them using Linux shared memory. Usually, in software development, is in the final stage when the performance optimization is made. Here I came to a big problem. The software has high performance requirements, but in machines with 4 or 8 CPU cores (usually with more than one CPU), it was only able to use 3 cores, thus wasting 25% of the CPU power in the first ones, and more than 60% in the second ones. After many research, and having discarded mutex and