Qiao XIN (qxin@cs.ucsd.edu)
Mon, 29 May 2000 23:18:52 -0700 (PDT)

Qiao Xin

Evaluation of the Paper: Memory coherence in Shared Virtual
Memory Systems

This paper discusses the memory coherence problem for a shared virtual
memory which provides a virtual address space shared among all
processors in a loosely coupled distributed-memory multiprocessor
system. The following three memory coherence strategies based on
invalidation approach for page synchronization are considered in the

In the invalidation approach, a processor with a write fault to a page
results in the invalidation of all copies of the page and the faulting
processor being the owned of the page, while a processor with a read fault
to a page results with a read access to the page.

The first strategy is the centralized manager algorithm. There is only
one manager that knows the owner of a page and it helps other
processors locate where the page is. Synchronization of requests may
be performed by the manager or the individual owners.

The second strategy is the fixed distributed manager algorithm. In this
algorithm, every processor is given a predetermined subset of the
pages to manage. When a page fault occurs on a page, the faulting
processor asks the manager where the page owner is and then proceeds
as the first algorithm.

The third strategy is the dynamic distributed manager algorithm. In
this algorithm, the ownership of all pages are dynamically tracked. A
field called "probOwner" indicates the true owner or the probable
owner of a page. A faulting processor sends request to the processor
indicated by the "probOwner" field for that page. If it is the owner,
it proceeds as the first algorithm, if it is not, it forwards the
request to the processor indicated by its probOwner field.

Implementations show that dynamic distributed manager algorithm and
its variations seem to have the most desirable overall feature, and
they also suggest the dynamic distributed manager algorithm has the
potential to implement a shared virtual memory system on a large scale
multiprocessor system.

A difficult yet important question is what the best page size should
be. This is important since the granularity of the memory units is
one of the two design choices that greatly influence the
implementation of a shared virtual memory.

Evaluation of the Paper: Implementing Global Memory Management
in a Workstation Cluster

This paper examines global memory management in a workstation cluster,
and it attempts to solve the problem in existing operating systems. In
existing operating systems, clusters acts as autonomous and
independent agents and result in difficulty in exploiting resources
suck as low-latency communication, huge primary memories, and
high-speed processors.

The introduced system is called GMS(Global Memory Service) differs
from previous system in significant ways. First, by inserting a global
memory management algorithm at the lowest OS level, the system
integrates all cluster memory by all higher-level functions, VM
paging, mapped files, and file system buffering. Second, memory is
globally managed based on good choices both for the faulting node and
the cluster as a whole. Pages on a node can be either local or global
which is stored on behalf of other nodes. On a fault requiring a disk
read, the faulting node grows its local memory, while the cluster node
with the oldest page loses a page to disk. Third, the system can
gracefully handle addition and deletion of nodes in a cluster without
user intervention. Addition is checked with and deletion is checked by
a designed master node and the master node distributes the related
information. Finally, the implementation is well integrated into a
production operating system: OSF/1 and achieves better performance.

There are also limitations of the algorithm. Since dirty pages are
written to disk before being sent to global memory, this increase the
average memory access time; The modified global LRU algorithm doesn't
fit all cases; In case of a few nodes have idle memory, programming
performance can be affected if many nodes attempts to use the idle
memory simultaneously.