How to access the content of a memory address?

Question:

In file1.cpp, I save some data to memory with memory address 0x0364DF00.

In file2.cpp, how to access the content of the memory address (0x0364DF00)?

What I tried

I tried adding some code to solve this problem, but it didn't work.

#include <iostream>
using namespace std;

int main() {
	int* address = (int*)0x0364DF00;
    cout << address(&address);
	return 0;
}

This is just an experiment. I don't know if it is possible.

You can do this using a concept called shared memory.

Using shared memory you could share say (as an example) a struct like the following:

struct Data {
    std::atomic<int> counter;
};

Note that because you will be sharing data across different cores, you need to properly synchronize. In this case we use std::atomic.

You then need a mechanism to map this memory to a shared location, which is OS-specific but in general would consist in providing a file as a named-location for the memory and a size (to resize the file). Once opened the file can be memory-mapped and a pointer to a memory location is returned to the user.

In general the producer (or creator) is given the file name and size like this:

// And this in file1.cpp
void child() {
    MappedFile file;
    if ( !file.open( "/tmp/file", 1024 ) ) return;
    Data* data = reinterpret_cast<Data*>(file.data());
    for ( unsigned j=0; j<=10; ++j ) {
        data->counter = j;
        ::usleep( 1000000 );
    }
}

Then the other process can then look at the file, get its size and memory map it on its entirety like in the following code. The pointer returned by the mapped location points to the same physical memory as the previous pointer. However, because these two functions are running on different process, their virtual mapping will be different and thus their numeric value will very likely be different too.

// This can be in file2.cpp
void parent() {
    MappedFile file;
    while ( !file.open( "/tmp/file" ) ) {}
    Data* data = reinterpret_cast<Data*>( file.data() );
    int last = 0;
    while ( data->counter < 10 ) {
        if ( last!=data->counter ) {
            std::cout << "Counter:" << data->counter << std::endl;
            last = data->counter;
        }
    }
}

The internal implementation is OS-specific but on Linux it would look like the following. This is an example I wrote for testing so it's not production quality or even tested fully (but works for this example).

First define a class with an integer to hold the file descriptor, the file size and the shared memory location.

struct MappedFile {
    MappedFile() {}
    ~MappedFile() { close(); }
private: 
    int _fid = -1;
    void* _addr = nullptr;
    std::size_t _mapsize = 0;
};

Then create one method to open/create the file with a given size. This is the "creator". It opens the file with the O_CREAT flag such that if the file does not exists, it is created. Then it truncates the file to the size provided, which is first rounded to a page size (typically 4k on Linux) - this is an mmap() requirement. Then the file is memory mapped and a pointer is returned to the user.

    bool open( const std::string& filename, std::size_t filesize ) {
        int fid = ::open( filename.c_str(), 
            O_CREAT|O_RDWR, S_IRWXU | S_IRWXG);
        if ( fid<0 ) {
            std::cerr << strerror(errno) << std::endl;
            std::cerr << "Could not create file " << filename << std::endl;
            return false;
        }
        long mapsize = ((filesize-1)/PAGESIZE + 1 )*PAGESIZE;
        int res = ftruncate( fid, mapsize );
        if ( res!=0 ) {
            std::cerr << strerror(errno) << std::endl;
            std::cerr << "Could not trucate file" << std::endl;
            ::close(fid);
            return false;
        }
        void* addr = mmap( nullptr, mapsize, PROT_READ|PROT_WRITE, MAP_SHARED, fid, 0 );
        if ( addr==MAP_FAILED ) {
            std::cerr << "Could not memory map region" << std::endl;
            ::close(fid);
            return false;
        }
        close();
        _fid = fid;
        _addr = addr;
        _mapsize = mapsize;
        return true;
    }

Then there is another method that relies on the fact that the file is already created. Note that there is a possibility of a race condition where the consumer opens the file after it is created but before it is truncated to the correct size. For this reason, we check the file size to see if it is zero. The rest is the same with the exception that we do not resize the file.

    bool open( const std::string& filename ) {
        struct stat sb;
        if ( stat( filename.c_str(), &sb ) != 0 ) {
            return false;        
        }
        size_t filesize = sb.st_size;
        if ( filesize == 0 ) return false;
        int fid = ::open( filename.c_str(), O_RDWR, S_IRWXU | S_IRWXG);
        if ( fid<0 ) {
            std::cerr << strerror(errno) << std::endl;
            std::cerr << "Could not open file " << filename << std::endl;
            return false;
        }
        void* addr = mmap( nullptr, filesize, PROT_READ|PROT_WRITE, MAP_SHARED, fid, 0 );
        if ( addr==MAP_FAILED ) {
            std::cerr << "Could not memory map region" << std::endl;
            ::close(fid);
            return false;
        }
        close();
        _fid = fid;
        _addr = addr;
        _mapsize = filesize;
        return true;
    }

Note that I say "producer" and "consumer" but both the processes have read-write access to the mapped memory.

Destroying the object is equal for both processes and as simple as unmapping the memory and closing the file.

    void close() {
        if ( _addr!=nullptr ) {
            ::munmap( _addr, _mapsize );
            ::close(_fid);
        }
        _addr = nullptr;
        _fid = -1;
        _mapsize = 0;
    }

A sample driver for this test spawns a separate process with fork() and proceeds to share information

int main() {
    pid_t pid = fork();
    if ( pid == 0 ) child(); else parent();
}

This produces

Counter:1
Counter:2
Counter:3
Counter:4
Counter:5
Counter:6
Counter:7
Counter:8
Counter:9
Counter:10

full code on Godbolt: https://godbolt.org/z/T8a5enzje