multithreaded kernel

[Jonathan Shapiro]

   Running the page aging process after you have aged a page sufficently so
   that it should be preempted because it is still modified (and needs to be
   cleaned before it can be preempted).  This procedure results in selecting
   R/O pages before R/W pages at times of high page pressure...

There is a related issue that I noticed recently concerning pinned
pages.  For real time purposes, what it means to be "pinned" is not
just that the page will stay in memory, but that nothing will cause
accesses to be delayed by I/O.  This raises a problem for
checkpointing dirty pinned pages/nodes.

Two solutions came to mind:

1) Have a facility to mark certain objects as "non-checkpointed" The
checkpoint mechanism will ignore them.  This is roughly the inverse of
journalling, and it may be dangerous if the page is not pinned.  Such
pages are useful for things like video buffers and storage in support
of things that are non-recoverable in any case, such as some network
connections (e.g. working storage used by the TCP/IP implementation).

2) Alternatively, distinguish pinned from non-checkpointed.  If a page
is pinned and non-checkpointed, the kernel must conspire always to be
able to copy it on demand.  It is checkpointed using the usual
mechanism, but if we get "caught" we copy the content to an
"available" frame and let the checkpoint proceed from the old copy.

This approach may be a problem in the absence of key chains, and it
definitely makes pinning expensive.



I'ld welcome other suggestions!


Jonathan