shared-memory

I have 'N' threads to perform simultaneously on device which they need M*N float from the global memory. What is the correct way to access the global memory coalesced? In this matter, how the shared memory can help? Usually, a good coalesced access can be achieved when the neighbouring threads access neighbouring cells in memory. So, if tid holds the index of your thread, then accessing: arr[tid] --- gives perfect coalescence arr[tid+5] --- is almost perfect, probably misaligned arr[tid*4] --- is not that good anymore, because of the gaps arr[random(0..N)] --- horrible! I am talking from the

I have written a code on Mac OS X to use POSIX shared memory as shown below: #include <sys/mman.h> #include <sys/stat.h> #include <fcntl.h> #include <unistd.h> #include <sys/types.h> int main() { int fileHandle = shm_open("TW_ShMem1",O_CREAT|O_RDWR, 0666); if(fileHandle==-1) { //error. } else { //Here, it is failing on Mac OS X if(-1==ftruncate(fileHandle, 8192)) { shm_unlink("TW_ShMem1"); fileHandle = -1; } else { return 0; } } return 1; } ftruncate on Linux is working without any problem. On Mac OS X, it is returning -1 and errno is EINVAL (as seen in the debugger). Why is it failing? What

When using shared memory, each process may mmap the shared region into a different area of its respective address space. This means that when storing pointers within the shared region, you need to store them as offsets of the start of the shared region. Unfortunately, this complicates use of atomic instructions (e.g. if you're trying to write a lock free algorithm ). For example, say you have a bunch of reference counted nodes in shared memory, created by a single writer. The writer periodically atomically updates a pointer 'p' to point to a valid node with positive reference count. Readers

I tried to compile the following code on ubuntu 11.04: #include <boost/interprocess/shared_memory_object.hpp> #include <iostream> int main() { boost::interprocess::shared_memory_object shdmem(boost::interprocess::open_or_create, "Highscore", boost::interprocess::read_write); shdmem.truncate(1024); std::cout << shdmem.get_name() << std::endl; boost::interprocess::offset_t size; if (shdmem.get_size(size)) std::cout << size << std::endl; } only to get the following errors: /tmp/cc786obC.o: In function `boost::interprocess::shared_memory_object::priv_open_or_create(boost::interprocess::detail:

So I installed the GPU version of TensorFlow on a Windows 10 machine with a GeForce GTX 980 graphics card on it. Admittedly, I know very little about graphics cards, but according to dxdiag it does have: 4060MB of dedicated memory (VRAM) and; 8163MB of shared memory for a total of about 12224MB . What I noticed, though, is that this "shared" memory seems to be pretty much useless. When I start training a model, the VRAM will fill up and if the memory requirement exceeds these 4GB , TensorFlow will crash with a "resource exhausted" error message. I CAN, of course, prevent reaching that point by