[svn-r9687] Purpose:

   Modify the cache code (H5C) to support automatic cache resizing to
adapt to the work load at run time.


Description:

   Different applications require different sized caches to maintain
an acceptable hit rate.  This set of changes attempts to provide the
ability to adjust to circumstances automatically.


Solution:

   Added highly configurable code to allow the user to either set a
fixed cache size, or allow the cache to grow and shrink according to
conditions.

   If enabled, cache size increases are triggered when the hit rate
drops below a user specified threshold in a user specified interval.

   Cache size reductions (if enabled) are triggered when either the
hit rate exceeds some user specified threshold over a user specified
interval, when the cache contains "enough" entries that haven't been
accessed for a user specified interval, or some mix of the above.

   See the header comments on the H5C_auto_size_ctl_t structure in
H5Cprivate.h for further details.

   At present, the cache resize configuration options are not
accessible via the user API.  Must add this.


Platforms tested:

   h5committested, heping (serial), and copper (parallel)


Misc. update:

1 files changed, 2417 insertions, 722 deletions

diff --git a/src/H5C.c b/src/H5C.c
index af96125..1e2f92a 100644
--- a/src/H5C.c
+++ b/src/H5C.c
@@ -75,12 +75,14 @@
  *
  *	Tests:
  *
- *	 - Trim execution time.
+ *	 - Trim execution time.  (This is no longer a major issue with the 
+ *	   shift from the TBBT to a hash table for indexing.)
  *
  *	 - Add random tests.
  *
  **************************************************************************/
 
+#define H5C_PACKAGE		/*suppress error about including H5Cpkg	  */
 #define H5F_PACKAGE		/*suppress error about including H5Fpkg	  */
 
 /* Pablo information */
@@ -88,7 +90,7 @@
 #define PABLO_MASK	H5C_mask
 
 #include "H5private.h"		/* Generic Functions			*/
-#include "H5Cprivate.h"		/* Cache				*/
+#include "H5Cpkg.h"		/* Cache				*/
 #include "H5Dprivate.h"		/* Dataset functions			*/
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5Fpkg.h"		/* Files				*/
@@ -120,6 +122,28 @@
  * do not reference the sanity checking macros.
  *							JRM - 5/5/04
  *
+ * Changes:
+ *
+ *  - Removed the line:
+ *
+ *        ( ( (Size) == (entry_ptr)->size ) && ( (len) != 1 ) ) ||
+ *
+ *    from the H5C__DLL_PRE_REMOVE_SC macro.  With the addition of the
+ *    epoch markers used in the age out based cache size reduction algorithm,
+ *    this invarient need not hold, as the epoch markers are of size 0.
+ *
+ *    One could argue that I should have given the epoch markers a positive
+ *    size, but this would break the index_size = LRU_list_size + pl_size
+ *    invarient.
+ *
+ *    Alternatively, I could pass the current decr_mode in to the macro, 
+ *    and just skip the check whenever epoch markers may be in use.
+ *
+ *    However, any size errors should be caught when the cache is flushed
+ *    and destroyed.  Until we are tracking such an error, this should be
+ *    good enough.
+ *                                                     JRM - 12/9/04
+ *
  ****************************************************************************/
 
 #if H5C_DO_SANITY_CHECKS
