So, what does all this mean?

VmUbc is a tool to help you understand the behavior of the memory system.
Much of the information is is also presented by vmstat(1), but it also
display UBC and Metadata cache information.  This is important, as it
can help you understand the causes of poor behavior.


Explanations:

CPU:  This is the percent of time the CPU has spent in the following states:
	User:  executing in user-mode
	Nice:  executing in user-mode at reduced priority
	System: executing in kernel-mode (i.e. system calls)
	Idle:  doing nothing
	Wait:  waiting for hardware access (e.g. tape, disk, etc.)

Memory pages
	Free: on the freelist
	Wired: not pageable -- generally belonging to the kernel or a device driver
	Active: assigned to a process
	Inactive: formerly assigned to a process but not used for at least n seconds.

UBC Page usage
	VM-only:  dedicated to the VM system (by default this is 0)
	VM:       assigned to the VM system
	FS:       assigned to the UBC
	Min:	  dedicated to the UBC (by default this is 10% of your total pages)

	Note that the UBC Page Usage and Memory pages give different views of the
	status of the same pages.  For example, the Free list may contain pages assigned
	to both the VM and UBC systems.  There may be discrepances in the totals however,
	since under some circumstances pages may not appare in the UBC Page Usage
	statistics.

UBC Page Status
	displays the number of clean and dirty pages in the UBC.  Dirty pages are written
	to disk soon after they become dirty, and are thus made clean

UBC Cache
	displays the number of hits and misses in the UBC.  Hits are satisfied from the UBC, which
	is in physical memory.  Misses are satisfied by loading the appropriate blocks from disk into
	the UBC

MetaData Cache
	displays the number of hits and misses in the Metadata cache.
	Hits are satisfied from the cache, which is in physical memory.
	Misses are satisfied by loading the appropriate blocks from disk into
	the cache
	
Page Faults
	COW : Copy-on-write faults -- a page that had previously been shared by
		by multiple process has been copied so that a process could modify it.
	Page In : VM pages read in, either from a swap device or from a file.
	Page Out : pages written to a swap device.
	React :  pages moved from the Inactive lists (see Memory pages) to the Active list.
	Zero : pages filled with zeros (commonly done when a new page is assigned to a process,
		to prevent it from discovering data that came from another process).



VM and UBC compete for physical pages.  Three kernel parameters control this behavior:
	ubc-minpercent -- the minimum size of the UBC, expressed as a percentage
			of memory.  The default value is 10%
	ubc-maxpercent -- the maximum size of the UBC, expressed as a percentage
			of memory.  The default value is 100%

	ubc-borrowpercent -- the threshold below which borrowing from the UBC is not
			permitted, expressed as a percentage of memory.
			The default value is 10%

	This means the the UBC is allowed to vary between 10% and 100% of memory (in practice
	100% is never acheived) and VM is allowed to vary between 90% and
	0% (again, never achieved) of memory.

What goes where in memory?

	Your program's executable code (called "text") goes in the UBC.  Dynamically allocated
	memory (i.e. stack and heap) go in VM. Pages read from or written to files go in the UBC.
	Memory-mapped files (readonly) go in the UBC.  Memory mapped files (read/write) go in VM.

How does this behave?
	So long are there are free pages in the system (the size of the freelist is above 128 pages),
	requests for new pages by either the VM or UBC are satisfied from this list.  When the
	freelist crosses its trigger threshold (default is <128 pages),
	old pages are evicted from either the UBC or VM to satisfy requests for
	new pages.  If the request is for VM and the UBC size is greater than ubc-borrowpercent, 
	pages will be evicted from the UBC.  If the UBC size is less than ubc-borrowpercent, pages
	will be evicted alternately from the UBC and VM.  Note that VM pages on both the
	Active and Inactive lists are by definition dirty (clean VM pages are on the Free list),
	and must be written to a swap device when evicted.  UBC pages may be either dirty or clean,
	but are usually clean.  Clean pages do not need to be written to disk, and thus take
	less time to evict.

	When pages must be evicted from VM, they are taken from the Inactive list.  This list is only
	maintained when page faulting is required.  If your system has never needed to evict pages
	from VM (since booted), it will have an Inactive list of size 0.