Hi Val,

Thanks for the quick response.

I am referring to how Virtual and Physical Memory works.

For more background, when a process is launched, it will be allocated a
virtual address space. This virtual memory will have a translation to the
physical memory you have on your computer. The pages allocated to the
processes will have different permissions (Read vs Read-Write), and some of
them will be exclusively mapped to the process it is assigned to, while some
others will be shared.

A good example of shared physical pages is for say a library (it does not
have to be a library, and I'm only providing that as an example). If I
launch two identical processes on the same machine, the shared libraries
used by these processes will have the same physical address (after
translating from virtual to physical addresses). This is because the library
might be read-only, and there is no need for two copies of the same library
if it is only being read. The processes will not get their own copy until
they attempt to write to the shared page. When they do, this will incur a
page-fault and the process will be allocated it's own (exclusive) copy of
the previously shared page for modification. This is called a Copy-On-Write
(CoW).

The case I am looking for specifically is when I launch 2 processes (say
Ignite for the sake of the example), and load up a dataset to be shared, I
want these 2 processes to point to the same physical memory space for the
shared dataset (until one of them tries to modify it, of course). In other
words, I want the loaded dataset to have the same physical address
translation from their respective virtual addresses. That is what I'm
referring to when I talk about identical physical page mappings.

This is for a research project I am conducting, so performance or
functionality is unimportant. The physical mapping is the only critical
component.

Sincerely,
Umur





--
Sent from: http://apache-ignite-users.70518.x6.nabble.com/

Reply via email to