@@ -130,7 +154,6 @@ if ( ( (head_ptr) == NULL ) ||                                               \
      ( (entry_ptr) == NULL ) ||                                              \
      ( (len) <= 0 ) ||                                                       \
      ( (Size) < (entry_ptr)->size ) ||                                       \
-     ( ( (Size) == (entry_ptr)->size ) && ( (len) != 1 ) ) ||                \
      ( ( (entry_ptr)->prev == NULL ) && ( (head_ptr) != (entry_ptr) ) ) ||   \
      ( ( (entry_ptr)->next == NULL ) && ( (tail_ptr) != (entry_ptr) ) ) ||   \
      ( ( (len) == 1 ) &&                                                     \
@@ -416,8 +439,18 @@ if ( ( (entry_ptr) == NULL ) ||                                                \
  * The following macros must handle stats collection when this collection
  * is enabled, and evaluate to the empty string when it is not.
  *
+ * The sole exception to this rule is 
+ * H5C__UPDATE_CACHE_HIT_RATE_STATS(), which is always active as
+ * the cache hit rate stats are always collected and available.
+ *
  ***********************************************************************/
 
+#define H5C__UPDATE_CACHE_HIT_RATE_STATS(cache_ptr, hit) \
+        (cache_ptr->cache_accesses)++;                   \
+        if ( hit ) {                                     \
+            (cache_ptr->cache_hits)++;                   \
+        }                                                \
+
 #if H5C_COLLECT_CACHE_STATS
 
 #define H5C__UPDATE_STATS_FOR_INSERTION(cache_ptr, entry_ptr)        \
@@ -581,7 +614,7 @@ if ( ( (entry_ptr) == NULL ) ||                                                \
  *
  ***********************************************************************/
 
-#define H5C__HASH_TABLE_LEN	(32 * 1024) /* must be a power of 2 */
+/* H5C__HASH_TABLE_LEN is defined in H5Cpkg.h.  It mut be a power of two. */
 
 #define H5C__HASH_MASK		((size_t)(H5C__HASH_TABLE_LEN - 1) << 3)
 
@@ -807,8 +840,10 @@ if ( ( (cache_ptr) == NULL ) ||                                        \
     HDassert( H5F_addr_defined((entry_ptr)->addr) );                           \
     HDassert( !((entry_ptr)->in_slist) );                                      \
                                                                                \
-    if ( H5SL_insert((cache_ptr)->slist_ptr, &entry_ptr->addr, entry_ptr) < 0 ) \
-        HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "Can't insert entry in skip list") \
+    if ( H5SL_insert((cache_ptr)->slist_ptr, &(entry_ptr)->addr, entry_ptr)    \
+                                                                         < 0 ) \
+        HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL,                             \
+                    "Can't insert entry in skip list")                         \
                                                                                \
     (entry_ptr)->in_slist = TRUE;                                              \
     (cache_ptr)->slist_len++;                                                  \
@@ -1554,556 +1589,202 @@ if ( ( (cache_ptr) == NULL ) ||                                        \
 #endif /* H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS */
 
 
+/*
+ * Private file-scope variables.
+ */
+
+/* Declare a free list to manage the H5C_t struct */
+H5FL_DEFINE_STATIC(H5C_t);
+
+/*
+ * Private file-scope function declarations:
+ */
+
+static herr_t H5C__auto_adjust_cache_size(H5C_t * cache_ptr,
+                                          H5F_t * f,
+                                          hid_t primary_dxpl_id,
+                                          hid_t secondary_dxpl_id,
+                                          hbool_t write_permitted,
+                                          hbool_t * first_flush_ptr);
+
+static herr_t H5C__autoadjust__ageout(H5C_t * cache_ptr,
+                                      double hit_rate,
+                                      enum H5C_resize_status * status_ptr,
+                                      size_t * new_max_cache_size_ptr,
+                                      H5F_t * f,
+                                      hid_t primary_dxpl_id,
+                                      hid_t secondary_dxpl_id,
+                                      hbool_t write_permitted,
+                                      hbool_t * first_flush_ptr);
+
+static herr_t H5C__autoadjust__ageout__cycle_epoch_marker(H5C_t * cache_ptr);
+
+static herr_t H5C__autoadjust__ageout__evict_aged_out_entries(H5F_t * f,
+                                                    hid_t primary_dxpl_id,
+                                                    hid_t secondary_dxpl_id,
+                                                    H5C_t * cache_ptr,
+                                                    hbool_t write_permitted,
+                                                    hbool_t * first_flush_ptr);
+
+static herr_t H5C__autoadjust__ageout__insert_new_marker(H5C_t * cache_ptr);
+
+static herr_t H5C__autoadjust__ageout__remove_all_markers(H5C_t * cache_ptr);
+
+static herr_t H5C__autoadjust__ageout__remove_excess_markers(H5C_t * cache_ptr);
+
+static herr_t H5C_flush_single_entry(H5F_t *             f,
+                                     hid_t               primary_dxpl_id,
+                                     hid_t               secondary_dxpl_id,
+                                     H5C_t *             cache_ptr,
+                                     const H5C_class_t * type_ptr,
+                                     haddr_t             addr,
+                                     unsigned            flags,
+                                     hbool_t *           first_flush_ptr,
+                                     hbool_t    del_entry_from_slist_on_destroy);
+
+static void * H5C_load_entry(H5F_t *             f,
+                             hid_t               dxpl_id,
+                             const H5C_class_t * type,
+                             haddr_t             addr,
+                             const void *        udata1,
+                             void *              udata2,
+                             hbool_t             skip_file_checks);
+
+static herr_t H5C_make_space_in_cache(H5F_t * f,
+                                      hid_t   primary_dxpl_id,
+                                      hid_t   secondary_dxpl_id,
+                                      H5C_t * cache_ptr,
+                                      size_t  space_needed,
+                                      hbool_t write_permitted,
+                                      hbool_t * first_flush_ptr);
+
+
 /****************************************************************************
  *
- * structure H5C_t
- *
- * Catchall structure for all variables specific to an instance of the cache.  
- *
- * While the individual fields of the structure are discussed below, the 
- * following overview may be helpful.
- *
- * Entries in the cache are stored in an instance of H5TB_TREE, indexed on
- * the entry's disk address.  While the H5TB_TREE is less efficient than 
- * hash table, it keeps the entries in address sorted order.  As flushes
- * in parallel mode are more efficient if they are issued in increasing 
- * address order, this is a significant benefit.  Also the H5TB_TREE code
- * was readily available, which reduced development time.
- *
- * While the cache was designed with multiple replacement policies in mind,
- * at present only a modified form of LRU is supported.  
- *
- *                                              JRM - 4/26/04
- *
- * Profiling has indicated that searches in the instance of H5TB_TREE are
- * too expensive.  To deal with this issue, I have augmented the cache 
- * with a hash table in which all entries will be stored.  Given the 
- * advantages of flushing entries in increasing address order, the TBBT 
- * is retained, but only dirty entries are stored in it.  At least for
- * now, we will leave entries in the TBBT after they are flushed.
- *
- * Note that index_size and index_len now refer to the total size of
- * and number of entries in the hash table.
- *
- *						JRM - 7/19/04
- *
- * Note that the dirty entries are now stored in a skip list, instead of
- * the threaded, balanced binary tree (TBBT).
- *
- *						QAK - 11/27/04
- *
- *           *********************************************
- *
- * WARNING:  A copy of H5C_t is in tst/cache.c (under the name "local_H5C_t"
- *	     to allow the test code to access the internal fields of the 
- *	     cache.  If you modify H5C_t, be sure to update local_H5C_t
- *	     in cache.c as well.
- *
- *           *********************************************
- *
- * magic:	Unsigned 32 bit integer always set to H5C__H5C_T_MAGIC.  This
- *		field is used to validate pointers to instances of H5C_t.
- *
- * max_type_id:	Integer field containing the maximum type id number assigned
- *		to a type of entry in the cache.  All type ids from 0 to 
- *		max_type_id inclusive must be defined.  The names of the 
- *		types are stored in the type_name_table discussed below, and
- *		indexed by the ids.
- *
- * type_name_table_ptr: Pointer to an array of pointer to char of length 
- *		max_type_id + 1.  The strings pointed to by the entries
- *		in the array are the names of the entry types associated
- *		with the indexing type IDs.
- *
- * max_cache_size:  Nominal maximum number of bytes that may be stored in the
- *              cache.  This value should be viewed as a soft limit, as the
- *              cache can exceed this value under the following circumstances:
- *
- *              a) All entries in the cache are protected, and the cache is
- *                 asked to insert a new entry.  In this case the new entry
- *                 will be created.  If this causes the cache to exceed
- *                 max_cache_size, it will do so.  The cache will attempt
- *                 to reduce its size as entries are unprotected.
- *
- *              b) When running in parallel mode, the cache may not be 
- *		   permitted to flush a dirty entry in response to a read.  
- *		   If there are no clean entries available to evict, the 
- *		   cache will exceed its maximum size.  Again the cache 
- *                 will attempt to reduce its size to the max_cache_size 
- *                 limit on the next cache write.
- *
- * min_clean_size: Nominal minimum number of clean bytes in the cache.
- *              The cache attempts to maintain this number of bytes of
- *              clean data so as to avoid case b) above.  Again, this is
- *              a soft limit.
- *
- *
- * In addition to the call back functions required for each entry, the 
- * cache requires the following call back functions for this instance of
- * the cache as a whole:
- * 
- * check_write_permitted:  In certain applications, the cache may not 
- *		be allowed to write to disk at certain time.  If specified,
- *		the check_write_permitted function is used to determine if
- *		a write is permissible at any given point in time.
- *
- *		If no such function is specified (i.e. this field is NULL),
- *		the cache will presume that writes are always permissable.
- *
- *
- * The cache requires an index to facilitate searching for entries.  The
- * following fields support that index.
- *
- * index_len:   Number of entries currently in the hash table used to index 
- *		the cache.
- *
- * index_size:  Number of bytes of cache entries currently stored in the
- *              hash table used to index the cache.
- *
- *              This value should not be mistaken for footprint of the
- *              cache in memory.  The average cache entry is small, and
- *              the cache has a considerable overhead.  Multiplying the
- *              index_size by two should yield a conservative estimate
- *              of the cache's memory footprint.
- *
- * index:	Array of pointer to H5C_cache_entry_t of size
- *		H5C__HASH_TABLE_LEN.  At present, this value is a power
- *		of two, not the usual prime number.  
- *
- *		I hope that the variable size of cache elements, the large 
- *		hash table size, and the way in which HDF5 allocates space
- *		will combine to avoid problems with periodicity.  If so, we 
- *		can use a trivial hash function (a bit-and and a 3 bit left 
- *		shift) with some small savings.  
- *
- *		If not, it will become evident in the statistics. Changing
- *		to the usual prime number length hash table will require 
- *		changing the H5C__HASH_FCN macro and the deletion of the
- *		H5C__HASH_MASK #define.  No other changes should be required.
- *
- *
- * When we flush the cache, we need to write entries out in increasing
- * address order.  An instance of a skip list is used to store dirty entries in
- * sorted order.  Whether it is cheaper to sort the dirty entries as needed,
- * or to maintain the list is an open question.  At a guess, it depends
- * on how frequently the cache is flushed.  We will see how it goes.
- *
- * For now at least, I will not remove dirty entries from the list as they
- * are flushed.
- *
- * slist_len:    Number of entries currently in the skip list
- *              used to maintain a sorted list of dirty entries in the 
- *		cache.
- *
- * slist_size:   Number of bytes of cache entries currently stored in the
- *              skip list used to maintain a sorted list of
- *		dirty entries in the cache.
- *
- * slist_ptr:	pointer to the instance of H5SL_t used maintain a sorted
- *		list of dirty entries in the cache.  This sorted list has
- *		two uses:
- *
- *		a) It allows us to flush dirty entries in increasing address
- *		   order, which results in significant savings.
- *
- *		b) It facilitates checking for adjacent dirty entries when
- *		   attempting to evict entries from the cache.  While we
- *		   don't use this at present, I hope that this will allow
- *		   some optimizations when I get to it.
- *
- *
- * When a cache entry is protected, it must be removed from the LRU
- * list(s) as it cannot be either flushed or evicted until it is unprotected.
- * The following fields are used to implement the protected list (pl).
- *
- * pl_len:      Number of entries currently residing on the protected list.
- *
- * pl_size:     Number of bytes of cache entries currently residing on the
- *              protected list.
- *
- * pl_head_ptr: Pointer to the head of the doubly linked list of protected
- *              entries.  Note that cache entries on this list are linked
- *              by their next and prev fields.
- *
- *              This field is NULL if the list is empty.
- *
- * pl_tail_ptr: Pointer to the tail of the doubly linked list of protected
- *              entries.  Note that cache entries on this list are linked
- *              by their next and prev fields.
- *
- *              This field is NULL if the list is empty.
- *
- *
- * The cache must have a replacement policy, and the fields supporting this
- * policy must be accessible from this structure.
- *
- * While there has been interest in several replacement policies for
- * this cache, the initial development schedule is tight.  Thus I have
- * elected to support only a modified LRU policy for the first cut.
- *
- * To further simplify matters, I have simply included the fields needed
- * by the modified LRU in this structure.  When and if we add support for
- * other policies, it will probably be easiest to just add the necessary
- * fields to this structure as well -- we only create one instance of this
- * structure per file, so the overhead is not excessive.
- *
- *
- * Fields supporting the modified LRU policy:
- *
- * See most any OS text for a discussion of the LRU replacement policy.
- *
- * When operating in parallel mode, we must ensure that a read does not
- * cause a write.  If it does, the process will hang, as the write will
- * be collective and the other processes will not know to participate.
- *
- * To deal with this issue, I have modified the usual LRU policy by adding
- * clean and dirty LRU lists to the usual LRU list.
- *
- * The clean LRU list is simply the regular LRU list with all dirty cache
- * entries removed.
- *
- * Similarly, the dirty LRU list is the regular LRU list with all the clean
- * cache entries removed.
- *
- * When reading in parallel mode, we evict from the clean LRU list only.
- * This implies that we must try to ensure that the clean LRU list is
- * reasonably well stocked at all times.
- *
- * We attempt to do this by trying to flush enough entries on each write
- * to keep the cLRU_list_size >= min_clean_size.
- *
- * Even if we start with a completely clean cache, a sequence of protects
- * without unprotects can empty the clean LRU list.  In this case, the
- * cache must grow temporarily.  At the next write, we will attempt to
- * evict enough entries to reduce index_size to less than max_cache_size.
- * While this will usually be possible, all bets are off if enough entries
- * are protected.
- *
- * Discussions of the individual fields used by the modified LRU replacement
- * policy follow:
- *
- * LRU_list_len:  Number of cache entries currently on the LRU list.
- *
- *              Observe that LRU_list_len + pl_len must always equal
- *              index_len.
- *
- * LRU_list_size:  Number of bytes of cache entries currently residing on the
- *              LRU list.
- *
- *              Observe that LRU_list_size + pl_size must always equal
- *              index_size.
- *
- * LRU_head_ptr:  Pointer to the head of the doubly linked LRU list.  Cache
- *              entries on this list are linked by their next and prev fields.
- *
- *              This field is NULL if the list is empty.
- *
- * LRU_tail_ptr:  Pointer to the tail of the doubly linked LRU list.  Cache
- *              entries on this list are linked by their next and prev fields.
- *
- *              This field is NULL if the list is empty.
- *
- * cLRU_list_len: Number of cache entries currently on the clean LRU list.
- *
- *              Observe that cLRU_list_len + dLRU_list_len must always
- *              equal LRU_list_len.
- *
- * cLRU_list_size:  Number of bytes of cache entries currently residing on
- *              the clean LRU list.
- *
- *              Observe that cLRU_list_size + dLRU_list_size must always
- *              equal LRU_list_size.
- *
- * cLRU_head_ptr:  Pointer to the head of the doubly linked clean LRU list.
- *              Cache entries on this list are linked by their aux_next and
- *              aux_prev fields.
- *
- *              This field is NULL if the list is empty.
- *
- * cLRU_tail_ptr:  Pointer to the tail of the doubly linked clean LRU list.
- *              Cache entries on this list are linked by their aux_next and
- *              aux_prev fields.
- *
- *              This field is NULL if the list is empty.
- *
- * dLRU_list_len: Number of cache entries currently on the dirty LRU list.
- *
- *              Observe that cLRU_list_len + dLRU_list_len must always
- *              equal LRU_list_len.
- *
- * dLRU_list_size:  Number of cache entries currently on the dirty LRU list.
- *
- *              Observe that cLRU_list_len + dLRU_list_len must always
- *              equal LRU_list_len.
- *
- * dLRU_head_ptr:  Pointer to the head of the doubly linked dirty LRU list.
- *              Cache entries on this list are linked by their aux_next and
- *              aux_prev fields.
- *
- *              This field is NULL if the list is empty.
- *
- * dLRU_tail_ptr:  Pointer to the tail of the doubly linked dirty LRU list.
- *              Cache entries on this list are linked by their aux_next and
- *              aux_prev fields.
- *
- *              This field is NULL if the list is empty.
- *
- *
- * Statistics collection fields:
- *
- * When enabled, these fields are used to collect statistics as described
- * below.  The first set are collected only when H5C_COLLECT_CACHE_STATS
- * is true.
- *
- * hits:        Array of int64 of length H5C__MAX_NUM_TYPE_IDS.  The cells 
- *		are used to record the number of times an entry with type id 
- *		equal to the array index has been in cache when requested in 
- *		the current epoch.
- *
- * misses:      Array of int64 of length H5C__MAX_NUM_TYPE_IDS.  The cells 
- *		are used to record the number of times an entry with type id 
- *		equal to the array index has not been in cache when 
- *		requested in the current epoch.
- *
- * insertions:  Array of int64 of length H5C__MAX_NUM_TYPE_IDS.  The cells 
- *		are used to record the number of times an entry with type 
- *		id equal to the array index has been inserted into the 
- *		cache in the current epoch.
- *
- * clears:      Array of int64 of length H5C__MAX_NUM_TYPE_IDS.  The cells 
- *		are used to record the number of times an entry with type 
- *		id equal to the array index has been cleared in the current 
- *		epoch.
- *
- * flushes:     Array of int64 of length H5C__MAX_NUM_TYPE_IDS.  The cells 
- *		are used to record the number of times an entry with type id 
- *		equal to the array index has been written to disk in the
- *              current epoch.
- *
- * evictions:   Array of int64 of length H5C__MAX_NUM_TYPE_IDS.  The cells 
- *		are used to record the number of times an entry with type id 
- *		equal to the array index has been evicted from the cache in 
- *		the current epoch.
- *
- * renames:     Array of int64 of length H5C__MAX_NUM_TYPE_IDS.  The cells 
- *		are used to record the number of times an entry with type 
- *		id equal to the array index has been renamed in the current 
- *		epoch.
- *
- * total_ht_insertions: Number of times entries have been inserted into the
- *		hash table in the current epoch.
- *
- * total_ht_deletions: Number of times entries have been deleted from the
- *              hash table in the current epoch.
- *
- * successful_ht_searches: int64 containing the total number of successful 
- *		searches of the hash table in the current epoch.
- *
- * total_successful_ht_search_depth: int64 containing the total number of 
- *		entries other than the targets examined in successful
- *		searches of the hash table in the current epoch.
- *
- * failed_ht_searches: int64 containing the total number of unsuccessful
- *              searches of the hash table in the current epoch.
- *
- * total_failed_ht_search_depth: int64 containing the total number of
- *              entries examined in unsuccessful searches of the hash 
- *		table in the current epoch.
- *
- * max_index_len:  Largest value attained by the index_len field in the
- *              current epoch.
- *
- * max_index_size:  Largest value attained by the index_size field in the
- *              current epoch.
- *
- * max_slist_len:  Largest value attained by the slist_len field in the
- *              current epoch.
- *
- * max_slist_size:  Largest value attained by the slist_size field in the
- *              current epoch.
- *
- * max_pl_len:  Largest value attained by the pl_len field in the
- *              current epoch.
- *
- * max_pl_size: Largest value attained by the pl_size field in the
- *              current epoch.
- *
- * The remaining stats are collected only when both H5C_COLLECT_CACHE_STATS
- * and H5C_COLLECT_CACHE_ENTRY_STATS are true.
- *
- * max_accesses: Array of int32 of length H5C__MAX_NUM_TYPE_IDS.  The cells 
- *		are used to record the maximum number of times any single 
- *		entry with type id equal to the array index has been 
- *		accessed in the current epoch.
- *
- * min_accesses: Array of int32 of length H5C__MAX_NUM_TYPE_IDS.  The cells 
- *		are used to record the minimum number of times any single 
- *		entry with type id equal to the array index has been 
- *		accessed in the current epoch.
- *
- * max_clears:  Array of int32 of length H5C__MAX_NUM_TYPE_IDS.  The cells 
- *		are used to record the maximum number of times any single 
- *		entry with type id equal to the array index has been cleared 
- *		in the current epoch.
- *
- * max_flushes: Array of int32 of length H5C__MAX_NUM_TYPE_IDS.  The cells 
- *		are used to record the maximum number of times any single 
- *		entry with type id equal to the array index has been 
- *		flushed in the current epoch.
- *
- * max_size:	Array of size_t of length H5C__MAX_NUM_TYPE_IDS.  The cells
- *              are used to record the maximum size of any single entry 
- *		with type id equal to the array index that has resided in
- *		the cache in the current epoch.
- *
+ * #defines and declarations for epoch marker cache entries.
  *
- * Fields supporting testing:
- *
- * For test purposes, it is useful to turn off some asserts and sanity
- * checks.  The following flags support this.
- *
- * skip_file_checks:  Boolean flag used to skip sanity checks on file
- *		parameters passed to the cache.  In the test bed, there
- *		is no reason to have a file open, as the cache proper
- *		just passes these parameters through without using them.
- *
- *		When this flag is set, all sanity checks on the file
- *		parameters are skipped.  The field defaults to FALSE.
- *
- * skip_dxpl_id_checks:  Boolean flag used to skip sanity checks on the 
- *		dxpl_id parameters passed to the cache.  These are not
- *		used directly by the cache, so skipping the checks 
- *		simplifies the test bed.
- *
- *		When this flag is set, all sanity checks on the dxpl_id
- *		parameters are skipped.  The field defaults to FALSE.
+ * As a strategy for automatic cache size reduction, the cache may insert
+ * marker entries in the LRU list at the end of each epoch.  These markers
+ * are then used to identify entries that have not been accessed for n
+ * epochs so that they can be evicted from the cache.
  *
  ****************************************************************************/
 
-#define H5C__H5C_T_MAGIC	0x005CAC0E
-#define H5C__MAX_NUM_TYPE_IDS	9
+/* Note that H5C__MAX_EPOCH_MARKERS is defined in H5Cpkg.h, not here because
+ * it is needed to dimension an array in H5C_t.
+ */
 
-struct H5C_t
-{
-    uint32_t			magic;
+#define H5C__EPOCH_MARKER_TYPE	H5C__MAX_NUM_TYPE_IDS
 
-    int32_t			max_type_id;
-    const char *                (* type_name_table_ptr);
+static void *H5C_epoch_marker_load(H5F_t *f, hid_t dxpl_id, haddr_t addr,
+                                   const void *udata1, void *udata2);
+static herr_t H5C_epoch_marker_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest,
+                                     haddr_t addr, void *thing);
+static herr_t H5C_epoch_marker_dest(H5F_t *f, void *thing);
+static herr_t H5C_epoch_marker_clear(H5F_t *f, void *thing, hbool_t dest);
+static herr_t H5C_epoch_marker_size(H5F_t *f, void *thing, size_t *size_ptr);
 
-    size_t                      max_cache_size;
-    size_t                      min_clean_size;
+const H5C_class_t epoch_marker_class =
+{
+    /* id    = */ H5C__EPOCH_MARKER_TYPE,
+    /* load  = */ &H5C_epoch_marker_load,
+    /* flush = */ &H5C_epoch_marker_flush,
+    /* dest  = */ &H5C_epoch_marker_dest,
+    /* clear = */ &H5C_epoch_marker_clear,
+    /* size  = */ &H5C_epoch_marker_size
+};
 
-    H5C_write_permitted_func_t	check_write_permitted;
+/***************************************************************************
+ * Class functions for H5C__EPOCH_MAKER_TYPE:
+ *
+ * None of these functions should ever be called, so there is no point in
+ * documenting them separately.
+ *                                                     JRM - 11/16/04
+ *
+ ***************************************************************************/
 
-    int32_t                     index_len;
-    size_t                      index_size;
-    H5C_cache_entry_t *		(index[H5C__HASH_TABLE_LEN]);
+static void *
+H5C_epoch_marker_load(UNUSED H5F_t *f, 
+                      UNUSED hid_t dxpl_id, 
+                      UNUSED haddr_t addr,
+                      UNUSED const void *udata1, 
+                      UNUSED void *udata2)
+{
+    void * ret_value = NULL;      /* Return value */
 
+    FUNC_ENTER_NOAPI(H5C_epoch_marker_load, NULL)
 
-    int32_t                     slist_len;
-    size_t                      slist_size;
-    H5SL_t *                    slist_ptr;
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, NULL, "called unreachable fcn.")
 
-    int32_t                     pl_len;
-    size_t                      pl_size;
-    H5C_cache_entry_t *	        pl_head_ptr;
-    H5C_cache_entry_t *  	pl_tail_ptr;
+done:
 
-    int32_t                     LRU_list_len;
-    size_t                      LRU_list_size;
-    H5C_cache_entry_t *		LRU_head_ptr;
-    H5C_cache_entry_t *		LRU_tail_ptr;
+    FUNC_LEAVE_NOAPI(ret_value)
+}
 
-    int32_t                     cLRU_list_len;
-    size_t                      cLRU_list_size;
-    H5C_cache_entry_t *		cLRU_head_ptr;
-    H5C_cache_entry_t *		cLRU_tail_ptr;
+static herr_t 
+H5C_epoch_marker_flush(UNUSED H5F_t *f, 
+                       UNUSED hid_t dxpl_id, 
+                       UNUSED hbool_t dest,
+                       UNUSED haddr_t addr, 
+                       UNUSED void *thing)
+{
+    herr_t ret_value = FAIL;      /* Return value */
 
-    int32_t                     dLRU_list_len;
-    size_t                      dLRU_list_size;
-    H5C_cache_entry_t *		dLRU_head_ptr;
-    H5C_cache_entry_t *	        dLRU_tail_ptr;
+    FUNC_ENTER_NOAPI(H5C_epoch_marker_flush, FAIL)
 
-#if H5C_COLLECT_CACHE_STATS
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "called unreachable fcn.")
 
-    /* stats fields */
-    int64_t                     hits[H5C__MAX_NUM_TYPE_IDS];
-    int64_t                     misses[H5C__MAX_NUM_TYPE_IDS];
-    int64_t                     insertions[H5C__MAX_NUM_TYPE_IDS];
-    int64_t                     clears[H5C__MAX_NUM_TYPE_IDS];
-    int64_t                     flushes[H5C__MAX_NUM_TYPE_IDS];
-    int64_t                     evictions[H5C__MAX_NUM_TYPE_IDS];
-    int64_t                     renames[H5C__MAX_NUM_TYPE_IDS];
+done:
 
-    int64_t			total_ht_insertions;
-    int64_t			total_ht_deletions;
-    int64_t			successful_ht_searches;
-    int64_t			total_successful_ht_search_depth;
-    int64_t			failed_ht_searches;
-    int64_t			total_failed_ht_search_depth;
+    FUNC_LEAVE_NOAPI(ret_value)
+}
 
-    int32_t                     max_index_len;
-    size_t                      max_index_size;
+static herr_t 
+H5C_epoch_marker_dest(UNUSED H5F_t *f, 
+                      UNUSED void *thing)
+{
+    herr_t ret_value = FAIL;      /* Return value */
 
-    int32_t                     max_slist_len;
-    size_t                      max_slist_size;
+    FUNC_ENTER_NOAPI(H5C_epoch_marker_dest, FAIL)
 
-    int32_t                     max_pl_len;
-    size_t                      max_pl_size;
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "called unreachable fcn.")
 
-#if H5C_COLLECT_CACHE_ENTRY_STATS
+done:
 
-    int32_t                     max_accesses[H5C__MAX_NUM_TYPE_IDS];
-    int32_t                     min_accesses[H5C__MAX_NUM_TYPE_IDS];
-    int32_t                     max_clears[H5C__MAX_NUM_TYPE_IDS];
-    int32_t                     max_flushes[H5C__MAX_NUM_TYPE_IDS];
-    size_t                      max_size[H5C__MAX_NUM_TYPE_IDS];
+    FUNC_LEAVE_NOAPI(ret_value)
+}
 
-#endif /* H5C_COLLECT_CACHE_ENTRY_STATS */
+static herr_t 
+H5C_epoch_marker_clear(UNUSED H5F_t *f, 
+                       UNUSED void *thing, 
+                       UNUSED hbool_t dest)
+{
+    herr_t ret_value = FAIL;      /* Return value */
 
-#endif /* H5C_COLLECT_CACHE_STATS */
+    FUNC_ENTER_NOAPI(H5C_epoch_marker_clear, FAIL)
 
-    hbool_t			skip_file_checks;
-    hbool_t			skip_dxpl_id_checks;
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "called unreachable fcn.")
 
-};
+done:
 
-
-/*
- * Private file-scope variables.
- */
+    FUNC_LEAVE_NOAPI(ret_value)
+}
 
-/* Declare a free list to manage the H5C_t struct */
-H5FL_DEFINE_STATIC(H5C_t);
+static herr_t 
+H5C_epoch_marker_size(UNUSED H5F_t *f, 
+                      UNUSED void *thing, 
+                      UNUSED size_t *size_ptr)
+{
+    herr_t ret_value = FAIL;      /* Return value */
 
-/*
- * Private file-scope function declarations:
- */
+    FUNC_ENTER_NOAPI(H5C_epoch_marker_size, FAIL)
 
-static herr_t H5C_flush_single_entry(H5F_t *             f,
-                                     hid_t               primary_dxpl_id,
-                                     hid_t               secondary_dxpl_id,
-                                     H5C_t *             cache_ptr,
-                                     const H5C_class_t * type_ptr,
-                                     haddr_t             addr,
-                                     unsigned            flags,
-                                     hbool_t *           first_flush_ptr,
-                                     hbool_t    del_entry_from_slist_on_destroy);
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "called unreachable fcn.")
 
