The current 'region' term in the ref. manual becomes 'area'.

Memory is divided into pages (4096 bytes ?).

Every region has a private and public identifier. The public identifier is
unique for shared regions (>=0) and reused for private regions (<0).  The
private identifier is the SharedRegion or PrivateRegion object.

The RC for a region is the sum of all local RCs stored in all the private
identifiers (objects) representing that region.

If you allocate in a SharedRegion that happens to be a global pointer
into another area, the allocation is performed as if you had used your
local representative of the shared region (i.e. allocation is always
local).

Processors do not put data in the same pages, even when objects are
allocated in the same region (in other words, processors associate
a local set of pages with each private region identifier).

There is a globally accessible data structure that maps object pointers
to public region identifiers. Essentially:
  regionof(p) = regionmap[area(p)][address(p) / PAGESIZE]
When the area is known (private objects, local objects, uniproc/smp-narrow
backends), the first indexing op is unecessary.

Updates to regionmap do not need locking (because pages are not shared
and region deletion is a synchronising operation).

There is a per-process table mapping public region identifiers to
private region identifiers. For the uniproc backend, this table is
not necessary (the public and private identifiers are the same).

Page allocation needs locking within an SMP (aka between processors
that share an area).

*a = b requires an atomic exchange if the write can be the subject of
a race (i.e. if on an SMP and if a is shared)