To avoid the additional page transfers induced by the basic parity method, we have developed a parity logging scheme. The key idea is that a given page need not be bound to a particular server or parity group. Instead, every time a page is paged out, a new server and a new parity group may be used to host the page.
Suppose the client uses S servers. Each paged out page is XORed with a
page size buffer maintained by the client (which is initially filled with
zeros) and then is transfered to a server following a
round robin policy. Whenever S pages have been transfered, the buffer
is also transfered to a parity server. Using this technique, the
runtime overhead is minimal, since for each paged out page 1 + 1/S
page transfers are required. When a server crashes, all of its pages
can be restored by XORing the pages in their group
with the corresponding parity page. 
Every time a page is repaged out, it is marked in the old parity group
containing it as inactive. When all the pages of a parity group are
marked as inactive, all the memory server pages and the corresponding
parity page
can be reused. It is obvious that each memory server must have some extra
overflow memory to support parity logging since many versions of
a given page may be present simultaneously at the servers' memory.
Also, due to this situation, it is possible that some server runs out of
memory. In this case, one has to perform garbage collection freeing
parity sets by combining their active pages to new ones.
In our experiments, 4 servers were used devoting 10% more memory to
support parity logging and we never had to perform garbage
collection.