-static void * H5C_load_entry(H5F_t *             f,
-                             hid_t               dxpl_id,
-                             const H5C_class_t * type,
-                             haddr_t             addr,
-                             const void *        udata1,
-                             void *              udata2,
-                             hbool_t             skip_file_checks);
+done:
 
-static herr_t H5C_make_space_in_cache(H5F_t * f,
-                                      hid_t   primary_dxpl_id,
-                                      hid_t   secondary_dxpl_id,
-                                      H5C_t * cache_ptr,
-                                      size_t  space_needed,
-                                      hbool_t write_permitted);
+    FUNC_LEAVE_NOAPI(ret_value)
+}
 
 
 /*-------------------------------------------------------------------------
@@ -2133,6 +1814,18 @@ static herr_t H5C_make_space_in_cache(H5F_t * f,
  *		JRM -- 7/20/04
  *		Updated for the addition of the hash table.
  *
+ *		JRM -- 10/5/04
+ *		Added call to H5C_reset_cache_hit_rate_stats().  Also
+ *		added initialization for cache_is_full flag and for 
+ *		resize_ctl.
+ *
+ *		JRM -- 11/12/04
+ *		Added initialization for the new size_decreased field.
+ *
+ *		JRM -- 11/17/04
+ *		Added/updated initialization for the automatic cache
+ *		size control data structures.
+ *
  *-------------------------------------------------------------------------
  */
 
@@ -2179,51 +1872,118 @@ H5C_create(size_t		      max_cache_size,
      * the fields.
      */
 
-    cache_ptr->magic 			= H5C__H5C_T_MAGIC;
+    cache_ptr->magic 				= H5C__H5C_T_MAGIC;
 
-    cache_ptr->max_type_id		= max_type_id;
-    cache_ptr->type_name_table_ptr	= type_name_table_ptr;
+    cache_ptr->max_type_id			= max_type_id;
+    cache_ptr->type_name_table_ptr		= type_name_table_ptr;
 
-    cache_ptr->max_cache_size		= max_cache_size;
-    cache_ptr->min_clean_size		= min_clean_size;
+    cache_ptr->max_cache_size			= max_cache_size;
+    cache_ptr->min_clean_size			= min_clean_size;
 
-    cache_ptr->check_write_permitted	= check_write_permitted;
+    cache_ptr->check_write_permitted		= check_write_permitted;
 
-    cache_ptr->index_len		= 0;
-    cache_ptr->index_size		= (size_t)0;
+    cache_ptr->index_len			= 0;
+    cache_ptr->index_size			= (size_t)0;
 
     cache_ptr->slist_len			= 0;
-    cache_ptr->slist_size		= (size_t)0;
+    cache_ptr->slist_size			= (size_t)0;
 
     for ( i = 0; i < H5C__HASH_TABLE_LEN; i++ )
     {
         (cache_ptr->index)[i] = NULL;
     }
 
-    cache_ptr->pl_len			= 0;
-    cache_ptr->pl_size			= (size_t)0;
-    cache_ptr->pl_head_ptr		= NULL;
-    cache_ptr->pl_tail_ptr		= NULL;
-
-    cache_ptr->LRU_list_len		= 0;
-    cache_ptr->LRU_list_size		= (size_t)0;
-    cache_ptr->LRU_head_ptr		= NULL;
-    cache_ptr->LRU_tail_ptr		= NULL;
+    cache_ptr->pl_len				= 0;
+    cache_ptr->pl_size				= (size_t)0;
+    cache_ptr->pl_head_ptr			= NULL;
+    cache_ptr->pl_tail_ptr			= NULL;
+
+    cache_ptr->LRU_list_len			= 0;
+    cache_ptr->LRU_list_size			= (size_t)0;
+    cache_ptr->LRU_head_ptr			= NULL;
+    cache_ptr->LRU_tail_ptr			= NULL;
+
+    cache_ptr->cLRU_list_len			= 0;
+    cache_ptr->cLRU_list_size			= (size_t)0;
+    cache_ptr->cLRU_head_ptr			= NULL;
+    cache_ptr->cLRU_tail_ptr			= NULL;
+
+    cache_ptr->dLRU_list_len			= 0;
+    cache_ptr->dLRU_list_size			= (size_t)0;
+    cache_ptr->dLRU_head_ptr			= NULL;
+    cache_ptr->dLRU_tail_ptr			= NULL;
+
+    cache_ptr->size_increase_possible		= FALSE;
+    cache_ptr->size_decrease_possible		= FALSE;
+    cache_ptr->resize_enabled			= FALSE;
+    cache_ptr->cache_full			= FALSE;
+    cache_ptr->size_decreased			= FALSE;
+
+    (cache_ptr->resize_ctl).version		= H5C__CURR_AUTO_SIZE_CTL_VER;
+    (cache_ptr->resize_ctl).rpt_fcn		= NULL;
+    (cache_ptr->resize_ctl).set_initial_size	= FALSE;
+    (cache_ptr->resize_ctl).initial_size	= H5C__DEF_AR_INIT_SIZE;
+    (cache_ptr->resize_ctl).min_clean_fraction	= H5C__DEF_AR_MIN_CLEAN_FRAC;
+    (cache_ptr->resize_ctl).max_size		= H5C__DEF_AR_MAX_SIZE;
+    (cache_ptr->resize_ctl).min_size		= H5C__DEF_AR_MIN_SIZE;
+    (cache_ptr->resize_ctl).epoch_length	= H5C__DEF_AR_EPOCH_LENGTH;
+
+    (cache_ptr->resize_ctl).incr_mode		= H5C_incr__off;
+    (cache_ptr->resize_ctl).lower_hr_threshold	= H5C__DEF_AR_LOWER_THRESHHOLD;
+    (cache_ptr->resize_ctl).increment	        = H5C__DEF_AR_INCREMENT;
+    (cache_ptr->resize_ctl).apply_max_increment	= TRUE;
+    (cache_ptr->resize_ctl).max_increment	= H5C__DEF_AR_MAX_INCREMENT;
+
+    (cache_ptr->resize_ctl).decr_mode		= H5C_decr__off;
+    (cache_ptr->resize_ctl).upper_hr_threshold	= H5C__DEF_AR_UPPER_THRESHHOLD;
+    (cache_ptr->resize_ctl).decrement	        = H5C__DEF_AR_DECREMENT;
+    (cache_ptr->resize_ctl).apply_max_decrement	= TRUE;
+    (cache_ptr->resize_ctl).max_decrement	= H5C__DEF_AR_MAX_DECREMENT;
+    (cache_ptr->resize_ctl).epochs_before_eviction = H5C__DEF_AR_EPCHS_B4_EVICT;
+    (cache_ptr->resize_ctl).apply_empty_reserve = TRUE;
+    (cache_ptr->resize_ctl).empty_reserve	= H5C__DEF_AR_EMPTY_RESERVE;
+
+    cache_ptr->epoch_markers_active		= 0;
+
+    /* no need to initialize the ring buffer itself */
+    cache_ptr->epoch_marker_ringbuf_first	= 1;
+    cache_ptr->epoch_marker_ringbuf_last	= 0;
+    cache_ptr->epoch_marker_ringbuf_size	= 0;
+
+    for ( i = 0; i < H5C__MAX_EPOCH_MARKERS; i++ )
+    {
+        (cache_ptr->epoch_marker_active)[i]		= FALSE;
+
+        ((cache_ptr->epoch_markers)[i]).addr		= (haddr_t)i;
+        ((cache_ptr->epoch_markers)[i]).size		= (size_t)0;
+        ((cache_ptr->epoch_markers)[i]).type		= &epoch_marker_class;
+        ((cache_ptr->epoch_markers)[i]).is_dirty	= FALSE;
+        ((cache_ptr->epoch_markers)[i]).is_protected	= FALSE;
+        ((cache_ptr->epoch_markers)[i]).in_slist	= FALSE;
+        ((cache_ptr->epoch_markers)[i]).ht_next		= NULL;
+        ((cache_ptr->epoch_markers)[i]).ht_prev		= NULL;
+        ((cache_ptr->epoch_markers)[i]).next		= NULL;
+        ((cache_ptr->epoch_markers)[i]).prev		= NULL;
+        ((cache_ptr->epoch_markers)[i]).aux_next	= NULL;
+        ((cache_ptr->epoch_markers)[i]).aux_prev	= NULL;
+#if H5C_COLLECT_CACHE_ENTRY_STATS
+        ((cache_ptr->epoch_markers)[i]).accesses	= 0;
+        ((cache_ptr->epoch_markers)[i]).clears		= 0;
+        ((cache_ptr->epoch_markers)[i]).flushes		= 0;
+#endif /* H5C_COLLECT_CACHE_ENTRY_STATS */
+    }
 
-    cache_ptr->cLRU_list_len		= 0;
-    cache_ptr->cLRU_list_size		= (size_t)0;
-    cache_ptr->cLRU_head_ptr		= NULL;
-    cache_ptr->cLRU_tail_ptr		= NULL;
+    if ( H5C_reset_cache_hit_rate_stats(cache_ptr) != SUCCEED ) {
 
-    cache_ptr->dLRU_list_len		= 0;
-    cache_ptr->dLRU_list_size		= (size_t)0;
-    cache_ptr->dLRU_head_ptr		= NULL;
-    cache_ptr->dLRU_tail_ptr		= NULL;
+        /* this should be impossible... */
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, NULL, \
+                    "H5C_reset_cache_hit_rate_stats failed.")
+    }
 
     H5C_stats__reset(cache_ptr);
 
-    cache_ptr->skip_file_checks		= FALSE;
-    cache_ptr->skip_dxpl_id_checks	= FALSE;
+    cache_ptr->skip_file_checks			= FALSE;
+    cache_ptr->skip_dxpl_id_checks		= FALSE;
 
     /* Set return value */
     ret_value = cache_ptr;
@@ -2251,6 +2011,158 @@ done:
 
 
 /*-------------------------------------------------------------------------
+ * Function:    H5C_def_auto_resize_rpt_fcn
+ *
+ * Purpose:     Print results of a automatic cache resize.
+ *
+ *		This function should only be used where HDprintf() behaves
+ *		well -- i.e. not on Windows.
+ *		
+ * Return:      void
+ *
+ * Programmer:  John Mainzer
+ *		10/27/04
+ *
+ * Modifications:
+ *
+ *		JRM -- 11/22/04
+ *		Reworked function to adapt it to the addition of the 
+ *		ageout method of cache size reduction.
+ *
+ *-------------------------------------------------------------------------
+ */
+void 
+H5C_def_auto_resize_rpt_fcn(H5C_t * cache_ptr,
+                            int32_t version,
+                            double hit_rate,
+                            enum H5C_resize_status status,
+                            size_t old_max_cache_size,
+                            size_t new_max_cache_size,
+                            size_t old_min_clean_size,
+                            size_t new_min_clean_size)
+{
+    HDassert( cache_ptr != NULL );
+    HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
+    HDassert( version == H5C__CURR_AUTO_RESIZE_RPT_FCN_VER );
+
+    switch ( status )
+    {
+        case in_spec:
+            HDfprintf(stdout, "Auto cache resize -- no change. ");
+            HDfprintf(stdout, "(hit rate = %lf)\n", hit_rate);
+            break;
+
+        case increase:
+            HDassert( hit_rate < (cache_ptr->resize_ctl).lower_hr_threshold );
+            HDassert( old_max_cache_size < new_max_cache_size );
+
+            HDfprintf(stdout, "Auto cache resize -- hit rate (%lf) ", hit_rate);
+
+            HDfprintf(stdout, "out of bounds low (%6.5lf).\n",
+                      (cache_ptr->resize_ctl).lower_hr_threshold);
+
+            HDfprintf(stdout, 
+                      "	cache size increased from (%Zu/%Zu) to (%Zu/%Zu).\n",
+                      old_max_cache_size,
+                      old_min_clean_size,
+                      new_max_cache_size,
+                      new_min_clean_size);
+            break;
+
+        case decrease:
+            HDassert( old_max_cache_size > new_max_cache_size );
+
+            switch ( (cache_ptr->resize_ctl).decr_mode )
+            {
+                case H5C_decr__threshold:
+                    HDassert( hit_rate >
+                              (cache_ptr->resize_ctl).upper_hr_threshold );
+
+                    HDfprintf(stdout, 
+                              "Auto cache resize -- decrease by threshold.  ");
+
+                    HDfprintf(stdout, "HR = %lf > %6.5lf\n", 
+                              hit_rate, 
+                              (cache_ptr->resize_ctl).upper_hr_threshold);
+
+                    HDfprintf(stdout, "out of bounds high (%6.5lf).\n",
+                              (cache_ptr->resize_ctl).upper_hr_threshold);
+                    break;
+
+                case H5C_decr__age_out:
+                    HDfprintf(stdout, 
+                              "Auto cache resize -- decrease by ageout. ");
+                    HDfprintf(stdout, "HR = %lf\n", hit_rate);
+                    break;
+
+                case H5C_decr__age_out_with_threshold:
+                    HDassert( hit_rate >
+                              (cache_ptr->resize_ctl).upper_hr_threshold );
+
+                    HDfprintf(stdout, 
+                              "Auto cache resize -- decrease by ageout with ");
+                    HDfprintf(stdout, "threshold. HR = %lf > %6.5lf\n",
+                              hit_rate, 
+                              (cache_ptr->resize_ctl).upper_hr_threshold);
+                    break;
+
+                default:
+                    HDfprintf(stdout, 
+                              "Auto cache resize -- decrease by unknown mode.");
+                    HDfprintf(stdout, " HR = %lf\n", hit_rate);
+            }
+
+            HDfprintf(stdout, 
+                      "	cache size decreased from (%Zu/%Zu) to (%Zu/%Zu).\n",
+                      old_max_cache_size,
+                      old_min_clean_size,
+                      new_max_cache_size,
+                      new_min_clean_size);
+            break;
+
+        case at_max_size:
+            HDfprintf(stdout, "Auto cache resize -- hit rate (%lf) ", hit_rate);
+            HDfprintf(stdout, "out of bounds low (%6.5lf).\n",
+                      (cache_ptr->resize_ctl).lower_hr_threshold);
+            HDfprintf(stdout, "	cache already at maximum size so no change.\n");
+            break;
+
+        case at_min_size:
+            HDfprintf(stdout, "Auto cache resize -- hit rate (%lf) ", hit_rate);
+            HDfprintf(stdout, "-- can't decrease.\n");
+            HDfprintf(stdout, "	cache already at minimum size.\n");
+            break;
+
+        case increase_disabled:
+            HDfprintf(stdout, "Auto cache resize -- increase disabled -- ");
+            HDfprintf(stdout, "HR = %lf.", hit_rate);
+            break;
+
+        case decrease_disabled:
+            HDfprintf(stdout, "Auto cache resize -- decrease disabled -- ");
+            HDfprintf(stdout, "HR = %lf.\n", hit_rate);
+            break;
+
+        case not_full:
+            HDassert( hit_rate < (cache_ptr->resize_ctl).lower_hr_threshold );
+
+            HDfprintf(stdout, "Auto cache resize -- hit rate (%lf) ", hit_rate);
+            HDfprintf(stdout, "out of bounds low (%6.5lf).\n",
+                      (cache_ptr->resize_ctl).lower_hr_threshold);
+            HDfprintf(stdout, "	cache not full so no increase in size.\n");
+            break;
+
+        default:
+            HDfprintf(stdout, "Auto cache resize -- unknown status code.\n");
+            break;
+    }
+
+    return;
+
+} /* H5C_def_auto_resize_rpt_fcn() */
+
+
+/*-------------------------------------------------------------------------
  * Function:    H5C_dest
  *
  * Purpose:     Flush all data to disk and destroy the cache.
@@ -2274,6 +2186,8 @@ done:
  *
  * Modifications:
  *
+ *              None.
+ *
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -2282,7 +2196,7 @@ H5C_dest(H5F_t * f,
          hid_t	 secondary_dxpl_id, 
          H5C_t * cache_ptr)
 {
-    herr_t ret_value=SUCCEED;      /* Return value */
+    herr_t ret_value = SUCCEED;      /* Return value */
 
     FUNC_ENTER_NOAPI(H5C_dest, FAIL)
 
@@ -2328,6 +2242,8 @@ done:
  *
  * Modifications:
  *
+ *		None.
+ *
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -2394,6 +2310,13 @@ done:
  *		JRM -- 7/20/04
  *		Modified the function for the addition of the hash table.
  *
