Replace os_cache_max configuration and behavior with calls to: (1)
discard any page read from the system cache, (2) immediately schedule
all writes to the disk, and periodically discard any pages written
from the system cache.  In all cases, ignore if O_DIRECT is configured.
Add the new map file.
Don't mmap(2) the file if it's configured for direct I/O, the Linux
man pages say it's a bad idea.
Merge branch 'develop' into fadvise
Re-work posix_fadvise, sync_file_range buffer cache changes.

Put per-object os_cache_max configuration back in, but implement it in
the block manager layer.  Disallow if direct_io is configured, or if the
system doesn't support posix_fadvise.

Add per-object os_write_schedule, if configured immediately schedule
any writes.  Disallow if direct_io is configured, or if the system
doesn't support sync_file_range.
Turn of file-mapping if the application configured a cache-size maximum.
Change os_write_schedule to be os_cache_dirty_max, changing a boolean
(schedule writes for each buffer after it's written) into a value
(schedule writes for all dirty buffers after enough bytes have been
written).
Look more carefully for merge candidates in LRU walks.
Don't pass in both a session and a btree, the standard pattern is to get
the btree handle from the session.
Fixes for the memory accounting of split-merge pages.

The eviction server was using the cache_inuse routines on exit, which
don't complain if there are more bytes/pages evicted than are in memory,
and that's not correct, change it to do an exact comparison.  This was
hiding some problems in our page count.  Fix the page count problems by:
	... adding an "allocate a new WT_PAGE" function that increments
the count of pages in the system and calling it from everywhere (we
weren't counting split-merge pages created during reconciliation, or the
pages we created when opening empty trees);
	... change the split-merge collapse code to call __wt_page_out
to discard pages instead of freeing them explicitly;
	... rename WT_CACHE.pages_read to be pages_inmem, matching the
bytes_inmem name and matching its new function of tracking all pages,
no matter their origin.

We were tracking cache "bytes in memory" in two variables: "bytes read"
was tracked in WT_CACHE.bytes_read and "bytes subsequently added in
memory" in WT_CACHE.bytes_inmem, and we added them together to get a
final answer.  Change WT_CACHE.bytes_inmem to be the bytes in memory,
regardless of whether it was read in, a created page, or subsequently
added memory, by removing WT_CACHE.bytes_read and changing the
__wt_page_inmem function to call __wt_cache_page_inmem_incr instead of
having a separate __wt_cache_page_read function.

Change __wt_page_modify_init to increment the page's footprint when the
WT_PAGE_MODIFY structure is first allocated.

Add a reconciliation function to create split-merge pages: abstract out
the common code and set the page's memory footprint.
Include newly created split-merge page WT_ADDR and WT_IKEY structures in
the page's memory footprint.
Make the "size" naming consistent, "inmem_" doesn't add anything.
Corret a comment.
Make the split percentage apply even when the resulting split page size
is smaller than the allocation size.
Use the maxpagesize, not the allocsize, and be consistent with use of
the variables (no change, but hopefully easier to understand the next
time I read through it).
Don't increment by offset, increment by size.
Merge branch 'develop' into fadvise
Merge pull request #475 from wiredtiger/split-merge-memory

Do better cache accounting on split-merge pages, respect splict_pct when allocation_size == leaf_page_max.
Merge pull request #472 from wiredtiger/fadvise

Add configurations to minimize the impact of reads and writes on the filesystem cache.
Fix a leak of address memory.