+ *		JRM -- 11/22/04
+ *		Added code to remove all epoch markers (if any) from the
+ *		LRU list before a destroy.  Strictly speaking, this isn't
+ *		necessary, as the marker entries reside only in the LRU
+ *		list, never in the index or in the tree.  However, it 
+ *		never hurts to tidy up.
+ *
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -2423,6 +2346,18 @@ H5C_flush_cache(H5F_t *  f,
     HDassert( cache_ptr->skip_file_checks || f );
     HDassert( cache_ptr->slist_ptr );
 
+    if ( ( destroy ) && ( cache_ptr->epoch_markers_active > 0 ) ) {
+
+        status = H5C__autoadjust__ageout__remove_all_markers(cache_ptr);
+
+        if ( status != SUCCEED ) {
+
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
+                        "error removing all epoch markers.")
+        }
+    }
+
+
     if ( cache_ptr->slist_len == 0 ) {
 
         node_ptr = NULL;
@@ -2464,7 +2399,7 @@ H5C_flush_cache(H5F_t *  f,
                                             &first_flush, 
                                             FALSE);
             if ( status < 0 ) {
-                
+
                 /* This shouldn't happen -- if it does, we are toast so
                  * just scream and die.
                  */
@@ -2532,7 +2467,7 @@ H5C_flush_cache(H5F_t *  f,
                                                     &first_flush, 
                                                     FALSE);
                     if ( status < 0 ) {
-                
+
                         /* This shouldn't happen -- if it does, we are toast so
                          * just scream and die.
                          */
@@ -2585,6 +2520,179 @@ done:
 
 
 /*-------------------------------------------------------------------------
+ * Function:    H5C_get_cache_auto_resize_config
+ *
+ * Purpose:	Copy the current configuration of the cache automatic 
+ *		re-sizing function into the instance of H5C_auto_size_ctl_t
+ *		pointed to by config_ptr.
+ *
+ * Return:      SUCCEED on success, and FAIL on failure.
+ *
+ * Programmer:  John Mainzer
+ *		10/8/04
+ *
+ * Modifications:
+ *
+ *		None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+herr_t
+H5C_get_cache_auto_resize_config(H5C_t * cache_ptr, 
+                                 H5C_auto_size_ctl_t *config_ptr)
+{
+    herr_t ret_value = SUCCEED;      /* Return value */
+
+    FUNC_ENTER_NOAPI(H5C_get_cache_auto_resize_config, FAIL)
+
+    if ( ( cache_ptr == NULL ) || ( cache_ptr->magic != H5C__H5C_T_MAGIC ) ) {
+
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Bad cache_ptr on entry.")
+    }
+
+    if ( config_ptr == NULL ) {
+
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Bad config_ptr on entry.")
+    }
+
+    *config_ptr = cache_ptr->resize_ctl;
+
+    config_ptr->set_initial_size = FALSE;
+    config_ptr->initial_size = cache_ptr->max_cache_size;
+
+done:
+
+    FUNC_LEAVE_NOAPI(ret_value)
+
+} /* H5C_get_cache_auto_resize_config() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5C_get_cache_size
+ *
+ * Purpose:	Return the cache maximum size, the minimum clean size, the 
+ *		current size, and the current number of entries in 
+ *              *max_size_ptr, *min_clean_size_ptr, *cur_size_ptr, and
+ *		*cur_num_entries_ptr respectively.  If any of these 
+ *		parameters are NULL, skip that value.
+ *
+ * Return:      SUCCEED on success, and FAIL on failure.
+ *
+ * Programmer:  John Mainzer
+ *		10/8/04
+ *
+ * Modifications:
+ *
+ *		None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+herr_t
+H5C_get_cache_size(H5C_t * cache_ptr, 
+                   size_t * max_size_ptr,
+                   size_t * min_clean_size_ptr,
+                   size_t * cur_size_ptr,
+                   int32_t * cur_num_entries_ptr)
+{
+    herr_t ret_value = SUCCEED;      /* Return value */
+
+    FUNC_ENTER_NOAPI(H5C_get_cache_size, FAIL)
+
+    if ( ( cache_ptr == NULL ) || ( cache_ptr->magic != H5C__H5C_T_MAGIC ) ) {
+
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Bad cache_ptr on entry.")
+    }
+
+    if ( max_size_ptr != NULL ) {
+
+        *max_size_ptr = cache_ptr->max_cache_size;
+    }
+
+    if ( min_clean_size_ptr != NULL ) {
+
+        *min_clean_size_ptr = cache_ptr->min_clean_size;
+    }
+
+    if ( cur_size_ptr != NULL ) {
+
+        *cur_size_ptr = cache_ptr->index_size;
+    }
+
+    if ( cur_num_entries_ptr != NULL ) {
+
+        *cur_num_entries_ptr = cache_ptr->index_len;
+    }
+
+done:
+
+    FUNC_LEAVE_NOAPI(ret_value)
+
+} /* H5C_get_cache_size() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5C_get_cache_hit_rate
+ *
+ * Purpose:	Compute and return the current cache hit rate in 
+ *              *hit_rate_ptr.  If there have been no accesses since the 
+ *              last time the cache hit rate stats were reset, set
+ *		*hit_rate_ptr to 0.0.  On error, *hit_rate_ptr is 
+ *		undefined.
+ *
+ * Return:      SUCCEED on success, and FAIL on failure.
+ *
+ * Programmer:  John Mainzer
+ *		10/7/04
+ *
+ * Modifications:
+ *
+ *		None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+herr_t
+H5C_get_cache_hit_rate(H5C_t * cache_ptr,
+                       double * hit_rate_ptr)
+
+{
+    herr_t ret_value = SUCCEED;      /* Return value */
+
+    FUNC_ENTER_NOAPI(H5C_get_cache_hit_rate, FAIL)
+
+    if ( ( cache_ptr == NULL ) || ( cache_ptr->magic != H5C__H5C_T_MAGIC ) ) {
+
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Bad cache_ptr on entry.")
+    }
+
+    if ( hit_rate_ptr == NULL ) {
+
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Bad hit_rate_ptr on entry.")
+    }
+
+    HDassert( cache_ptr->cache_hits >= 0 );
+    HDassert( cache_ptr->cache_accesses >= cache_ptr->cache_hits );
+
+    if ( cache_ptr->cache_accesses > 0 ) {
+
+        *hit_rate_ptr = ((double)(cache_ptr->cache_hits)) /
+                         ((double)(cache_ptr->cache_accesses));
+
+    } else {
+
+        *hit_rate_ptr = 0.0;
+    }
+
+done:
+
+    FUNC_LEAVE_NOAPI(ret_value)
+
+} /* H5C_get_cache_hit_rate() */
+
+
+/*-------------------------------------------------------------------------
  * Function:    H5C_insert_entry
  *
  * Purpose:     Adds the specified thing to the cache.  The thing need not
@@ -2614,6 +2722,14 @@ done:
  *		JRM -- 7/21/04
  *		Updated function for the addition of the hash table.
  *
+ *		JRM -- 10/28/04
+ *		Added code to set the cache_full flag to TRUE when ever
+ *		we need to make space in the cache.
+ *
+ *		JRM --11/22/04
+ *		Updated function for the addition of the first_flush_ptr
+ *		parameter to H5C_make_space_in_cache().
+ *
  *-------------------------------------------------------------------------
  */
 
@@ -2628,6 +2744,7 @@ H5C_insert_entry(H5F_t * 	     f,
 {
     herr_t		result;
     herr_t		ret_value = SUCCEED;    /* Return value */
+    hbool_t		first_flush = TRUE;
     hbool_t		write_permitted = TRUE;
     H5C_cache_entry_t *	entry_ptr;
     H5C_cache_entry_t *	test_entry_ptr;
@@ -2673,6 +2790,8 @@ H5C_insert_entry(H5F_t * 	     f,
 
         size_t space_needed;
 
+        cache_ptr->cache_full = TRUE;
+
         if ( cache_ptr->check_write_permitted != NULL ) {
 
             result = (cache_ptr->check_write_permitted)(f, 
@@ -2720,7 +2839,8 @@ H5C_insert_entry(H5F_t * 	     f,
                                          secondary_dxpl_id,
                                          cache_ptr, 
                                          space_needed, 
-                                         write_permitted);
+                                         write_permitted,
+                                         &first_flush);
 
         if ( result < 0 ) {
 
@@ -2917,26 +3037,39 @@ done:
  *
  * Modifications:
  *
- *		JRM - 7/21/04
+ *		JRM -- 7/21/04
  *		Updated for the addition of the hash table.
  *
+ *		JRM -- 10/28/04
+ *		Added code to set cache_full to TRUE whenever we try to 
+ *		make space in the cache.
+ *
+ *		JRM -- 11/12/04
+ *		Added code to call to H5C_make_space_in_cache()	after the 
+ *		call to H5C__auto_adjust_cache_size() if that function 
+ *		sets the size_decreased flag is TRUE.
+ *
  *-------------------------------------------------------------------------
  */
 
 void *
 H5C_protect(H5F_t *	       f, 
-           hid_t	       primary_dxpl_id, 
-           hid_t	       secondary_dxpl_id, 
-           H5C_t *	       cache_ptr,
-           const H5C_class_t * type, 
-           haddr_t 	       addr,
-           const void *	       udata1, 
-           void *	       udata2)
+            hid_t	       primary_dxpl_id, 
+            hid_t	       secondary_dxpl_id, 
+            H5C_t *	       cache_ptr,
+            const H5C_class_t * type, 
+            haddr_t 	       addr,
+            const void *       udata1, 
+            void *	       udata2)
 {
     hbool_t		hit = FALSE;
+    hbool_t		first_flush = TRUE;
+    hbool_t		have_write_permitted = FALSE;
+    hbool_t		write_permitted = TRUE;
+    herr_t		result;
     void *		thing = NULL;
     H5C_cache_entry_t *	entry_ptr;
-    void *		ret_value;      /* Return value */
+    void *		ret_value = NULL;      /* Return value */
 
     FUNC_ENTER_NOAPI(H5C_protect, NULL)
 
@@ -2960,6 +3093,7 @@ H5C_protect(H5F_t *	       f,
     } else { /* must try to load the entry from disk. */
 
         hit = FALSE;
+
         thing = H5C_load_entry(f, primary_dxpl_id, type, addr, udata1, udata2,
                                cache_ptr->skip_file_checks);
 
@@ -2974,10 +3108,10 @@ H5C_protect(H5F_t *	       f,
         if ( (cache_ptr->index_size + entry_ptr->size) > 
               cache_ptr->max_cache_size ) {
 
-            hbool_t write_permitted = TRUE;
-            herr_t result;
             size_t space_needed;
 
+            cache_ptr->cache_full = TRUE;
+
             if ( cache_ptr->check_write_permitted != NULL ) {
 
                 result = (cache_ptr->check_write_permitted)(f, 
@@ -2987,8 +3121,15 @@ H5C_protect(H5F_t *	       f,
                 if ( result < 0 ) {
 
                     HGOTO_ERROR(H5E_CACHE, H5E_CANTPROTECT, NULL, \
-                               "Can't get write_permitted")
+                               "Can't get write_permitted 1")
+
+                } else {
+
+                    have_write_permitted = TRUE;
                 }
+            } else {
+
+                have_write_permitted = TRUE;
             }
 
             HDassert( entry_ptr->size <= H5C_MAX_ENTRY_SIZE );
@@ -3022,12 +3163,13 @@ H5C_protect(H5F_t *	       f,
 
             result = H5C_make_space_in_cache(f, primary_dxpl_id, 
                                              secondary_dxpl_id, cache_ptr, 
-                                             space_needed, write_permitted);
+                                             space_needed, write_permitted,
+                                             &first_flush);
 
             if ( result < 0 ) {
 
                 HGOTO_ERROR(H5E_CACHE, H5E_CANTPROTECT, NULL, \
-                            "H5C_make_space_in_cache failed.")
+                            "H5C_make_space_in_cache failed 1.")
             }
         }
 
@@ -3059,8 +3201,80 @@ H5C_protect(H5F_t *	       f,
 
     ret_value = thing;
 
+    H5C__UPDATE_CACHE_HIT_RATE_STATS(cache_ptr, hit)
+
     H5C__UPDATE_STATS_FOR_PROTECT(cache_ptr, entry_ptr, hit)
 
+    if ( ( cache_ptr->resize_enabled ) &&
+         ( cache_ptr->cache_accesses >= 
+           (cache_ptr->resize_ctl).epoch_length ) ) {
+
+        if ( ! have_write_permitted ) {
+
+            if ( cache_ptr->check_write_permitted != NULL ) {
+
+                result = (cache_ptr->check_write_permitted)(f, 
+                                                            primary_dxpl_id, 
+                                                            &write_permitted);
+
+                if ( result < 0 ) {
+
+                    HGOTO_ERROR(H5E_CACHE, H5E_CANTPROTECT, NULL, \
+                               "Can't get write_permitted 2")
+
+                } else {
+
+                    have_write_permitted = TRUE;
+                }
+            } else {
+
+                have_write_permitted = TRUE;
+            }
+        }
+
+        result = H5C__auto_adjust_cache_size(cache_ptr,
+                                             f,
+                                             primary_dxpl_id,
+                                             secondary_dxpl_id,
+                                             write_permitted,
+                                             &first_flush);
+
+        if ( result != SUCCEED ) {
+
+            HGOTO_ERROR(H5E_CACHE, H5E_CANTPROTECT, NULL, \
+                        "Cache auto-resize failed.")
+        
+        } else if ( cache_ptr->size_decreased  ) {
+
+            cache_ptr->size_decreased = FALSE;
+        
+            /* check to see if the cache is now oversized due to the cache
+             * size reduction.  If it is, try to evict enough entries to 
+             * bring the cache size down to the current maximum cache size.
+             */
+            if ( cache_ptr->index_size > cache_ptr->max_cache_size ) {
+
+                size_t space_needed;
+
+                cache_ptr->cache_full = TRUE;
+
+                space_needed = cache_ptr->index_size - 
+                               cache_ptr->max_cache_size + 1;
+
+                result = H5C_make_space_in_cache(f, primary_dxpl_id, 
+                                                 secondary_dxpl_id, cache_ptr, 
+                                                 space_needed, write_permitted,
+                                                 &first_flush);
+
+                if ( result < 0 ) {
+
+                    HGOTO_ERROR(H5E_CACHE, H5E_CANTPROTECT, NULL, \
+                                "H5C_make_space_in_cache failed 2.")
+                }
+            }
+        }
+    }
+
 done:
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -3069,152 +3283,428 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5C_unprotect
  *
- * Purpose:	Undo an H5C_protect() call -- specifically, mark the
- *		entry as unprotected, remove it from the protected list,
- *		and give it back to the replacement policy.
+ * Function:    H5C_reset_cache_hit_rate_stats()
  *
- *		The TYPE and ADDR arguments must be the same as those in
- *		the corresponding call to H5C_protect() and the THING 
- *		argument must be the value returned by that call to 
- *		H5C_protect().
+ * Purpose:     Reset the cache hit rate computation fields.
  *
- *		The primary_dxpl_id and secondary_dxpl_id parameters 
- *		specify the dxpl_ids used on the first write occasioned
- *		by the unprotect (primary_dxpl_id), and on all subsequent 
- *		writes (secondary_dxpl_id).  Since an uprotect cannot 
- *		occasion a write at present, all this is moot for now.  
- *		However, things change, and in any case, 
- *		H5C_flush_single_entry() needs primary_dxpl_id and 
- *		secondary_dxpl_id in its parameter list.
+ * Return:      SUCCEED on success, and FAIL on failure.
  *
- *		The function can't cause a read either, so the dxpl_id
- *		parameters are moot in this case as well.
+ * Programmer:  John Mainzer, 10/5/04
  *
- * Return:      Non-negative on success/Negative on failure
+ * Modifications:
  *
- *		If the deleted flag is TRUE, simply remove the target entry
- *		from the cache, clear it, and free it without writing it to 
- *		disk.
+ *		JRM - 7/21/04
+ *		Updated the function for the addition of the hash table.
+ *		In particular, we now add dirty entries to the skip list if
+ *		they aren't in the list already.
  *
- * Return:      Non-negative on success/Negative on failure
+ *-------------------------------------------------------------------------
+ */
+
+herr_t
+H5C_reset_cache_hit_rate_stats(H5C_t * cache_ptr)
+{
+    herr_t	ret_value = SUCCEED;      /* Return value */
+
+    FUNC_ENTER_NOAPI(H5C_reset_cache_hit_rate_stats, FAIL)
+
+    if ( ( cache_ptr == NULL ) || ( cache_ptr->magic != H5C__H5C_T_MAGIC ) ) {
+
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Bad cache_ptr on entry.")
+    }
+
+    cache_ptr->cache_hits		= 0;
+    cache_ptr->cache_accesses		= 0;
+
+done:
+
+    FUNC_LEAVE_NOAPI(ret_value)
+
+} /* H5C_reset_cache_hit_rate_stats() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5C_set_cache_auto_resize_config
+ *
+ * Purpose:	Set the cache automatic resize configuration to the 
+ *		provided values if they are in range, and fail if they
+ *		are not.
+ *
+ *		If the new configuration enables automatic cache resizing,
+ *		coerce the cache max size and min clean size into agreement
+ *		with the new policy and re-set the full cache hit rate
+ *		stats.
+ *
+ * Return:      SUCCEED on success, and FAIL on failure.
  *
  * Programmer:  John Mainzer
- *              6/2/04
+ *		10/8/04
  *
  * Modifications:
  *
- *		JRM - 7/21/04
- *		Updated the function for the addition of the hash table.
- *		In particular, we now add dirty entries to the skip list if
- *		they aren't in the list already.
+ *		JRM -- 11/18/04
+ *		Reworked function to match major changes in 
+ *		H5C_auto_size_ctl_t.  
  *
  *-------------------------------------------------------------------------
  */
+
 herr_t
-H5C_unprotect(H5F_t *		  f, 
-              hid_t		  primary_dxpl_id, 
-              hid_t		  secondary_dxpl_id, 
-              H5C_t *		  cache_ptr,
-              const H5C_class_t * type, 
-              haddr_t		  addr,
-              void *		  thing, 
-              hbool_t		  deleted)
+H5C_set_cache_auto_resize_config(H5C_t * cache_ptr, 
+                                 H5C_auto_size_ctl_t *config_ptr)
 {
-    herr_t              ret_value = SUCCEED;    /* Return value */
-    H5C_cache_entry_t *	entry_ptr;
-    H5C_cache_entry_t *	test_entry_ptr;
+    herr_t	ret_value = SUCCEED;      /* Return value */
+    herr_t	result;
+    size_t      new_max_cache_size;
+    size_t      new_min_clean_size;
 
-    FUNC_ENTER_NOAPI(H5C_unprotect, FAIL)
+    FUNC_ENTER_NOAPI(H5C_set_cache_auto_resize_config, FAIL)
 
-    HDassert( cache_ptr );
-    HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
-    HDassert( cache_ptr->skip_file_checks || f );
-    HDassert( type );
-    HDassert( type->clear );
-    HDassert( type->flush );
-    HDassert( H5F_addr_defined(addr) );
-    HDassert( thing );
+    if ( ( cache_ptr == NULL ) || ( cache_ptr->magic != H5C__H5C_T_MAGIC ) ) {
 
-    entry_ptr = (H5C_cache_entry_t *)thing;
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Bad cache_ptr on entry.")
+    }
 
-    HDassert( entry_ptr->addr == addr );
-    HDassert( entry_ptr->type == type );
+    if ( config_ptr == NULL ) {
 
-    if ( ! (entry_ptr->is_protected) ) {
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "NULL config_ptr on entry.")
+    }
 
-            HGOTO_ERROR(H5E_CACHE, H5E_CANTUNPROTECT, FAIL, \
-                        "Entry already unprotected??")
+    if ( config_ptr->version != H5C__CURR_AUTO_SIZE_CTL_VER ) {
+
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Unknown config version.")
     }
 
-    H5C__UPDATE_RP_FOR_UNPROTECT(cache_ptr, entry_ptr, FAIL)
+    /* check general configuration section of the config: */
+    if ( ( config_ptr->max_size > H5C__MAX_MAX_CACHE_SIZE ) 
+         ||
+         ( config_ptr->max_size < config_ptr->min_size )
+         ||
+         ( config_ptr->min_size < H5C__MIN_MAX_CACHE_SIZE )
+         ||
+         ( ( config_ptr->set_initial_size ) &&
+           ( config_ptr->initial_size > config_ptr->max_size )
+         )
+         ||
+         ( ( config_ptr->set_initial_size ) &&
+           ( config_ptr->initial_size < config_ptr->min_size )
+         )
+         ||
+         ( config_ptr->min_clean_fraction > 1.0 )
+         ||
+         ( config_ptr->min_clean_fraction < 0.0 )
+         ||
+         ( config_ptr->epoch_length < H5C__MIN_AR_EPOCH_LENGTH )
+         ||
+         ( config_ptr->epoch_length > H5C__MAX_AR_EPOCH_LENGTH )
+       ) {
+
+        HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, \
+                    "error in general configuration fields of new config.")
+    }
 
-    entry_ptr->is_protected = FALSE;    
+    /* check size increase control fields of the config: */
+    if ( ( ( config_ptr->incr_mode != H5C_incr__off ) 
+           &&
+           ( config_ptr->incr_mode != H5C_incr__threshold ) 
+         )
+         ||
+         ( ( config_ptr->incr_mode == H5C_incr__threshold )
+           &&
+           ( ( config_ptr->lower_hr_threshold < 0.0 )
+             ||
+             ( config_ptr->lower_hr_threshold > 1.0 )
+             ||
+             ( config_ptr->increment < 1.0 )
+             /* no need to check max_increment, as it is a size_t,
+              * and thus must be non-negative.
+              */
+           ) 
+         )
+       ) {
+
+        HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, \
+                    "error in the size increase control fields of new config.")
+    }
+
+    /* check size decrease control fields of the config: */
+    if ( ( ( config_ptr->decr_mode != H5C_decr__off ) 
+           &&
+           ( config_ptr->decr_mode != H5C_decr__threshold ) 
+           &&
+           ( config_ptr->decr_mode != H5C_decr__age_out ) 
+           &&
+           ( config_ptr->decr_mode != H5C_decr__age_out_with_threshold ) 
+         )
+         ||
+         ( ( config_ptr->decr_mode == H5C_decr__threshold )
+           &&
+           ( ( config_ptr->upper_hr_threshold > 1.0 )
+             ||
+             ( config_ptr->decrement > 1.0 )
+             ||
+             ( config_ptr->decrement < 0.0 )
+             /* no need to check max_decrement as it is a size_t 
+              * and thus must be non-negative.
+              */
+           )
+         )
+         ||
+         ( ( ( config_ptr->decr_mode == H5C_decr__age_out )
+             ||
+             ( config_ptr->decr_mode == H5C_decr__age_out_with_threshold )
+           )
+           &&
+           (
+             ( config_ptr->epochs_before_eviction < 1 )
+             ||
+             ( config_ptr->epochs_before_eviction > H5C__MAX_EPOCH_MARKERS )
+             ||
+             ( ( config_ptr->apply_empty_reserve )
+               &&
+               ( config_ptr->empty_reserve < 0.0 )
+             )
+             ||
+             ( ( config_ptr->apply_empty_reserve )
+               &&
+               ( config_ptr->empty_reserve > 1.0 )
+             )
+             /* no need to check max_decrement as it is a size_t 
+              * and thus must be non-negative.
+              */
+           )
+         )
+         ||
+         ( ( config_ptr->decr_mode == H5C_decr__age_out_with_threshold )
+           &&
+           ( config_ptr->upper_hr_threshold > 1.0 )
+         )
+       ) {
+
+        HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, \
+                    "error in the size decrease control fields of new config.")
+    }
+
+    /* check for conflicts between size increase and size decrease controls: */
+    if ( ( config_ptr->incr_mode == H5C_incr__threshold )
+         &&
+         ( ( config_ptr->decr_mode == H5C_decr__threshold ) 
+           ||
+           ( config_ptr->decr_mode == H5C_decr__age_out_with_threshold )
+         )
+         &&
+         ( config_ptr->lower_hr_threshold >= config_ptr->upper_hr_threshold )
+       ) {
+
+        HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, \
+                    "conflicting threshold fields in new config.")
+    }
+
+    cache_ptr->size_increase_possible = TRUE; /* will set to FALSE if needed */
+    cache_ptr->size_decrease_possible = TRUE; /* will set to FALSE if needed */
+
+    switch ( config_ptr->incr_mode )
+    {
+        case H5C_incr__off:
+            cache_ptr->size_increase_possible = FALSE;
+            break;
+
+        case H5C_incr__threshold:
+            if ( ( config_ptr->lower_hr_threshold <= 0.0 ) ||
+                 ( config_ptr->increment <= 1.0 ) ||
+                 ( ( config_ptr->apply_max_increment ) &&
+                   ( config_ptr->max_increment <= 0 ) ) ) {
+
+                 cache_ptr->size_increase_possible = FALSE;
+            }    
+            break;
+
+        default: /* should be unreachable */
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Unknown incr_mode?!?!?.")
+            break;
+    }
+
+    switch ( config_ptr->decr_mode )
+    {
+        case H5C_decr__off:
+            cache_ptr->size_decrease_possible = FALSE;
+            break;
+
+        case H5C_decr__threshold:
+            if ( ( config_ptr->upper_hr_threshold >= 1.0 ) ||
+                 ( config_ptr->decrement >= 1.0 ) ||
+                 ( ( config_ptr->apply_max_decrement ) &&
+                   ( config_ptr->max_decrement <= 0 ) ) ) {
+
+                cache_ptr->size_decrease_possible = FALSE;
+            }
+            break;
+
+        case H5C_decr__age_out:
+            if ( ( ( config_ptr->apply_empty_reserve ) &&
+                   ( config_ptr->empty_reserve >= 1.0 ) ) ||
+                 ( ( config_ptr->apply_max_decrement ) &&
+                   ( config_ptr->max_decrement <= 0 ) ) ) {
+
+                cache_ptr->size_decrease_possible = FALSE;
+            }
+            break;
+
+        case H5C_decr__age_out_with_threshold:
+            if ( ( ( config_ptr->apply_empty_reserve ) &&
+                   ( config_ptr->empty_reserve >= 1.0 ) ) ||
+                 ( ( config_ptr->apply_max_decrement ) &&
+                   ( config_ptr->max_decrement <= 0 ) ) ||
+                 ( config_ptr->upper_hr_threshold >= 1.0 ) ) {
+
+                cache_ptr->size_decrease_possible = FALSE;
+            }
+            break;
+
+        default: /* should be unreachable */
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Unknown decr_mode?!?!?.")
+            break;
+    }
+
+    if ( config_ptr->max_size == config_ptr->min_size ) {
+
+        cache_ptr->size_increase_possible = FALSE;
+        cache_ptr->size_decrease_possible = FALSE;
+    }
 
-    /* add the entry to the skip list if it is dirty, and it isn't already in
-     * the list.
+    cache_ptr->resize_enabled = cache_ptr->size_increase_possible ||
+                                cache_ptr->size_decrease_possible;
+
+    cache_ptr->resize_ctl = *config_ptr;
+
+    /* Resize the cache to the supplied initial value if requested, or as 
+     * necessary to force it within the bounds of the current automatic 
+     * cache resizing configuration.
+     *
+     * Note that the min_clean_fraction may have changed, so we 
+     * go through the exercise even if the current size is within
+     * range and an initial size has not been provided.
      */
+    if ( (cache_ptr->resize_ctl).set_initial_size ) {
+        
+        new_max_cache_size = (cache_ptr->resize_ctl).initial_size;
+    } 
+    else if ( cache_ptr->max_cache_size > (cache_ptr->resize_ctl).max_size ) {
 
-    if ( ( entry_ptr->is_dirty ) && ( ! (entry_ptr->in_slist) ) ) {
+        new_max_cache_size = (cache_ptr->resize_ctl).max_size;
+    }
+    else if ( cache_ptr->max_cache_size < (cache_ptr->resize_ctl).min_size ) {
 
-        H5C__INSERT_ENTRY_IN_SLIST(cache_ptr, entry_ptr)
+        new_max_cache_size = (cache_ptr->resize_ctl).min_size;
+
+    } else {
+
+        new_max_cache_size = cache_ptr->max_cache_size;
     }
 
-    /* this implementation of the "deleted" option is a bit inefficient, as
-     * we re-insert the entry to be deleted into the replacement policy
-     * data structures, only to remove them again.  Depending on how often
-     * we do this, we may want to optimize a bit.  
+    new_min_clean_size = (size_t)
+                         ((double)new_max_cache_size *
+                          ((cache_ptr->resize_ctl).min_clean_fraction));
+
+
+    /* since new_min_clean_size is of type size_t, we have
      *
-     * On the other hand, this implementation is reasonably clean, and 
-     * makes good use of existing code.
-     *                                             JRM - 5/19/04
+     * 	( 0 <= new_min_clean_size )
+     *
+     * by definition.
      */
-    if ( deleted ) {
+    HDassert( new_min_clean_size <= new_max_cache_size );
+    HDassert( (cache_ptr->resize_ctl).min_size <= new_max_cache_size );
+    HDassert( new_max_cache_size <= (cache_ptr->resize_ctl).max_size );
 
-        /* the following first flush flag will never be used as we are
-         * calling H5C_flush_single_entry with both the H5F_FLUSH_CLEAR_ONLY
-         * and H5F_FLUSH_INVALIDATE flags.  However, it is needed for the
-         * function call.
-         */
-        hbool_t		dummy_first_flush = TRUE;
+    cache_ptr->max_cache_size = new_max_cache_size;
+    cache_ptr->min_clean_size = new_min_clean_size;
 
-        /* verify that the target entry is in the cache. */
+    if ( H5C_reset_cache_hit_rate_stats(cache_ptr) != SUCCEED ) {
 
-        H5C__SEARCH_INDEX(cache_ptr, addr, test_entry_ptr, FAIL)
+        /* this should be impossible... */
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
+                    "H5C_reset_cache_hit_rate_stats failed.")
+    }
 
-        if ( test_entry_ptr == NULL ) {
+    /* remove excess epoch markers if any */
+    if ( ( config_ptr->decr_mode == H5C_decr__age_out_with_threshold ) ||
+         ( config_ptr->decr_mode == H5C_decr__age_out ) ) {
 
-            HGOTO_ERROR(H5E_CACHE, H5E_CANTUNPROTECT, FAIL, \
-                        "entry not in hash table?!?.")
-        }
-        else if ( test_entry_ptr != entry_ptr ) {
+        if ( cache_ptr->epoch_markers_active >
+             (cache_ptr->resize_ctl).epochs_before_eviction ) {
 
-            HGOTO_ERROR(H5E_CACHE, H5E_CANTUNPROTECT, FAIL, \
-                        "hash table contains multiple entries for addr?!?.")
+            result =
+                H5C__autoadjust__ageout__remove_excess_markers(cache_ptr);
+
+            if ( result != SUCCEED ) {
+
+                HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
+                            "can't remove excess epoch markers.")
+            }
         }
+    } else if ( cache_ptr->epoch_markers_active > 0 ) {
 
-        if ( H5C_flush_single_entry(f, 
-                                    primary_dxpl_id, 
-                                    secondary_dxpl_id, 
-                                    cache_ptr,
-                                    type, 
-                                    addr, 
-                                    (H5F_FLUSH_CLEAR_ONLY|H5F_FLUSH_INVALIDATE),
-                                    &dummy_first_flush, 
-                                    TRUE) < 0 ) {
+        result = H5C__autoadjust__ageout__remove_all_markers(cache_ptr);
 
-            HGOTO_ERROR(H5E_CACHE, H5E_CANTUNPROTECT, FAIL, "Can't flush.")
+        if ( result != SUCCEED ) {
+
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
+                        "error removing all epoch markers.")
         }
     }
 
-    H5C__UPDATE_STATS_FOR_UNPROTECT(cache_ptr)
-
 done:
 
     FUNC_LEAVE_NOAPI(ret_value)
 
-} /* H5C_unprotect() */
+} /* H5C_set_cache_auto_resize_config() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5C_set_skip_flags
+ *
+ * Purpose:     Set the values of the skip sanity check flags.
+ *		
+ *		This function and the skip sanity check flags were created
+ *		for the convenience of the test bed.  However it is 
+ *		possible that there may be other uses for the flags.
+ *
+ * Return:      Non-negative on success/Negative on failure
+ *
+ * Programmer:  John Mainzer
+ *              6/11/04
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+
+herr_t
+H5C_set_skip_flags(H5C_t * cache_ptr,
+                   hbool_t skip_file_checks,
+                   hbool_t skip_dxpl_id_checks)
+{
+    herr_t		ret_value = SUCCEED;   /* Return value */
+
+    FUNC_ENTER_NOAPI(H5C_set_skip_flags, FAIL)
+
+    /* This would normally be an assert, but we need to use an HGOTO_ERROR
+     * call to shut up the compiler.
+     */
+    if ( ( ! cache_ptr ) || ( cache_ptr->magic != H5C__H5C_T_MAGIC ) ) {
+
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Bad cache_ptr")
+    }
+
+    cache_ptr->skip_file_checks    = skip_file_checks;
+    cache_ptr->skip_dxpl_id_checks = skip_dxpl_id_checks;
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+
+} /* H5C_set_skip_flags() */
 
 
 /*-------------------------------------------------------------------------
@@ -3355,7 +3845,7 @@ H5C_stats(H5C_t * cache_ptr,
               (long)(cache_ptr->max_index_len));
 
     HDfprintf(stdout, 
-              "  current (max) skip list size / length   = %ld (%ld) / %ld (%ld)\n",
+              "  current (max) slist size / length  = %ld (%ld) / %ld (%ld)\n",
               (long)(cache_ptr->slist_size),
               (long)(cache_ptr->max_slist_size),
               (long)(cache_ptr->slist_len),
@@ -3558,48 +4048,152 @@ H5C_stats__reset(H5C_t * cache_ptr)
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5C_set_skip_flags
+ * Function:    H5C_unprotect
  *
- * Purpose:     Set the values of the skip sanity check flags.
- *		
- *		This function and the skip sanity check flags were created
- *		for the convenience of the test bed.  However it is 
- *		possible that there may be other uses for the flags.
+ * Purpose:	Undo an H5C_protect() call -- specifically, mark the
+ *		entry as unprotected, remove it from the protected list,
+ *		and give it back to the replacement policy.
+ *
+ *		The TYPE and ADDR arguments must be the same as those in
+ *		the corresponding call to H5C_protect() and the THING 
+ *		argument must be the value returned by that call to 
+ *		H5C_protect().
+ *
+ *		The primary_dxpl_id and secondary_dxpl_id parameters 
+ *		specify the dxpl_ids used on the first write occasioned
+ *		by the unprotect (primary_dxpl_id), and on all subsequent 
+ *		writes (secondary_dxpl_id).  Since an uprotect cannot 
+ *		occasion a write at present, all this is moot for now.  
+ *		However, things change, and in any case, 
+ *		H5C_flush_single_entry() needs primary_dxpl_id and 
+ *		secondary_dxpl_id in its parameter list.
+ *
+ *		The function can't cause a read either, so the dxpl_id
+ *		parameters are moot in this case as well.
+ *
+ * Return:      Non-negative on success/Negative on failure
+ *
+ *		If the deleted flag is TRUE, simply remove the target entry
+ *		from the cache, clear it, and free it without writing it to 
+ *		disk.
  *
  * Return:      Non-negative on success/Negative on failure
  *
  * Programmer:  John Mainzer
- *              6/11/04
+ *              6/2/04
  *
  * Modifications:
  *
+ *		JRM -- 7/21/04
+ *		Updated the function for the addition of the hash table.
+ *		In particular, we now add dirty entries to the tree if
+ *		they aren't in the tree already.
+ *
  *-------------------------------------------------------------------------
  */
-
 herr_t
-H5C_set_skip_flags(H5C_t * cache_ptr,
-                   hbool_t skip_file_checks,
-                   hbool_t skip_dxpl_id_checks)
+H5C_unprotect(H5F_t *		  f, 
+              hid_t		  primary_dxpl_id, 
+              hid_t		  secondary_dxpl_id, 
+              H5C_t *		  cache_ptr,
+              const H5C_class_t * type, 
+              haddr_t		  addr,
+              void *		  thing, 
+              hbool_t		  deleted)
 {
-    herr_t		ret_value = SUCCEED;   /* Return value */
+    herr_t              ret_value = SUCCEED;    /* Return value */
+    H5C_cache_entry_t *	entry_ptr;
+    H5C_cache_entry_t *	test_entry_ptr;
 
-    FUNC_ENTER_NOAPI(H5C_set_skip_flags, FAIL)
+    FUNC_ENTER_NOAPI(H5C_unprotect, FAIL)
 
-    /* This would normally be an assert, but we need to use an HGOTO_ERROR
-     * call to shut up the compiler.
+    HDassert( cache_ptr );
+    HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
+    HDassert( cache_ptr->skip_file_checks || f );
+    HDassert( type );
+    HDassert( type->clear );
+    HDassert( type->flush );
+    HDassert( H5F_addr_defined(addr) );
+    HDassert( thing );
+
+    entry_ptr = (H5C_cache_entry_t *)thing;
+
+    HDassert( entry_ptr->addr == addr );
+    HDassert( entry_ptr->type == type );
+
+    if ( ! (entry_ptr->is_protected) ) {
+
+            HGOTO_ERROR(H5E_CACHE, H5E_CANTUNPROTECT, FAIL, \
+                        "Entry already unprotected??")
+    }
+
+    H5C__UPDATE_RP_FOR_UNPROTECT(cache_ptr, entry_ptr, FAIL)
+
+    entry_ptr->is_protected = FALSE;    
+
+    /* add the entry to the tree if it is dirty, and it isn't already in
+     * the tree.
      */
-    if ( ( ! cache_ptr ) || ( cache_ptr->magic != H5C__H5C_T_MAGIC ) ) {
 
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Bad cache_ptr")
+    if ( ( entry_ptr->is_dirty ) && ( ! (entry_ptr->in_slist) ) ) {
+
+        H5C__INSERT_ENTRY_IN_SLIST(cache_ptr, entry_ptr)
     }
 
-    cache_ptr->skip_file_checks    = skip_file_checks;
-    cache_ptr->skip_dxpl_id_checks = skip_dxpl_id_checks;
+    /* this implementation of the "deleted" option is a bit inefficient, as
+     * we re-insert the entry to be deleted into the replacement policy
+     * data structures, only to remove them again.  Depending on how often
+     * we do this, we may want to optimize a bit.  
+     *
+     * On the other hand, this implementation is reasonably clean, and 
+     * makes good use of existing code.
+     *                                             JRM - 5/19/04
+     */
+    if ( deleted ) {
+
+        /* the following first flush flag will never be used as we are
+         * calling H5C_flush_single_entry with both the H5F_FLUSH_CLEAR_ONLY
+         * and H5F_FLUSH_INVALIDATE flags.  However, it is needed for the
+         * function call.
+         */
+        hbool_t		dummy_first_flush = TRUE;
+
+        /* verify that the target entry is in the cache. */
+
+        H5C__SEARCH_INDEX(cache_ptr, addr, test_entry_ptr, FAIL)
+
+        if ( test_entry_ptr == NULL ) {
+
+            HGOTO_ERROR(H5E_CACHE, H5E_CANTUNPROTECT, FAIL, \
+                        "entry not in hash table?!?.")
+        }
+        else if ( test_entry_ptr != entry_ptr ) {
+
+            HGOTO_ERROR(H5E_CACHE, H5E_CANTUNPROTECT, FAIL, \
+                        "hash table contains multiple entries for addr?!?.")
+        }
+
+        if ( H5C_flush_single_entry(f, 
+                                    primary_dxpl_id, 
+                                    secondary_dxpl_id, 
+                                    cache_ptr,
+                                    type, 
+                                    addr, 
+                                    (H5F_FLUSH_CLEAR_ONLY|H5F_FLUSH_INVALIDATE),
+                                    &dummy_first_flush, 
+                                    TRUE) < 0 ) {
+
+            HGOTO_ERROR(H5E_CACHE, H5E_CANTUNPROTECT, FAIL, "Can't flush.")
+        }
+    }
+
+    H5C__UPDATE_STATS_FOR_UNPROTECT(cache_ptr)
 
 done:
+
     FUNC_LEAVE_NOAPI(ret_value)
 
-} /* H5C_set_skip_flags() */
+} /* H5C_unprotect() */
 
 
 /*************************************************************************/
@@ -3608,6 +4202,1068 @@ done:
 
 /*-------------------------------------------------------------------------
  *
+ * Function:	H5C__auto_adjust_cache_size
+ *
+ * Purpose:    	Obtain the current full cache hit rate, and compare it 
+ *		with the hit rate thresholds for modifying cache size.  
+ *		If one of the thresholds has been crossed, adjusts the 
+ *		size of the cache accordingly.
+ *
+ *		The function then resets the full cache hit rate 
+ *		statistics, and exits.
+ *
+ * Return:      Non-negative on success/Negative on failure or if there was 
+ *		an attempt to flush a protected item.
+ *
+ *
+ * Programmer:  John Mainzer, 10/7/04
+ *
+ * Modifications:
+ *
+ *		JRM -- 11/18/04
+ *		Major re-write to support ageout method of cache size
+ *		reduction, and to adjust to changes in the 
+ *		H5C_auto_size_ctl_t structure.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+static herr_t
+H5C__auto_adjust_cache_size(H5C_t * cache_ptr,
+                            H5F_t * f,
+                            hid_t primary_dxpl_id,
+                            hid_t secondary_dxpl_id,
+                            hbool_t write_permitted,
+                            hbool_t * first_flush_ptr)
+{
+    herr_t			ret_value = SUCCEED;      /* Return value */
+    herr_t			result;
+    hbool_t			inserted_epoch_marker = FALSE;
+    size_t			new_max_cache_size = 0;
+    size_t			old_max_cache_size = 0;
+    size_t			new_min_clean_size = 0;
+    size_t			old_min_clean_size = 0;
+    double			hit_rate;
+    enum H5C_resize_status	status = in_spec; /* will change if needed */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5C__auto_adjust_cache_size)
+
+    HDassert( cache_ptr );
+    HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
+    HDassert( cache_ptr->cache_accesses >= 
+              (cache_ptr->resize_ctl).epoch_length );
+    HDassert( 0.0 <= (cache_ptr->resize_ctl).min_clean_fraction );
+    HDassert( (cache_ptr->resize_ctl).min_clean_fraction <= 100.0 );
+
+    if ( !cache_ptr->resize_enabled ) {
+
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Auto cache resize disabled.")
+    }
+
+    HDassert( ( (cache_ptr->resize_ctl).incr_mode != H5C_incr__off ) || \
+              ( (cache_ptr->resize_ctl).decr_mode != H5C_decr__off ) );
+
+    if ( H5C_get_cache_hit_rate(cache_ptr, &hit_rate) != SUCCEED ) {
+
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Can't get hit rate.")
+    }
+
+    HDassert( ( 0.0 <= hit_rate ) && ( hit_rate <= 1.0 ) );
+
+    switch ( (cache_ptr->resize_ctl).incr_mode )
+    {
+        case H5C_incr__off:
+            if ( cache_ptr->size_increase_possible ) {
+
+                HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
+                           "size_increase_possible but H5C_incr__off?!?!?")
+            }
+            break;
+
+        case H5C_incr__threshold:
+            if ( hit_rate < (cache_ptr->resize_ctl).lower_hr_threshold ) {
+
+                if ( ! cache_ptr->size_increase_possible ) {
+
+                    status = increase_disabled;
+                    
+                } else if ( cache_ptr->max_cache_size >= 
+                            (cache_ptr->resize_ctl).max_size ) {
+
+                    HDassert( cache_ptr->max_cache_size == \
+                              (cache_ptr->resize_ctl).max_size );
+                    status = at_max_size;
+
+                } else if ( ! cache_ptr->cache_full ) {
+
+                    status = not_full;
+
+                } else {
+
+                    new_max_cache_size = (size_t)
+                                     (((double)(cache_ptr->max_cache_size)) *
+                                      (cache_ptr->resize_ctl).increment);
+
+                    /* clip to max size if necessary */
+                    if ( new_max_cache_size > 
+                         (cache_ptr->resize_ctl).max_size ) {
+
+                        new_max_cache_size = (cache_ptr->resize_ctl).max_size;
+                    }
+
+                    /* clip to max increment if necessary */
+                    if ( ( (cache_ptr->resize_ctl).apply_max_increment ) &&
+                         ( (cache_ptr->max_cache_size + 
+                            (cache_ptr->resize_ctl).max_increment) <
+                           new_max_cache_size ) ) {
+
+                        new_max_cache_size = cache_ptr->max_cache_size +
+                                         (cache_ptr->resize_ctl).max_increment;
+                    }
+
+                    status = increase;
+                }
+            }
+            break;
+
+        default:
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "unknown incr_mode.")
+            break;
+    }
+
+    /* If the decr_mode is either age out or age out with threshold, we 
+     * must run the marker maintenance code, whether we run the size
+     * reduction code or not.  We do this in two places -- here we 
+     * insert a new marker if the number of active epoch markers is
+     * is less than the the current epochs before eviction, and after
+     * the ageout call, we cycle the markers.
+     *
+     * However, we can't call the ageout code or cycle the markers
+     * unless there was a full complement of markers in place on 
+     * entry.  The inserted_epoch_marker flag is used to track this.
+     */
+
+    if ( ( ( (cache_ptr->resize_ctl).decr_mode == H5C_decr__age_out ) 
+           ||
+           ( (cache_ptr->resize_ctl).decr_mode == 
+              H5C_decr__age_out_with_threshold
+           )
+         )
+         &&
+         ( cache_ptr->epoch_markers_active < 
+           (cache_ptr->resize_ctl).epochs_before_eviction 
+         ) 
+       ) {
+
+        result = H5C__autoadjust__ageout__insert_new_marker(cache_ptr);
+
+        if ( result != SUCCEED ) {
+
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
+                        "can't insert new epoch marker.")
+
+        } else {
+
+            inserted_epoch_marker = TRUE;
+        }
+    }
+
+    /* don't run the cache size decrease code unless the cache size
+     * increase code is disabled, or the size increase code sees no need
+     * for action.  In either case, status == in_spec at this point.
+     */
+
+    if ( status == in_spec ) {
+
+        switch ( (cache_ptr->resize_ctl).decr_mode )
+        {
+            case H5C_decr__off:
+                break;
+
+            case H5C_decr__threshold:
+                if ( hit_rate > (cache_ptr->resize_ctl).upper_hr_threshold ) {
+
+                    if ( ! cache_ptr->size_decrease_possible ) {
+
+                        status = decrease_disabled;
+                    
+                    } else if ( cache_ptr->max_cache_size <= 
+                                (cache_ptr->resize_ctl).min_size ) {
+
+                        HDassert( cache_ptr->max_cache_size ==
+                                  (cache_ptr->resize_ctl).min_size );
+                        status = at_min_size;
+
+                    } else {
+
+                        new_max_cache_size = (size_t)
+                                 (((double)(cache_ptr->max_cache_size)) *
+                                  (cache_ptr->resize_ctl).decrement);
+
+                        /* clip to min size if necessary */
+                        if ( new_max_cache_size < 
+                             (cache_ptr->resize_ctl).min_size ) {
+
+                            new_max_cache_size = 
+                                (cache_ptr->resize_ctl).min_size;
+                        }
+
+                        /* clip to max decrement if necessary */
+                        if ( ( (cache_ptr->resize_ctl).apply_max_decrement ) &&
+                             ( ((cache_ptr->resize_ctl).max_decrement +
+                                new_max_cache_size) < 
+                               cache_ptr->max_cache_size ) ) {
+
+                            new_max_cache_size = cache_ptr->max_cache_size - 
+                                         (cache_ptr->resize_ctl).max_decrement;
+                        }
+
+                        status = decrease;
+                    }
+                }
+                break;
+
+            case H5C_decr__age_out_with_threshold:
+            case H5C_decr__age_out:
+                if ( ! inserted_epoch_marker ) {
+
+                    if ( ! cache_ptr->size_decrease_possible ) {
+
+                        status = decrease_disabled;
+
+                    } else {
+
+                        result = H5C__autoadjust__ageout(cache_ptr,
+                                                         hit_rate,
+                                                         &status,
+                                                         &new_max_cache_size,
+                                                         f,
+                                                         primary_dxpl_id,
+                                                         secondary_dxpl_id,
+                                                         write_permitted,
+                                                         first_flush_ptr);
+
+                        if ( result != SUCCEED ) {
+
+                            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
+                                        "ageout code failed.")
+                        }
+                    }
+                }
+                break;
+
+            default:
+                HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "unknown incr_mode.")
+                break;
+        }
+    }
+
+    /* cycle the epoch markers here if appropriate */
+    if ( ( ( (cache_ptr->resize_ctl).decr_mode == H5C_decr__age_out ) 
+           ||
+           ( (cache_ptr->resize_ctl).decr_mode == 
+              H5C_decr__age_out_with_threshold
+           )
+         )
+         &&
+         ( ! inserted_epoch_marker )
+       ) {
+
+        /* move last epoch marker to the head of the LRU list */
+        result = H5C__autoadjust__ageout__cycle_epoch_marker(cache_ptr);
+
+        if ( result != SUCCEED ) {
+
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
+                        "error cycling epoch marker.")
+        }
+    }
+
+    if ( ( status == increase ) || ( status == decrease ) ) {
+
+        old_max_cache_size = cache_ptr->max_cache_size;
+        old_min_clean_size = cache_ptr->min_clean_size;
+
+        new_min_clean_size = (size_t)
+                             ((double)new_max_cache_size * 
+                              ((cache_ptr->resize_ctl).min_clean_fraction));
+
+        /* new_min_clean_size is of size_t, and thus must be non-negative.
+         * Hence we have
+         *
+         * 	( 0 <= new_min_clean_size ).
+         *
+ 	 * by definition.
+         */
+        HDassert( new_min_clean_size <= new_max_cache_size );
+        HDassert( (cache_ptr->resize_ctl).min_size <= new_max_cache_size );
+        HDassert( new_max_cache_size <= (cache_ptr->resize_ctl).max_size );
+
+        cache_ptr->max_cache_size = new_max_cache_size;
+        cache_ptr->min_clean_size = new_min_clean_size;
+
+        if ( status == increase ) {
+
+            cache_ptr->cache_full = FALSE;
+
+        } else if ( status == decrease ) {
+
+            cache_ptr->size_decreased = TRUE;
+        }
+    }
+
+    if ( (cache_ptr->resize_ctl).rpt_fcn != NULL ) {
+
+        (*((cache_ptr->resize_ctl).rpt_fcn))
+            (cache_ptr,
+             H5C__CURR_AUTO_RESIZE_RPT_FCN_VER,
+             hit_rate,
+             status,
+             old_max_cache_size,
+             new_max_cache_size,
+             old_min_clean_size,
+             new_min_clean_size);
+    }
+
+    if ( H5C_reset_cache_hit_rate_stats(cache_ptr) != SUCCEED ) {
+
+        /* this should be impossible... */
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
+                    "H5C_reset_cache_hit_rate_stats failed.")
+    }
+
+done:
+
+    FUNC_LEAVE_NOAPI(ret_value)
+
+} /* H5C__auto_adjust_cache_size() */
+
+
+/*-------------------------------------------------------------------------
+ *
+ * Function:    H5C__autoadjust__ageout
+ *
+ * Purpose:     Implement the ageout automatic cache size decrement 
+ *		algorithm.  Note that while this code evicts aged out
+ *		entries, the code does not change the maximum cache size.
+ *		Instead, the function simply computes the new value (if
+ *		any change is indicated) and reports this value in 
+ *		*new_max_cache_size_ptr.
+ *
+ * Return:      Non-negative on success/Negative on failure or if there was
+ *              an attempt to flush a protected item.
+ *
+ *
+ * Programmer:  John Mainzer, 11/18/04
+ *
+ * Modifications:
+ *
+ *              None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+static herr_t
+H5C__autoadjust__ageout(H5C_t * cache_ptr,
+                        double hit_rate,
+                        enum H5C_resize_status * status_ptr,
+                        size_t * new_max_cache_size_ptr,
+                        H5F_t * f,
+                        hid_t primary_dxpl_id,
+                        hid_t secondary_dxpl_id,
+                        hbool_t write_permitted,
+                        hbool_t * first_flush_ptr)
+{
+    herr_t	ret_value = SUCCEED;      /* Return value */
+    herr_t	result;
+    size_t	test_size;
+
+    FUNC_ENTER_NOAPI_NOINIT(H5C__autoadjust__ageout)
+
+    HDassert( cache_ptr );
+    HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
+    HDassert( ( status_ptr ) && ( *status_ptr == in_spec ) );
+    HDassert( ( new_max_cache_size_ptr ) && ( *new_max_cache_size_ptr == 0 ) );
+
+    /* remove excess epoch markers if any */
+    if ( cache_ptr->epoch_markers_active >
+         (cache_ptr->resize_ctl).epochs_before_eviction ) {
+
+        result = H5C__autoadjust__ageout__remove_excess_markers(cache_ptr);
+
+        if ( result != SUCCEED ) {
+
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
+                        "can't remove excess epoch markers.")
+        }
+    }
+
+    if ( ( (cache_ptr->resize_ctl).decr_mode == H5C_decr__age_out ) 
+         ||
+         ( ( (cache_ptr->resize_ctl).decr_mode == 
+              H5C_decr__age_out_with_threshold 
+               )
+           &&
+           ( hit_rate >= (cache_ptr->resize_ctl).upper_hr_threshold )
+         )
+       ) {
+
+        if ( cache_ptr->max_cache_size > (cache_ptr->resize_ctl).min_size ){
+
+            /* evict aged out cache entries if appropriate... */
+            result = H5C__autoadjust__ageout__evict_aged_out_entries
+                     (
+                       f,
+                       primary_dxpl_id,
+                       secondary_dxpl_id,
+                       cache_ptr,
+                       write_permitted,
+                       first_flush_ptr
+                     );
+
+            if ( result != SUCCEED ) {
+
+                HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
+                            "error flushing aged out entries.")
+            }
+
+            /* ... and then reduce cache size if appropriate */
+            if ( cache_ptr->index_size < cache_ptr->max_cache_size ) {
+
+                if ( (cache_ptr->resize_ctl).apply_empty_reserve ) {
+
+                    test_size = (size_t)(((double)cache_ptr->index_size) /
+                                (1 - (cache_ptr->resize_ctl).empty_reserve));
+
+                    if ( test_size < cache_ptr->max_cache_size ) {
+
+                        *status_ptr = decrease;
+                        *new_max_cache_size_ptr = test_size;
+                    }
+                } else {
+
+                    *status_ptr = decrease;
+                    *new_max_cache_size_ptr = cache_ptr->index_size;
+                }
+
+                if ( *status_ptr == decrease ) {
+
+                    /* clip to min size if necessary */
+                    if ( *new_max_cache_size_ptr <
+                         (cache_ptr->resize_ctl).min_size ) {
+
+                        *new_max_cache_size_ptr = 
+                                (cache_ptr->resize_ctl).min_size;
+                    }
+
+                    /* clip to max decrement if necessary */
+                    if ( ( (cache_ptr->resize_ctl).apply_max_decrement ) &&
+                         ( ((cache_ptr->resize_ctl).max_decrement +
+                            *new_max_cache_size_ptr) < 
+                           cache_ptr->max_cache_size ) ) {
+
+                        *new_max_cache_size_ptr = cache_ptr->max_cache_size - 
+                                         (cache_ptr->resize_ctl).max_decrement;
+                    }
+                }
+            }
+        } else {
+
+            *status_ptr = at_min_size;
+        }
+    }
+
+done:
+
+    FUNC_LEAVE_NOAPI(ret_value)
+
+} /* H5C__autoadjust__ageout() */
+
+
+/*-------------------------------------------------------------------------
+ *
+ * Function:    H5C__autoadjust__ageout__cycle_epoch_marker
+ *
+ * Purpose:     Remove the oldest epoch marker from the LRU list,
+ *		and reinsert it at the head of the LRU list.  Also
+ *		remove the epoch marker's index from the head of the
+ *		ring buffer, and re-insert it at the tail of the ring
+ *		buffer.
+ *
+ * Return:      SUCCEED on success/FAIL on failure.
+ *
+ * Programmer:  John Mainzer, 11/22/04
+ *
+ * Modifications:
+ *
+ *              None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+static herr_t
+H5C__autoadjust__ageout__cycle_epoch_marker(H5C_t * cache_ptr)
+{
+    herr_t                      ret_value = SUCCEED;      /* Return value */
+    int i;
+
+    FUNC_ENTER_NOAPI_NOINIT(H5C__autoadjust__ageout__cycle_epoch_marker)
+
+    HDassert( cache_ptr );
+    HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
+
+    if ( cache_ptr->epoch_markers_active <= 0 ) { 
+
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
+                    "No active epoch markers on entry?!?!?.")
+    }
+
+    /* remove the last marker from both the ring buffer and the LRU list */
+
+    i = cache_ptr->epoch_marker_ringbuf[cache_ptr->epoch_marker_ringbuf_first];
+
+    cache_ptr->epoch_marker_ringbuf_first = 
+            (cache_ptr->epoch_marker_ringbuf_first + 1) % 
+            (H5C__MAX_EPOCH_MARKERS + 1);
+
+    cache_ptr->epoch_marker_ringbuf_size -= 1;
+
+    if ( cache_ptr->epoch_marker_ringbuf_size < 0 ) {
+
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "ring buffer underflow.")
+    }
+
+    if ( (cache_ptr->epoch_marker_active)[i] != TRUE ) {
+
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "unused marker in LRU?!?")
+    }
+
+    H5C__DLL_REMOVE((&((cache_ptr->epoch_markers)[i])), \
+                    (cache_ptr)->LRU_head_ptr, \
+                    (cache_ptr)->LRU_tail_ptr, \
+                    (cache_ptr)->LRU_list_len, \
+                    (cache_ptr)->LRU_list_size, \
+                    (FAIL))
+
+    /* now, re-insert it at the head of the LRU list, and at the tail of
+     * the ring buffer.
+     */ 
+
+    HDassert( ((cache_ptr->epoch_markers)[i]).addr == (haddr_t)i );
+    HDassert( ((cache_ptr->epoch_markers)[i]).next == NULL );
+    HDassert( ((cache_ptr->epoch_markers)[i]).prev == NULL );
+
+    cache_ptr->epoch_marker_ringbuf_last = 
+        (cache_ptr->epoch_marker_ringbuf_last + 1) % 
+        (H5C__MAX_EPOCH_MARKERS + 1);
+
+    (cache_ptr->epoch_marker_ringbuf)[cache_ptr->epoch_marker_ringbuf_last] = i;
+
+    cache_ptr->epoch_marker_ringbuf_size += 1;
+
+    if ( cache_ptr->epoch_marker_ringbuf_size > H5C__MAX_EPOCH_MARKERS ) {
+
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "ring buffer overflow.")
+    }
+
+    H5C__DLL_PREPEND((&((cache_ptr->epoch_markers)[i])), \
+                     (cache_ptr)->LRU_head_ptr, \
+                     (cache_ptr)->LRU_tail_ptr, \
+                     (cache_ptr)->LRU_list_len, \
+                     (cache_ptr)->LRU_list_size, \
+                     (FAIL))
+done:
+
+    FUNC_LEAVE_NOAPI(ret_value)
+
+} /* H5C__autoadjust__ageout__cycle_epoch_marker() */
+
+
+/*-------------------------------------------------------------------------
+ *
+ * Function:    H5C__autoadjust__ageout__evict_aged_out_entries
+ *
+ * Purpose:     Evict clean entries in the cache that haven't
+ *		been accessed for at least 
+ *              (cache_ptr->resize_ctl).epochs_before_eviction epochs,
+ *      	and flush dirty entries that haven't been accessed for
+ *		that amount of time.
+ *
+ *		Depending on configuration, the function will either 
+ *		flush or evict all such entries, or all such entries it
+ *		encounters until it has freed the maximum amount of space
+ *		allowed under the maximum decrement.
+ *
+ *		If we are running in parallel mode, writes may not be
+ *		permitted.  If so, the function simply skips any dirty 
+ *		entries it may encounter.
+ *
+ *		The function makes no attempt to maintain the minimum 
+ *		clean size, as there is no guarantee that the cache size
+ *		will be changed.  
+ *
+ *		If there is no cache size change, the minimum clean size 
+ *		constraint will be met through a combination of clean 
+ *		entries and free space in the cache.
+ *
+ *		If there is a cache size reduction, the minimum clean size
+ *		will be re-calculated, and will be enforced the next time
+ *		we have to make space in the cache.
+ *
+ *              The primary_dxpl_id and secondary_dxpl_id parameters
+ *              specify the dxpl_ids used depending on the value of 
+ *		*first_flush_ptr.  The idea is to use the primary_dxpl_id
+ *		on the first write in a sequence of writes, and to use
+ *		the secondary_dxpl_id on all subsequent writes.
+ *
+ *              This is useful in the metadata cache, but may not be 
+ *		needed elsewhere.  If so, just use the same dxpl_id for 
+ *		both parameters.
+ *
+ *              Observe that this function cannot occasion a read.
+ *
+ * Return:      Non-negative on success/Negative on failure.
+ *
+ * Programmer:  John Mainzer, 11/22/04
+ *
+ * Modifications:
+ *
+ *              None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+static herr_t
+H5C__autoadjust__ageout__evict_aged_out_entries(H5F_t * f,
+                                                hid_t   primary_dxpl_id,
+                                                hid_t   secondary_dxpl_id,
+                                                H5C_t * cache_ptr,
+                                                hbool_t write_permitted,
+                                                hbool_t * first_flush_ptr)
+{
+    herr_t              ret_value = SUCCEED;      /* Return value */
+    herr_t              result;
+    size_t		eviction_size_limit;
+    size_t		bytes_evicted = 0;
+    H5C_cache_entry_t * entry_ptr;
+    H5C_cache_entry_t * prev_ptr;
+
+    FUNC_ENTER_NOAPI_NOINIT(H5C__autoadjust__ageout__evict_aged_out_entries)
+
+    HDassert( cache_ptr );
+    HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
+
+    /* if there is a limit on the amount that the cache size can be decrease
+     * in any one round of the cache size reduction algorithm, load that 
+     * limit into eviction_size_limit.  Otherwise, set eviction_size_limit
+     * to the equivalent of infinity.  The current size of the index will
+     * do nicely.
+     */
+    if ( (cache_ptr->resize_ctl).apply_max_decrement ) {
+
+        eviction_size_limit = (cache_ptr->resize_ctl).max_decrement;
+
+    } else {
+
+        eviction_size_limit = cache_ptr->index_size; /* i.e. infinity */
+    }
+
+    if ( write_permitted ) {
+
+        entry_ptr = cache_ptr->LRU_tail_ptr;
+
+        while ( ( entry_ptr != NULL ) &&
+                ( (entry_ptr->type)->id != H5C__EPOCH_MARKER_TYPE ) &&
+                ( bytes_evicted < eviction_size_limit ) )
+        {
+            HDassert( ! (entry_ptr->is_protected) );
+
+            prev_ptr = entry_ptr->prev;
+
+            if ( entry_ptr->is_dirty ) {
+
+                result = H5C_flush_single_entry(f,
+                                                primary_dxpl_id,
+                                                secondary_dxpl_id,
+                                                cache_ptr,
+                                                entry_ptr->type,
+                                                entry_ptr->addr,
+                                                (unsigned)0,
+                                                first_flush_ptr,
+                                                FALSE);
+            } else {
+
+                bytes_evicted += entry_ptr->size;
+
+                result = H5C_flush_single_entry(f,
+                                                primary_dxpl_id,
+                                                secondary_dxpl_id,
+                                                cache_ptr,
+                                                entry_ptr->type,
+                                                entry_ptr->addr,
+                                                H5F_FLUSH_INVALIDATE,
+                                                first_flush_ptr,
+                                                TRUE);
+            }
+
+            if ( result < 0 ) {
+
+                HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, \
+                            "unable to flush entry")
+            }
+
+            entry_ptr = prev_ptr;
+
+        } /* end while */
+
+        /* for now at least, don't bother to maintain the minimum clean size,
+         * as the cache should now be less than its maximum size.  Due to 
+         * the vaguries of the cache size reduction algorthim, we may not
+         * reduce the size of the cache.
+         *
+         * If we do, we will calculate a new minimum clean size, which will
+         * be enforced the next time we try to make space in the cache.
+         *
+         * If we don't, no action is necessary, as we have just evicted and/or
+         * or flushed a bunch of entries and therefore the sum of the clean
+         * and free space in the cache must be greater than or equal to the 
+         * min clean space requirement (assuming that requirement was met on
+         * entry).
+         */
+
+    } else /* ! write_permitted */  {
+
+        /* since we are not allowed to write, all we can do is evict
+         * any clean entries that we may encounter before we either 
+         * hit the eviction size limit, or encounter the epoch marker.
+         *
+         * If we are operating read only, this isn't an issue, as there
+         * will not be any dirty entries.
+         *
+         * If we are operating in R/W mode, all the dirty entries we 
+         * skip will be flushed the next time we attempt to make space
+         * when writes are permitted.  This may have some local 
+         * performance implications, but it shouldn't cause any net 
+         * slowdown.
+         */
+
+        HDassert( H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS );
+
+        entry_ptr = cache_ptr->LRU_tail_ptr;
+
+        while ( ( entry_ptr != NULL ) &&
+                ( (entry_ptr->type)->id != H5C__EPOCH_MARKER_TYPE ) &&
+                ( bytes_evicted < eviction_size_limit ) )
+        {
+            HDassert( ! (entry_ptr->is_protected) );
+
+            prev_ptr = entry_ptr->prev;
+
+            if ( ! (entry_ptr->is_dirty) ) {
+
+                result = H5C_flush_single_entry(f,
+                                                primary_dxpl_id,
+                                                secondary_dxpl_id,
+                                                cache_ptr,
+                                                entry_ptr->type,
+                                                entry_ptr->addr,
+                                                H5F_FLUSH_INVALIDATE,
+                                                first_flush_ptr,
+                                                TRUE);
+
+                if ( result < 0 ) {
+
+                    HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, \
+                                "unable to flush clean entry")
+                }
+            }
+            /* just skip the entry if it is dirty, as we can't do 
+             * anything with it now since we can't write.
+             */
+
+            entry_ptr = prev_ptr;
+
+        } /* end while */
+    }
+
+    if ( cache_ptr->index_size < cache_ptr->max_cache_size ) {
+
+        cache_ptr->cache_full = FALSE;
+    }
+
+done:
+
+    FUNC_LEAVE_NOAPI(ret_value)
+
+} /* H5C__autoadjust__ageout__evict_aged_out_entries() */
+
+
+/*-------------------------------------------------------------------------
+ *
+ * Function:    H5C__autoadjust__ageout__insert_new_marker
+ *
+ * Purpose:     Find an unused marker cache entry, mark it as used, and 
+ *		insert it at the head of the LRU list.  Also add the 
+ *		marker's index in the epoch_markers array.
+ *
+ * Return:      SUCCEED on success/FAIL on failure.
+ *
+ * Programmer:  John Mainzer, 11/19/04
+ *
+ * Modifications:
+ *
+ *              None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+static herr_t
+H5C__autoadjust__ageout__insert_new_marker(H5C_t * cache_ptr)
+{
+    herr_t                      ret_value = SUCCEED;      /* Return value */
+    int i;
+
+    FUNC_ENTER_NOAPI_NOINIT(H5C__autoadjust__ageout__insert_new_marker)
+
+    HDassert( cache_ptr );
+    HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
+
+    if ( cache_ptr->epoch_markers_active >=
+         (cache_ptr->resize_ctl).epochs_before_eviction ) {
+
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
+                    "Already have a full complement of markers.")
+    }
+
+    /* find an unused marker */
+    i = 0;
+    while ( ( (cache_ptr->epoch_marker_active)[i] ) && 
+            ( i < H5C__MAX_EPOCH_MARKERS ) ) 
+    {
+        i++;
+    }
+
+    HDassert( i < H5C__MAX_EPOCH_MARKERS );
+
+    if ( (cache_ptr->epoch_marker_active)[i] != FALSE ) {
+
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Can't find unused marker.")
+    }
+
+    HDassert( ((cache_ptr->epoch_markers)[i]).addr == (haddr_t)i );
+    HDassert( ((cache_ptr->epoch_markers)[i]).next == NULL );
+    HDassert( ((cache_ptr->epoch_markers)[i]).prev == NULL );
+
+    (cache_ptr->epoch_marker_active)[i] = TRUE;
+
+    cache_ptr->epoch_marker_ringbuf_last = 
+        (cache_ptr->epoch_marker_ringbuf_last + 1) % 
+        (H5C__MAX_EPOCH_MARKERS + 1);
+
+    (cache_ptr->epoch_marker_ringbuf)[cache_ptr->epoch_marker_ringbuf_last] = i;
+
+    cache_ptr->epoch_marker_ringbuf_size += 1;
+
+    if ( cache_ptr->epoch_marker_ringbuf_size > H5C__MAX_EPOCH_MARKERS ) {
+
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "ring buffer overflow.")
+    }
+
+    H5C__DLL_PREPEND((&((cache_ptr->epoch_markers)[i])), \
+                     (cache_ptr)->LRU_head_ptr, \
+                     (cache_ptr)->LRU_tail_ptr, \
+                     (cache_ptr)->LRU_list_len, \
+                     (cache_ptr)->LRU_list_size, \
+                     (FAIL))
+
+    cache_ptr->epoch_markers_active += 1;
+
+done:
+
+    FUNC_LEAVE_NOAPI(ret_value)
+
+} /* H5C__autoadjust__ageout__insert_new_marker() */
+
+
+/*-------------------------------------------------------------------------
+ *
+ * Function:    H5C__autoadjust__ageout__remove_all_markers
+ *
+ * Purpose:     Remove all epoch markers from the LRU list and mark them 
+ *		as inactive.
+ *
+ * Return:      SUCCEED on success/FAIL on failure.
+ *
+ * Programmer:  John Mainzer, 11/22/04
+ *
+ * Modifications:
+ *
+ *              None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+static herr_t
+H5C__autoadjust__ageout__remove_all_markers(H5C_t * cache_ptr)
+{
+    herr_t                      ret_value = SUCCEED;      /* Return value */
+    int i;
+    int ring_buf_index;
+
+    FUNC_ENTER_NOAPI_NOINIT(H5C__autoadjust__ageout__remove_all_markers)
+
+    HDassert( cache_ptr );
+    HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
+
+    while ( cache_ptr->epoch_markers_active > 0 )
+    {
+        /* get the index of the last epoch marker in the LRU list 
+         * and remove it from the ring buffer.
+         */
+
+        ring_buf_index = cache_ptr->epoch_marker_ringbuf_first;
+        i = (cache_ptr->epoch_marker_ringbuf)[ring_buf_index];
+
+        cache_ptr->epoch_marker_ringbuf_first = 
+            (cache_ptr->epoch_marker_ringbuf_first + 1) % 
+            (H5C__MAX_EPOCH_MARKERS + 1);
+
+        cache_ptr->epoch_marker_ringbuf_size -= 1;
+
+        if ( cache_ptr->epoch_marker_ringbuf_size < 0 ) {
+
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "ring buffer underflow.")
+        }
+
+        if ( (cache_ptr->epoch_marker_active)[i] != TRUE ) {
+
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "unused marker in LRU?!?")
+        }
+
+        /* remove the epoch marker from the LRU list */
+        H5C__DLL_REMOVE((&((cache_ptr->epoch_markers)[i])), \
+                        (cache_ptr)->LRU_head_ptr, \
+                        (cache_ptr)->LRU_tail_ptr, \
+                        (cache_ptr)->LRU_list_len, \
+                        (cache_ptr)->LRU_list_size, \
+                        (FAIL))
+
+        /* mark the epoch marker as unused. */
+        (cache_ptr->epoch_marker_active)[i] = FALSE;
+
+        HDassert( ((cache_ptr->epoch_markers)[i]).addr == (haddr_t)i );
+        HDassert( ((cache_ptr->epoch_markers)[i]).next == NULL );
+        HDassert( ((cache_ptr->epoch_markers)[i]).prev == NULL );
+
+        /* decrement the number of active epoch markers */
+        cache_ptr->epoch_markers_active -= 1;
+
+        HDassert( cache_ptr->epoch_markers_active == \
+                  cache_ptr->epoch_marker_ringbuf_size );
+    }
+
+done:
+
+    FUNC_LEAVE_NOAPI(ret_value)
+
+} /* H5C__autoadjust__ageout__remove_all_markers() */
+
+
+/*-------------------------------------------------------------------------
+ *
+ * Function:    H5C__autoadjust__ageout__remove_excess_markers
+ *
+ * Purpose:     Remove epoch markers from the end of the LRU list and 
+ *		mark them as inactive until the number of active markers
+ *		equals the the current value of 
+ *		(cache_ptr->resize_ctl).epochs_before_eviction.
+ *
+ * Return:      SUCCEED on success/FAIL on failure.
+ *
+ * Programmer:  John Mainzer, 11/19/04
+ *
+ * Modifications:
+ *
+ *              None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+static herr_t
+H5C__autoadjust__ageout__remove_excess_markers(H5C_t * cache_ptr)
+{
+    herr_t	ret_value = SUCCEED;      /* Return value */
+    int		i;
+    int		ring_buf_index;
+
+    FUNC_ENTER_NOAPI_NOINIT(H5C__autoadjust__ageout__remove_excess_markers)
+
+    HDassert( cache_ptr );
+    HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
+
+    if ( cache_ptr->epoch_markers_active <=
+         (cache_ptr->resize_ctl).epochs_before_eviction ) {
+
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "no excess markers on entry.")
+    }
+
+    while ( cache_ptr->epoch_markers_active > 
+            (cache_ptr->resize_ctl).epochs_before_eviction )
+    {
+        /* get the index of the last epoch marker in the LRU list 
+         * and remove it from the ring buffer.
+         */
+
+        ring_buf_index = cache_ptr->epoch_marker_ringbuf_first;
+        i = (cache_ptr->epoch_marker_ringbuf)[ring_buf_index];
+
+        cache_ptr->epoch_marker_ringbuf_first = 
+            (cache_ptr->epoch_marker_ringbuf_first + 1) % 
+            (H5C__MAX_EPOCH_MARKERS + 1);
+
+        cache_ptr->epoch_marker_ringbuf_size -= 1;
+
+        if ( cache_ptr->epoch_marker_ringbuf_size < 0 ) {
+
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "ring buffer underflow.")
+        }
+
+        if ( (cache_ptr->epoch_marker_active)[i] != TRUE ) {
+
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "unused marker in LRU?!?")
+        }
+
+        /* remove the epoch marker from the LRU list */
+        H5C__DLL_REMOVE((&((cache_ptr->epoch_markers)[i])), \
+                        (cache_ptr)->LRU_head_ptr, \
+                        (cache_ptr)->LRU_tail_ptr, \
+                        (cache_ptr)->LRU_list_len, \
+                        (cache_ptr)->LRU_list_size, \
+                        (FAIL))
+
+        /* mark the epoch marker as unused. */
+        (cache_ptr->epoch_marker_active)[i] = FALSE;
+
+        HDassert( ((cache_ptr->epoch_markers)[i]).addr == (haddr_t)i );
+        HDassert( ((cache_ptr->epoch_markers)[i]).next == NULL );
+        HDassert( ((cache_ptr->epoch_markers)[i]).prev == NULL );
+
+        /* decrement the number of active epoch markers */
+        cache_ptr->epoch_markers_active -= 1;
+
+        HDassert( cache_ptr->epoch_markers_active == \
+                  cache_ptr->epoch_marker_ringbuf_size );
+    }
+
+done:
+
+    FUNC_LEAVE_NOAPI(ret_value)
+
+} /* H5C__autoadjust__ageout__remove_excess_markers() */
+
+
+/*-------------------------------------------------------------------------
+ *
  * Function:    H5C_flush_single_entry
  *
  * Purpose:     Flush or clear (and evict if requested) the cache entry 
@@ -3689,27 +5345,40 @@ H5C_flush_single_entry(H5F_t *		   f,
     H5C__SEARCH_INDEX(cache_ptr, addr, entry_ptr, FAIL)
 
 #if H5C_DO_SANITY_CHECKS
-    if ( entry_ptr->in_slist ) {
+    if ( entry_ptr != NULL ) {
 
-        if ( ( entry_ptr->addr != addr ) ) {
+        if ( entry_ptr->in_slist ) {
 
-            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                        "Hash table and skip list out of sync.")
-        }
-    } else if ( entry_ptr != NULL ) {
+            if ( entry_ptr->addr != addr ) {
+
+                HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
+                            "entry in slist failed sanity checks.")
+            }
+        } else {
 
-        if ( ( entry_ptr->in_slist ) ||
-             ( entry_ptr->is_dirty ) ||
-             ( entry_ptr->addr != addr ) ) {
+            if ( ( entry_ptr->is_dirty ) || ( entry_ptr->addr != addr ) ) {
 
-            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                        "entry failed sanity checks.")
+                HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
+                            "entry failed sanity checks.")
+            }
         }
     }
+#if 0 
+    /* this should be useful for debugging from time to time.
+     * lets leave it in for now.       -- JRM 12/15/04
+     */
+    else {
+        HDfprintf(stdout, 
+                  "H5C_flush_single_entry(): non-existant entry. addr = %a\n",
+                  addr);
+        HDfflush(stdout);
+    }
+#endif
 #endif /* H5C_DO_SANITY_CHECKS */
 
     if ( ( entry_ptr != NULL ) && ( entry_ptr->is_protected ) )
     {
+
         /* Attempt to flush a protected entry -- scream and die. */
         HGOTO_ERROR(H5E_CACHE, H5E_PROTECT, FAIL, \
                     "Attempt to flush a protected entry.")
@@ -3773,9 +5442,9 @@ H5C_flush_single_entry(H5F_t *		   f,
         }
 
         /* Always remove the entry from the hash table on a destroy.  On a 
-         * flush with destroy, it is cheaper to discard the skip list all at once
-         * rather than remove the entries one by one, so we only delete from
-         * the list if requested.
+         * flush with destroy, it is cheaper to discard the skip list all at 
+         * once rather than remove the entries one by one, so we only delete 
+         * from the list if requested.
          *
          * We must do deletions now as the callback routines will free the 
          * entry if destroy is true.
@@ -3784,7 +5453,8 @@ H5C_flush_single_entry(H5F_t *		   f,
 
             H5C__DELETE_FROM_INDEX(cache_ptr, entry_ptr)
 
-            if ( ( entry_ptr->in_slist ) && ( del_entry_from_slist_on_destroy ) ) {
+            if ( ( entry_ptr->in_slist ) && 
+                 ( del_entry_from_slist_on_destroy ) ) {
 
                 H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr)
             }
@@ -3805,8 +5475,10 @@ H5C_flush_single_entry(H5F_t *		   f,
 
         /* Clear the dirty flag only, if requested */
         if ( clear_only ) {
+
             /* Call the callback routine to clear all dirty flags for object */
             if ( (entry_ptr->type->clear)(f, entry_ptr, destroy) < 0 ) {
+
                 HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "can't clear entry")
             }
         } else {
@@ -3815,16 +5487,20 @@ H5C_flush_single_entry(H5F_t *		   f,
              */
 
             if ( *first_flush_ptr && entry_ptr->is_dirty ) {
+
                 status = (entry_ptr->type->flush)(f, primary_dxpl_id, destroy, 
                                                  entry_ptr->addr, entry_ptr);
                 *first_flush_ptr = FALSE;
+
             } else {
+
                 status = (entry_ptr->type->flush)(f, secondary_dxpl_id, 
                                                  destroy, entry_ptr->addr, 
                                                  entry_ptr);
             }
 
             if ( status < 0 ) {
+
                 HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, \
                             "unable to flush entry")
             }
@@ -3970,6 +5646,14 @@ done:
  *		Minor modifications in support of the addition of a hash
  *		table to facilitate lookups.
  *
+ *		JRM -- 11/22/04
+ *		Added the first_flush_ptr parameter, which replaces the 
+ *		old first_flush local variable.  This allows the function
+ *		to coordinate on the first flush issue with other functions.
+ *
+ *		JRM -- 12/13/04
+ *		Added code to skip over epoch markers if present.
+ *
  *-------------------------------------------------------------------------
  */
 
@@ -3979,9 +5663,9 @@ H5C_make_space_in_cache(H5F_t *	f,
                         hid_t	secondary_dxpl_id,
                         H5C_t *	cache_ptr,
 		        size_t	space_needed,
-                        hbool_t	write_permitted)
+                        hbool_t	write_permitted,
+                        hbool_t * first_flush_ptr)
 {
-    hbool_t		first_flush = TRUE;
     herr_t		ret_value = SUCCEED;      /* Return value */
     herr_t		result;
     int32_t		entries_examined = 0;
@@ -3993,6 +5677,8 @@ H5C_make_space_in_cache(H5F_t *	f,
 
     HDassert( cache_ptr );
     HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
+    HDassert( first_flush_ptr != NULL );
+    HDassert( ( *first_flush_ptr == TRUE ) || ( *first_flush_ptr == FALSE ) );
 
     if ( write_permitted ) {
 
@@ -4013,28 +5699,37 @@ H5C_make_space_in_cache(H5F_t *	f,
 
             prev_ptr = entry_ptr->prev;
 
-            if ( entry_ptr->is_dirty ) {
+            if ( (entry_ptr->type)->id != H5C__EPOCH_MARKER_TYPE ) {
 
-                result = H5C_flush_single_entry(f, 
-                                                primary_dxpl_id, 
-                                                secondary_dxpl_id,
-                                                cache_ptr,
-                                                entry_ptr->type, 
-                                                entry_ptr->addr, 
-                                                (unsigned)0, 
-                                                &first_flush, 
-                                                FALSE);
+                if ( entry_ptr->is_dirty ) {
+
+                    result = H5C_flush_single_entry(f, 
+                                                    primary_dxpl_id, 
+                                                    secondary_dxpl_id,
+                                                    cache_ptr,
+                                                    entry_ptr->type, 
+                                                    entry_ptr->addr, 
+                                                    (unsigned)0, 
+                                                    first_flush_ptr, 
+                                                    FALSE);
+                } else {
+
+                    result = H5C_flush_single_entry(f, 
+                                                    primary_dxpl_id, 
+                                                    secondary_dxpl_id,
+                                                    cache_ptr,
+                                                    entry_ptr->type, 
+                                                    entry_ptr->addr, 
+                                                    H5F_FLUSH_INVALIDATE,
+                                                    first_flush_ptr, 
+                                                    TRUE);
+                }
             } else {
 
-                result = H5C_flush_single_entry(f, 
-                                                primary_dxpl_id, 
-                                                secondary_dxpl_id,
-                                                cache_ptr,
-                                                entry_ptr->type, 
-                                                entry_ptr->addr, 
-                                                H5F_FLUSH_INVALIDATE,
-                                                &first_flush, 
-                                                TRUE);
+                /* Skip epoch markers.  Set result to SUCCEED to avoid
+                 * triggering the error code below.
+                 */
+                result = SUCCEED;
             }
 
             if ( result < 0 ) {
@@ -4069,7 +5764,7 @@ H5C_make_space_in_cache(H5F_t *	f,
                                             entry_ptr->type, 
                                             entry_ptr->addr, 
                                             (unsigned)0, 
-                                            &first_flush, 
+                                            first_flush_ptr, 
                                             FALSE);
 
             if ( result < 0 ) {
@@ -4112,7 +5807,7 @@ H5C_make_space_in_cache(H5F_t *	f,
                                             entry_ptr->type, 
                                             entry_ptr->addr, 
                                             H5F_FLUSH_INVALIDATE,
-                                            &first_flush, 
+                                            first_flush_ptr, 
                                             TRUE);
 
             if ( result < 0 ) {