diff options
Diffstat (limited to 'test/cache.c')
| -rw-r--r-- | test/cache.c | 934 |
1 files changed, 467 insertions, 467 deletions
diff --git a/test/cache.c b/test/cache.c index 6ea92ef..7de613e 100644 --- a/test/cache.c +++ b/test/cache.c @@ -965,7 +965,7 @@ smoke_check_5(void) /* hbool_t apply_max_increment = */ TRUE, /* size_t max_increment = */ (4 * 1024 * 1024), - /* enum H5C_cache_flash_incr_mode */ + /* enum H5C_cache_flash_incr_mode */ /* flash_incr_mode = */ H5C_flash_incr__off, /* double flash_multiple = */ 2.0, /* double flash_threshold = */ 0.5, @@ -1205,7 +1205,7 @@ smoke_check_6(void) /* hbool_t apply_max_increment = */ TRUE, /* size_t max_increment = */ (4 * 1024 * 1024), - /* enum H5C_cache_flash_incr_mode */ + /* enum H5C_cache_flash_incr_mode */ /* flash_incr_mode = */ H5C_flash_incr__off, /* double flash_multiple = */ 2.0, /* double flash_threshold = */ 0.5, @@ -1445,7 +1445,7 @@ smoke_check_7(void) /* hbool_t apply_max_increment = */ TRUE, /* size_t max_increment = */ (8 * 1024 * 1024), - /* enum H5C_cache_flash_incr_mode */ + /* enum H5C_cache_flash_incr_mode */ /* flash_incr_mode = */ H5C_flash_incr__off, /* double flash_multiple = */ 2.0, /* double flash_threshold = */ 0.5, @@ -1686,7 +1686,7 @@ smoke_check_8(void) /* hbool_t apply_max_increment = */ TRUE, /* size_t max_increment = */ (4 * 1024 * 1024), - /* enum H5C_cache_flash_incr_mode */ + /* enum H5C_cache_flash_incr_mode */ /* flash_incr_mode = */ H5C_flash_incr__off, /* double flash_multiple = */ 2.0, /* double flash_threshold = */ 0.5, @@ -1871,9 +1871,9 @@ smoke_check_8(void) * Purpose: A repeat of smoke check 1, only with the cache corked * part of the time. * - * Recall that smoke check 1 is a basic functional test, - * with inserts, destroys, and renames in the mix, along - * with repeated protects and unprotects. All entries are + * Recall that smoke check 1 is a basic functional test, + * with inserts, destroys, and renames in the mix, along + * with repeated protects and unprotects. All entries are * marked as clean. * * Return: void @@ -2178,9 +2178,9 @@ smoke_check_9(void) * Purpose: A repeat of smoke check 2, only with the cache corked * part of the time. * - * Recall that smoke check 2 is a basic functional test, - * with inserts, destroys, and renames in the mix, along - * with some repeated protects and unprotects. About half + * Recall that smoke check 2 is a basic functional test, + * with inserts, destroys, and renames in the mix, along + * with some repeated protects and unprotects. About half * the entries are marked as dirty. * * Return: void @@ -2708,12 +2708,12 @@ check_insert_entry(void) pass = TRUE; - /* Allocate a cache, and insert entries into it using all + /* Allocate a cache, and insert entries into it using all * combinations of flags. Verify that the entries are inserted, * and that the flags have the desired effects. * * Note that the dirty parameter in insert_entry is no longer - * used, as we have decided that all inserted entries are + * used, as we have decided that all inserted entries are * dirty by definition. (Which sounds very reasonable, but didn't * used to be the case.) */ @@ -2729,10 +2729,10 @@ check_insert_entry(void) if ( pass ) { insert_entry(cache_ptr, entry_type, 0, TRUE, H5C__NO_FLAGS_SET); - insert_entry(cache_ptr, entry_type, 1, TRUE, + insert_entry(cache_ptr, entry_type, 1, TRUE, H5C__SET_FLUSH_MARKER_FLAG); insert_entry(cache_ptr, entry_type, 2, TRUE, H5C__PIN_ENTRY_FLAG); - insert_entry(cache_ptr, entry_type, 3, TRUE, + insert_entry(cache_ptr, entry_type, 3, TRUE, (H5C__SET_FLUSH_MARKER_FLAG | H5C__PIN_ENTRY_FLAG)); } @@ -2748,7 +2748,7 @@ check_insert_entry(void) /* Start by checking everything we can via H5C_get_entry_status() */ result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size, - &in_cache, &is_dirty, &is_protected, + &in_cache, &is_dirty, &is_protected, &is_pinned); if ( result < 0 ) { @@ -2757,10 +2757,10 @@ check_insert_entry(void) failure_mssg = "H5AC_get_entry_status() reports failure."; } - if ( pass ) { + if ( pass ) { /* check the universals */ - if ( ( ! in_cache ) || ( ! is_dirty ) || ( is_protected ) || + if ( ( ! in_cache ) || ( ! is_dirty ) || ( is_protected ) || ( entry_size != entry_sizes[entry_type] ) ) { pass = FALSE; @@ -2819,7 +2819,7 @@ check_insert_entry(void) search_ptr = cache_ptr->pel_head_ptr; while ( ( search_ptr != NULL ) && - ( search_ptr != + ( search_ptr != (struct H5C_cache_entry_t *)entry_ptr ) ) { search_ptr = search_ptr->next; @@ -2841,7 +2841,7 @@ check_insert_entry(void) search_ptr = cache_ptr->LRU_head_ptr; while ( ( search_ptr != NULL ) && - ( search_ptr != + ( search_ptr != (struct H5C_cache_entry_t *)entry_ptr ) ) { search_ptr = search_ptr->next; @@ -2864,7 +2864,7 @@ check_insert_entry(void) search_ptr = cache_ptr->dLRU_head_ptr; while ( ( search_ptr != NULL ) && - ( search_ptr != + ( search_ptr != (struct H5C_cache_entry_t *)entry_ptr ) ) { search_ptr = search_ptr->aux_next; @@ -2884,8 +2884,8 @@ check_insert_entry(void) } /* while */ - /* So much for looking at the individual entries. Now verify - * that the various counts and sized in the cache header are + /* So much for looking at the individual entries. Now verify + * that the various counts and sized in the cache header are * as expected. */ @@ -5383,9 +5383,9 @@ check_flush_cache__pe_multi_entry_test(H5C_t * cache_ptr, /*------------------------------------------------------------------------- * Function: check_flush_cache__flush_ops() * - * Purpose: Run the flush ops cache tests. + * Purpose: Run the flush ops cache tests. * - * These are tests that test the cache's ability to handle + * These are tests that test the cache's ability to handle * the case in which the flush callback dirties, resizes, * and/or renames entries. * @@ -5421,7 +5421,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) if ( pass ) /* test #1 */ { /* start with a very simple test, in which there are two entries - * resident in cache, and the second entry dirties the first in + * resident in cache, and the second entry dirties the first in * the flush callback. No size changes, and no flush flags. */ int test_num = 1; @@ -5431,9 +5431,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) size_t init_expected_index_size = 2 * PICO_ENTRY_SIZE; int expected_index_len = 2; size_t expected_index_size = 2 * PICO_ENTRY_SIZE; - struct fo_flush_cache_test_spec spec[2] = + struct fo_flush_cache_test_spec spec[2] = { - { + { /* entry_num = */ 0, /* entry_type = */ 0, /* entry_index = */ 0, @@ -5461,7 +5461,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) /* expected_flushed = */ TRUE, /* expected_destroyed = */ FALSE }, - { + { /* entry_num = */ 1, /* entry_type = */ 0, /* entry_index = */ 1, @@ -5529,8 +5529,8 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) * Note that we must repeat all tests with the flush invalidate flag * as this triggers a different set of code to execute the flush. * - * Create two entries resident in cache, and have the second entry - * dirty the first in the flush callback. + * Create two entries resident in cache, and have the second entry + * dirty the first in the flush callback. */ int test_num = 2; unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG; @@ -5539,9 +5539,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) size_t init_expected_index_size = 2 * PICO_ENTRY_SIZE; int expected_index_len = 0; size_t expected_index_size = 0; - struct fo_flush_cache_test_spec spec[2] = + struct fo_flush_cache_test_spec spec[2] = { - { + { /* entry_num = */ 0, /* entry_type = */ PICO_ENTRY_TYPE, /* entry_index = */ 0, @@ -5569,7 +5569,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) /* expected_flushed = */ TRUE, /* expected_destroyed = */ TRUE }, - { + { /* entry_num = */ 1, /* entry_type = */ PICO_ENTRY_TYPE, /* entry_index = */ 1, @@ -5644,9 +5644,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) size_t init_expected_index_size = VARIABLE_ENTRY_SIZE / 4; int expected_index_len = 1; size_t expected_index_size = VARIABLE_ENTRY_SIZE / 2; - struct fo_flush_cache_test_spec spec[1] = + struct fo_flush_cache_test_spec spec[1] = { - { + { /* entry_num = */ 0, /* entry_type = */ VARIABLE_ENTRY_TYPE, /* entry_index = */ 0, @@ -5723,9 +5723,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) size_t init_expected_index_size = VARIABLE_ENTRY_SIZE / 4; int expected_index_len = 0; size_t expected_index_size = 0; - struct fo_flush_cache_test_spec spec[1] = + struct fo_flush_cache_test_spec spec[1] = { - { + { /* entry_num = */ 0, /* entry_type = */ VARIABLE_ENTRY_TYPE, /* entry_index = */ 0, @@ -5793,8 +5793,8 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) * which the call back function renames the entry for which it has * been called. * - * Run this entry twice, as the first run moves the entry to its - * alternate address, and the second moves it back. + * Run this entry twice, as the first run moves the entry to its + * alternate address, and the second moves it back. */ int test_num = 5; /* and 6 */ unsigned int flush_flags = H5C__NO_FLAGS_SET; @@ -5803,9 +5803,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) size_t init_expected_index_size = VARIABLE_ENTRY_SIZE; int expected_index_len = 1; size_t expected_index_size = VARIABLE_ENTRY_SIZE; - struct fo_flush_cache_test_spec spec[1] = + struct fo_flush_cache_test_spec spec[1] = { - { + { /* entry_num = */ 0, /* entry_type = */ VARIABLE_ENTRY_TYPE, /* entry_index = */ 0, @@ -5866,15 +5866,15 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) check_size, checks); - /* this change forces the rename to move the target entry back to its + /* this change forces the rename to move the target entry back to its * main address. The first test moved it to its alternate address. * * Note that these two tests are not the same, as in the first test, - * the renamed entry is moved forward in the slist. In the second + * the renamed entry is moved forward in the slist. In the second * it is moved backwards. * * Since there is only one entry in the cache, this doesn't really - * matter in this case. But we will do similar tests later with + * matter in this case. But we will do similar tests later with * other entries in the cache. */ if ( pass ) { @@ -5898,15 +5898,15 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) if ( pass ) /* test #7 & #8 */ { - /* Run tests 5 & 6 again, using the flush invalidate flag on the + /* Run tests 5 & 6 again, using the flush invalidate flag on the * second test. * * Single entry test verifying that the cache can handle the case in * which the call back function renames the entry for which it has * been called. * - * Run this entry twice, as the first run moves the entry to its - * alternate address, and the second moves it back. + * Run this entry twice, as the first run moves the entry to its + * alternate address, and the second moves it back. */ int test_num = 7; /* and 8 */ unsigned int flush_flags = H5C__NO_FLAGS_SET; @@ -5915,9 +5915,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) size_t init_expected_index_size = VARIABLE_ENTRY_SIZE; int expected_index_len = 1; size_t expected_index_size = VARIABLE_ENTRY_SIZE; - struct fo_flush_cache_test_spec spec[1] = + struct fo_flush_cache_test_spec spec[1] = { - { + { /* entry_num = */ 0, /* entry_type = */ VARIABLE_ENTRY_TYPE, /* entry_index = */ 0, @@ -5978,15 +5978,15 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) check_size, checks); - /* this change forces the rename to move the target entry back to its + /* this change forces the rename to move the target entry back to its * main address. The first test moved it to its alternate address. * * Note that these two tests are not the same, as in the first test, - * the renamed entry is moved forward in the slist. In the second + * the renamed entry is moved forward in the slist. In the second * it is moved backwards. * * Since there is only one entry in the cache, this doesn't really - * matter in this case. But we will do similar tests later with + * matter in this case. But we will do similar tests later with * other entries in the cache. */ @@ -6016,11 +6016,11 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) if ( pass ) /* test #9 & #10 */ { /* Single entry test verifying that the cache can handle the case in - * which the call back function both resizes and renames the entry + * which the call back function both resizes and renames the entry * for which it has been called. * - * Again, we run this entry twice, as the first run moves the entry to its - * alternate address, and the second moves it back. + * Again, we run this entry twice, as the first run moves the entry to its + * alternate address, and the second moves it back. */ int test_num = 9; /* and 10 */ unsigned int flush_flags = H5C__NO_FLAGS_SET; @@ -6029,9 +6029,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) size_t init_expected_index_size = VARIABLE_ENTRY_SIZE / 2; int expected_index_len = 1; size_t expected_index_size = VARIABLE_ENTRY_SIZE / 4; - struct fo_flush_cache_test_spec spec[1] = + struct fo_flush_cache_test_spec spec[1] = { - { + { /* entry_num = */ 0, /* entry_type = */ VARIABLE_ENTRY_TYPE, /* entry_index = */ 0, @@ -6092,15 +6092,15 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) check_size, checks); - /* this change forces the rename to move the target entry back to its + /* this change forces the rename to move the target entry back to its * main address. The first test moved it to its alternate address. * * Note that these two tests are not the same, as in the first test, - * the renamed entry is moved forward in the slist. In the second + * the renamed entry is moved forward in the slist. In the second * it is moved backwards. * * Since there is only one entry in the cache, this doesn't really - * matter in this case. But we will do similar tests later with + * matter in this case. But we will do similar tests later with * other entries in the cache. */ if ( pass ) { @@ -6128,11 +6128,11 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) * second test. * * Single entry test verifying that the cache can handle the case in - * which the call back function both resizes and renames the entry + * which the call back function both resizes and renames the entry * for which it has been called. * - * Again, we run this entry twice, as the first run moves the entry to its - * alternate address, and the second moves it back. + * Again, we run this entry twice, as the first run moves the entry to its + * alternate address, and the second moves it back. */ int test_num = 11; /* and 12 */ unsigned int flush_flags = H5C__NO_FLAGS_SET; @@ -6141,9 +6141,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) size_t init_expected_index_size = VARIABLE_ENTRY_SIZE / 2; int expected_index_len = 1; size_t expected_index_size = VARIABLE_ENTRY_SIZE / 4; - struct fo_flush_cache_test_spec spec[1] = + struct fo_flush_cache_test_spec spec[1] = { - { + { /* entry_num = */ 0, /* entry_type = */ VARIABLE_ENTRY_TYPE, /* entry_index = */ 0, @@ -6204,15 +6204,15 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) check_size, checks); - /* this change forces the rename to move the target entry back to its + /* this change forces the rename to move the target entry back to its * main address. The first test moved it to its alternate address. * * Note that these two tests are not the same, as in the first test, - * the renamed entry is moved forward in the slist. In the second + * the renamed entry is moved forward in the slist. In the second * it is moved backwards. * * Since there is only one entry in the cache, this doesn't really - * matter in this case. But we will do similar tests later with + * matter in this case. But we will do similar tests later with * other entries in the cache. */ if ( pass ) { @@ -6241,9 +6241,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) if ( pass ) /* test #13 */ { - /* Test the ability of the cache to handle the case in which - * the flush function of an entry that is resident in cache - * dirties two entries that are not in cache. No size + /* Test the ability of the cache to handle the case in which + * the flush function of an entry that is resident in cache + * dirties two entries that are not in cache. No size * changes. * * At present, I am assured that this case will never occur, but @@ -6256,9 +6256,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) size_t init_expected_index_size = 1 * PICO_ENTRY_SIZE; int expected_index_len = 3; size_t expected_index_size = 3 * PICO_ENTRY_SIZE; - struct fo_flush_cache_test_spec spec[1] = + struct fo_flush_cache_test_spec spec[1] = { - { + { /* entry_num = */ 0, /* entry_type = */ 0, /* entry_index = */ 1, @@ -6339,9 +6339,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) { /* Repeat previous test with the flush invalidate flag. * - * Test the ability of the cache to handle the case in which - * the flush function of an entry that is resident in cache - * dirties two entries that are not in cache. No size + * Test the ability of the cache to handle the case in which + * the flush function of an entry that is resident in cache + * dirties two entries that are not in cache. No size * changes. * * At present, I am assured that this case will never occur, but @@ -6354,9 +6354,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) size_t init_expected_index_size = 1 * PICO_ENTRY_SIZE; int expected_index_len = 0; size_t expected_index_size = (size_t)0; - struct fo_flush_cache_test_spec spec[1] = + struct fo_flush_cache_test_spec spec[1] = { - { + { /* entry_num = */ 0, /* entry_type = */ 0, /* entry_index = */ 1, @@ -6435,8 +6435,8 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) if ( pass ) /* test #15 */ { - /* Test the ability of the cache to handle the case in which - * the flush function of an entry that is resident in cache + /* Test the ability of the cache to handle the case in which + * the flush function of an entry that is resident in cache * resizes and dirties two entries that are not in cache. * * At present, I am assured that this case will never occur, but @@ -6451,9 +6451,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) size_t expected_index_size = VARIABLE_ENTRY_SIZE + (VARIABLE_ENTRY_SIZE / 4) + (VARIABLE_ENTRY_SIZE / 2); - struct fo_flush_cache_test_spec spec[1] = + struct fo_flush_cache_test_spec spec[1] = { - { + { /* entry_num = */ 0, /* entry_type = */ VARIABLE_ENTRY_TYPE, /* entry_index = */ 1, @@ -6534,8 +6534,8 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) { /* Repeat previous test with the flush invalidate flag. * - * Test the ability of the cache to handle the case in which - * the flush function of an entry that is resident in cache + * Test the ability of the cache to handle the case in which + * the flush function of an entry that is resident in cache * resizes and dirties two entries that are not in cache. * * At present, I am assured that this case will never occur, but @@ -6548,9 +6548,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) size_t init_expected_index_size = 1 * VARIABLE_ENTRY_SIZE; int expected_index_len = 0; size_t expected_index_size = (size_t)0; - struct fo_flush_cache_test_spec spec[1] = + struct fo_flush_cache_test_spec spec[1] = { - { + { /* entry_num = */ 0, /* entry_type = */ VARIABLE_ENTRY_TYPE, /* entry_index = */ 1, @@ -6629,8 +6629,8 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) if ( pass ) /* test #17 & #18 */ { - /* Test the ability of the cache to handle the case in which - * the flush function of an entry that is resident in cache + /* Test the ability of the cache to handle the case in which + * the flush function of an entry that is resident in cache * resizes, dirties, and renames two entries that are not in cache. * * At present, I am assured that this case will never occur, but @@ -6645,9 +6645,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) size_t expected_index_size = VARIABLE_ENTRY_SIZE + (VARIABLE_ENTRY_SIZE / 4) + (VARIABLE_ENTRY_SIZE / 2); - struct fo_flush_cache_test_spec spec[1] = + struct fo_flush_cache_test_spec spec[1] = { - { + { /* entry_num = */ 0, /* entry_type = */ VARIABLE_ENTRY_TYPE, /* entry_index = */ 1, @@ -6710,7 +6710,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) /* expected_destroyed = */ FALSE } }; - + check_flush_cache__flush_op_test(cache_ptr, test_num, flush_flags, @@ -6723,12 +6723,12 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) check_size, checks); - /* this change forces the renames to move the target entries back to - * their main address. The first test moved them to their alternate + /* this change forces the renames to move the target entries back to + * their main address. The first test moved them to their alternate * address. * * Note that these two tests are not the same, as in the first test, - * the renamed entries are moved forward in the slist. In the second + * the renamed entries are moved forward in the slist. In the second * they are moved backwards. */ if ( pass ) { @@ -6758,8 +6758,8 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) /* Repeat the above test with the flush invalidate flag on the * second test. * - * Test the ability of the cache to handle the case in which - * the flush function of an entry that is resident in cache + * Test the ability of the cache to handle the case in which + * the flush function of an entry that is resident in cache * resizes, dirties, and renames two entries that are not in cache. * * At present, I am assured that this case will never occur, but @@ -6774,9 +6774,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) size_t expected_index_size = VARIABLE_ENTRY_SIZE + (VARIABLE_ENTRY_SIZE / 4) + (VARIABLE_ENTRY_SIZE / 2); - struct fo_flush_cache_test_spec spec[1] = + struct fo_flush_cache_test_spec spec[1] = { - { + { /* entry_num = */ 0, /* entry_type = */ VARIABLE_ENTRY_TYPE, /* entry_index = */ 1, @@ -6852,12 +6852,12 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) check_size, checks); - /* this change forces the renames to move the target entries back to - * their main address. The first test moved them to their alternate + /* this change forces the renames to move the target entries back to + * their main address. The first test moved them to their alternate * address. * * Note that these two tests are not the same, as in the first test, - * the renamed entries are moved forward in the slist. In the second + * the renamed entries are moved forward in the slist. In the second * they are moved backwards. */ if ( pass ) { @@ -6894,14 +6894,14 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) { /* Now mix things up a bit. * - * Load several entries, two of which have flush functions that - * resize, dirty, and rename two entries that are not in the - * cache. Mark only one of these entries, and then flush the + * Load several entries, two of which have flush functions that + * resize, dirty, and rename two entries that are not in the + * cache. Mark only one of these entries, and then flush the * cache with the flush marked entries flag. * - * This is the only test in which we test the + * This is the only test in which we test the * H5C__FLUSH_MARKED_ENTRIES_FLAG. The hope is that since - * we test the two features extensively by themselves, so + * we test the two features extensively by themselves, so * it should be sufficient to verify that they play together * as expected. */ @@ -6915,9 +6915,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) (VARIABLE_ENTRY_SIZE / 4) + (VARIABLE_ENTRY_SIZE / 2) + (2 * PICO_ENTRY_SIZE); - struct fo_flush_cache_test_spec spec[4] = + struct fo_flush_cache_test_spec spec[4] = { - { + { /* entry_num = */ 0, /* entry_type = */ VARIABLE_ENTRY_TYPE, /* entry_index = */ 1, @@ -6945,7 +6945,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) /* expected_flushed = */ TRUE, /* expected_destroyed = */ FALSE }, - { + { /* entry_num = */ 1, /* entry_type = */ VARIABLE_ENTRY_TYPE, /* entry_index = */ 11, @@ -6973,7 +6973,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) /* expected_flushed = */ FALSE, /* expected_destroyed = */ FALSE }, - { + { /* entry_num = */ 2, /* entry_type = */ PICO_ENTRY_TYPE, /* entry_index = */ 0, @@ -7001,7 +7001,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) /* expected_flushed = */ TRUE, /* expected_destroyed = */ FALSE }, - { + { /* entry_num = */ 3, /* entry_type = */ PICO_ENTRY_TYPE, /* entry_index = */ 1, @@ -7113,9 +7113,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) { /* Mix things up some more. * - * Load lots of entries, some of which have flush functions that - * resize, dirty, and rename two entries that are not in the - * cache. + * Load lots of entries, some of which have flush functions that + * resize, dirty, and rename two entries that are not in the + * cache. * * Also load entries that have flush ops on entries that are in * cache. @@ -7130,9 +7130,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) (2 * (VARIABLE_ENTRY_SIZE / 4)) + (2 * (VARIABLE_ENTRY_SIZE / 2)) + (4 * PICO_ENTRY_SIZE); - struct fo_flush_cache_test_spec spec[6] = + struct fo_flush_cache_test_spec spec[6] = { - { + { /* entry_num = */ 0, /* entry_type = */ VARIABLE_ENTRY_TYPE, /* entry_index = */ 1, @@ -7160,7 +7160,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) /* expected_flushed = */ TRUE, /* expected_destroyed = */ FALSE }, - { + { /* entry_num = */ 1, /* entry_type = */ VARIABLE_ENTRY_TYPE, /* entry_index = */ 11, @@ -7188,7 +7188,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) /* expected_flushed = */ TRUE, /* expected_destroyed = */ FALSE }, - { + { /* entry_num = */ 2, /* entry_type = */ PICO_ENTRY_TYPE, /* entry_index = */ 0, @@ -7216,7 +7216,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) /* expected_flushed = */ TRUE, /* expected_destroyed = */ FALSE }, - { + { /* entry_num = */ 3, /* entry_type = */ PICO_ENTRY_TYPE, /* entry_index = */ 1, @@ -7244,7 +7244,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) /* expected_flushed = */ FALSE, /* expected_destroyed = */ FALSE }, - { + { /* entry_num = */ 4, /* entry_type = */ PICO_ENTRY_TYPE, /* entry_index = */ 10, @@ -7272,7 +7272,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) /* expected_flushed = */ TRUE, /* expected_destroyed = */ FALSE }, - { + { /* entry_num = */ 5, /* entry_type = */ PICO_ENTRY_TYPE, /* entry_index = */ 20, @@ -7386,9 +7386,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) * * Mix things up some more. * - * Load lots of entries, some of which have flush functions that - * resize, dirty, and rename two entries that are not in the - * cache. + * Load lots of entries, some of which have flush functions that + * resize, dirty, and rename two entries that are not in the + * cache. * * Also load entries that have flush ops on entries that are in * cache. @@ -7400,9 +7400,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) size_t init_expected_index_size = (2 * VARIABLE_ENTRY_SIZE) + (4 * PICO_ENTRY_SIZE); int expected_index_len = 0; size_t expected_index_size = 0; - struct fo_flush_cache_test_spec spec[6] = + struct fo_flush_cache_test_spec spec[6] = { - { + { /* entry_num = */ 0, /* entry_type = */ VARIABLE_ENTRY_TYPE, /* entry_index = */ 1, @@ -7430,7 +7430,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) /* expected_flushed = */ TRUE, /* expected_destroyed = */ TRUE }, - { + { /* entry_num = */ 1, /* entry_type = */ VARIABLE_ENTRY_TYPE, /* entry_index = */ 11, @@ -7458,7 +7458,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) /* expected_flushed = */ TRUE, /* expected_destroyed = */ TRUE }, - { + { /* entry_num = */ 2, /* entry_type = */ PICO_ENTRY_TYPE, /* entry_index = */ 0, @@ -7486,7 +7486,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) /* expected_flushed = */ TRUE, /* expected_destroyed = */ TRUE }, - { + { /* entry_num = */ 3, /* entry_type = */ PICO_ENTRY_TYPE, /* entry_index = */ 1, @@ -7514,7 +7514,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) /* expected_flushed = */ TRUE, /* expected_destroyed = */ TRUE }, - { + { /* entry_num = */ 4, /* entry_type = */ PICO_ENTRY_TYPE, /* entry_index = */ 10, @@ -7542,7 +7542,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) /* expected_flushed = */ TRUE, /* expected_destroyed = */ TRUE }, - { + { /* entry_num = */ 5, /* entry_type = */ PICO_ENTRY_TYPE, /* entry_index = */ 20, @@ -7666,9 +7666,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) size_t init_expected_index_size = 3 * PICO_ENTRY_SIZE; int expected_index_len = 3; size_t expected_index_size = 3 * PICO_ENTRY_SIZE; - struct fo_flush_cache_test_spec spec[3] = + struct fo_flush_cache_test_spec spec[3] = { - { + { /* entry_num = */ 0, /* entry_type = */ PICO_ENTRY_TYPE, /* entry_index = */ 100, @@ -7800,9 +7800,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) size_t init_expected_index_size = 3 * PICO_ENTRY_SIZE; int expected_index_len = 0; size_t expected_index_size = (size_t)0; - struct fo_flush_cache_test_spec spec[3] = + struct fo_flush_cache_test_spec spec[3] = { - { + { /* entry_num = */ 0, /* entry_type = */ PICO_ENTRY_TYPE, /* entry_index = */ 100, @@ -7922,22 +7922,22 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) if ( pass ) /* test #26 */ { - /* This one is complex. + /* This one is complex. * - * In the following overvies table, VET stands for + * In the following overvies table, VET stands for * VARIABLE_ENTRY_TYPE. * * In trying to follow what happens when we flush the * set of entries constructed below, recall that each - * flush operation is executed the first time the + * flush operation is executed the first time the * entry is flushed, and then not executed again. - * This may be a weakness in the tests, but that + * This may be a weakness in the tests, but that * is the way it is for now. * - * After thinking about it for a while, I'm not sure that - * the interaction between pins and flush operations needs - * all that much testing, as the two are essentially - * orthoginal. Thus this is a bit of a smoke check to + * After thinking about it for a while, I'm not sure that + * the interaction between pins and flush operations needs + * all that much testing, as the two are essentially + * orthoginal. Thus this is a bit of a smoke check to * verify that we get the expected results. * * (VET, 100) initially not resident in cache @@ -8004,9 +8004,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) size_t init_expected_index_size = 10 * VARIABLE_ENTRY_SIZE; int expected_index_len = 13; size_t expected_index_size = 9 * VARIABLE_ENTRY_SIZE; - struct fo_flush_cache_test_spec spec[10] = + struct fo_flush_cache_test_spec spec[10] = { - { + { /* entry_num = */ 0, /* entry_type = */ VARIABLE_ENTRY_TYPE, /* entry_index = */ 200, @@ -8357,24 +8357,24 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) { /* Repeat test #26 with the flush invalidate flag. * - * In the following overview table, VET stands for + * In the following overview table, VET stands for * VARIABLE_ENTRY_TYPE. * * In trying to follow what happens when we flush the * set of entries constructed below, recall that each - * flush operation is executed the first time the + * flush operation is executed the first time the * entry is flushed, and then not executed again. - * This may be a weakness in the tests, but that + * This may be a weakness in the tests, but that * is the way it is for now. * - * After thinking about it for a while, I'm not sure that - * the interaction between pins and flush operations needs - * all that much testing, as the two are essentially + * After thinking about it for a while, I'm not sure that + * the interaction between pins and flush operations needs + * all that much testing, as the two are essentially * orthoginal. The big thing is to verify that flushes of - * pinned entries with flush ops result in the expected + * pinned entries with flush ops result in the expected * updates of the cache. * - * Thus this is a bit of a smoke check to * verify that we + * Thus this is a bit of a smoke check to * verify that we * get the expected results. * * (VET, 100) initially not resident in cache @@ -8441,9 +8441,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) size_t init_expected_index_size = 10 * VARIABLE_ENTRY_SIZE; int expected_index_len = 0; size_t expected_index_size = (size_t)0; - struct fo_flush_cache_test_spec spec[10] = + struct fo_flush_cache_test_spec spec[10] = { - { + { /* entry_num = */ 0, /* entry_type = */ VARIABLE_ENTRY_TYPE, /* entry_index = */ 200, @@ -8793,7 +8793,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) if ( pass ) /* test #28 */ { /* Test the expected fheap case, in which an entry dirties - * and resizes itself, and dirties an entry which it has + * and resizes itself, and dirties an entry which it has * pinned. */ int test_num = 28; @@ -8803,9 +8803,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) size_t init_expected_index_size = 3 * VARIABLE_ENTRY_SIZE; int expected_index_len = 5; size_t expected_index_size = 4 * VARIABLE_ENTRY_SIZE; - struct fo_flush_cache_test_spec spec[5] = + struct fo_flush_cache_test_spec spec[5] = { - { + { /* entry_num = */ 0, /* entry_type = */ VARIABLE_ENTRY_TYPE, /* entry_index = */ 100, @@ -8986,7 +8986,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) /* Repeat test #28 with the flush invalidate flag. * * Test the expected fheap case, in which an entry dirties - * and resizes itself, and dirties an entry which it has + * and resizes itself, and dirties an entry which it has * pinned. */ int test_num = 29; @@ -8996,9 +8996,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) size_t init_expected_index_size = 3 * VARIABLE_ENTRY_SIZE; int expected_index_len = 0; size_t expected_index_size = 0; - struct fo_flush_cache_test_spec spec[5] = + struct fo_flush_cache_test_spec spec[5] = { - { + { /* entry_num = */ 0, /* entry_type = */ VARIABLE_ENTRY_TYPE, /* entry_index = */ 100, @@ -9185,7 +9185,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr) /*------------------------------------------------------------------------- * Function: check_flush_cache__flush_op_test() * - * Purpose: Run a flush op flush cache test. Of the nature of + * Purpose: Run a flush op flush cache test. Of the nature of * flush operations, this is a multi-entry test. * * Return: void @@ -9222,7 +9222,7 @@ check_flush_cache__flush_op_test(H5C_t * cache_ptr, #if 0 /* This is useful debugging code -- lets keep it around. */ HDfprintf(stdout, "check_flush_cache__flush_op_test: test %d\n", test_num); -#endif +#endif if ( cache_ptr == NULL ) { @@ -9282,23 +9282,23 @@ check_flush_cache__flush_op_test(H5C_t * cache_ptr, ( check[i].entry_index < 0 ) || ( check[i].entry_index > max_indices[check[i].entry_type] ) || ( check[i].expected_size <= (size_t)0 ) || - ( ( check[i].in_cache != TRUE ) && + ( ( check[i].in_cache != TRUE ) && ( check[i].in_cache != FALSE ) ) || - ( ( check[i].at_main_addr != TRUE ) && + ( ( check[i].at_main_addr != TRUE ) && ( check[i].at_main_addr != FALSE ) ) || - ( ( check[i].is_dirty != TRUE ) && + ( ( check[i].is_dirty != TRUE ) && ( check[i].is_dirty != FALSE ) ) || - ( ( check[i].is_protected != TRUE ) && + ( ( check[i].is_protected != TRUE ) && ( check[i].is_protected != FALSE ) ) || - ( ( check[i].is_pinned != TRUE ) && + ( ( check[i].is_pinned != TRUE ) && ( check[i].is_pinned != FALSE ) ) || - ( ( check[i].expected_loaded != TRUE ) && + ( ( check[i].expected_loaded != TRUE ) && ( check[i].expected_loaded != FALSE ) ) || - ( ( check[i].expected_cleared != TRUE ) && + ( ( check[i].expected_cleared != TRUE ) && ( check[i].expected_cleared != FALSE ) ) || - ( ( check[i].expected_flushed != TRUE ) && + ( ( check[i].expected_flushed != TRUE ) && ( check[i].expected_flushed != FALSE ) ) || - ( ( check[i].expected_destroyed != TRUE ) && + ( ( check[i].expected_destroyed != TRUE ) && ( check[i].expected_destroyed != FALSE ) ) ) { pass = FALSE; @@ -9338,7 +9338,7 @@ check_flush_cache__flush_op_test(H5C_t * cache_ptr, for ( j = 0; j < spec[i].num_flush_ops; j++ ) { - add_flush_op(spec[i].entry_type, + add_flush_op(spec[i].entry_type, spec[i].entry_index, spec[i].flush_ops[j].op_code, spec[i].flush_ops[j].type, @@ -9420,7 +9420,7 @@ check_flush_cache__flush_op_test(H5C_t * cache_ptr, i = 0; while ( ( pass ) && ( i < check_size ) ) { - if ( check[i].in_cache != entry_in_cache(cache_ptr, + if ( check[i].in_cache != entry_in_cache(cache_ptr, check[i].entry_type, check[i].entry_index) ) { @@ -9460,7 +9460,7 @@ check_flush_cache__flush_op_test(H5C_t * cache_ptr, if ( ( ! entry_ptr->header.destroy_in_progress ) && ( check[i].in_cache ) && ( entry_ptr->header.size != check[i].expected_size ) ) { - HDfprintf(stdout, + HDfprintf(stdout, "(!destroy in progress and in cache and size (expected) = %d (%d).\n", (int)(entry_ptr->header.size), (int)(check[i].expected_size)); @@ -9654,9 +9654,9 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) test_entry_t * base_addr; struct expected_entry_status expected[8 + 31 + 14] = { - /* the expected array is used to maintain a table of the expected status of every + /* the expected array is used to maintain a table of the expected status of every * entry used in this test. Note that since the function that processes this - * array only processes as much of it as it is told to, we don't have to + * array only processes as much of it as it is told to, we don't have to * worry about maintaining the status of entries that we haven't used yet. */ /* entry entry in at main */ @@ -9745,9 +9745,9 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) if ( pass ) { /* the basic idea in this test is to insert a bunch of entries - * with flush operations associated with them, and then load - * other entries into the cache until the cache is full. At - * that point, load yet more entries into the cache, and see + * with flush operations associated with them, and then load + * other entries into the cache until the cache is full. At + * that point, load yet more entries into the cache, and see * if the flush operations are performed as expected. * * To make things a bit more interesting, we also include a @@ -9765,43 +9765,43 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) */ protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 0); - unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 0, + unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 0, H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG, (VARIABLE_ENTRY_SIZE / 2)); protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 1); - unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 1, + unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 1, H5C__NO_FLAGS_SET, (size_t)0); protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 2); - unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 2, + unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 2, H5C__NO_FLAGS_SET, (size_t)0); protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 3); - unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 3, + unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 3, H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG, (VARIABLE_ENTRY_SIZE / 2)); protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 4); - unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 4, + unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 4, H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG, (VARIABLE_ENTRY_SIZE / 2)); protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 5); - unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 5, + unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 5, H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG, (VARIABLE_ENTRY_SIZE / 2)); protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 6); - unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 6, + unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 6, H5C__NO_FLAGS_SET, (size_t)0); protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 7); - unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 7, + unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 7, H5C__NO_FLAGS_SET, (size_t)0); if ( ( cache_ptr->index_len != 8 ) || - ( cache_ptr->index_size != (4 * (VARIABLE_ENTRY_SIZE / 2)) + + ( cache_ptr->index_size != (4 * (VARIABLE_ENTRY_SIZE / 2)) + (4 * VARIABLE_ENTRY_SIZE) ) ) { pass = FALSE; @@ -9811,7 +9811,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) if ( pass ) { - /* Now set up the pinning relationships: + /* Now set up the pinning relationships: * * Briefly, (VET, 0) is pinned by (VET, 1), (VET, 2), and (VET, 3) * (VET, 7) is pinned by (VET, 3), and (VET, 5) @@ -9841,39 +9841,39 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) * * (VET, 7) dirties (VET, 6) */ - add_flush_op(VARIABLE_ENTRY_TYPE, 1, FLUSH_OP__DIRTY, + add_flush_op(VARIABLE_ENTRY_TYPE, 1, FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 0, FALSE, (size_t)0); - add_flush_op(VARIABLE_ENTRY_TYPE, 1, FLUSH_OP__RESIZE, - VARIABLE_ENTRY_TYPE, 0, FALSE, + add_flush_op(VARIABLE_ENTRY_TYPE, 1, FLUSH_OP__RESIZE, + VARIABLE_ENTRY_TYPE, 0, FALSE, 3 * VARIABLE_ENTRY_SIZE / 4); - add_flush_op(VARIABLE_ENTRY_TYPE, 2, FLUSH_OP__DIRTY, + add_flush_op(VARIABLE_ENTRY_TYPE, 2, FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 0, FALSE, (size_t)0); - add_flush_op(VARIABLE_ENTRY_TYPE, 2, FLUSH_OP__RESIZE, + add_flush_op(VARIABLE_ENTRY_TYPE, 2, FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 0, FALSE, VARIABLE_ENTRY_SIZE); - add_flush_op(VARIABLE_ENTRY_TYPE, 2, FLUSH_OP__RENAME, + add_flush_op(VARIABLE_ENTRY_TYPE, 2, FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 0, FALSE, (size_t)0); - add_flush_op(VARIABLE_ENTRY_TYPE, 3, FLUSH_OP__DIRTY, + add_flush_op(VARIABLE_ENTRY_TYPE, 3, FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 0, FALSE, (size_t)0); - add_flush_op(VARIABLE_ENTRY_TYPE, 3, FLUSH_OP__RESIZE, + add_flush_op(VARIABLE_ENTRY_TYPE, 3, FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 3, FALSE, VARIABLE_ENTRY_SIZE); - add_flush_op(VARIABLE_ENTRY_TYPE, 7, FLUSH_OP__DIRTY, + add_flush_op(VARIABLE_ENTRY_TYPE, 7, FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 6, FALSE, (size_t)0); } if ( pass ) { - /* to summarize, at present the following variable size entries + /* to summarize, at present the following variable size entries * are in cache with the following characteristics: * * in * entry: cache? size: dirty? pinned? pins: flush operations: - * + * * (VET, 0) Y 5 KB Y Y - - * - * (VET, 1) Y 10 KB N N 0 dirty (VET, 0), + * (VET, 1) Y 10 KB N N 0 dirty (VET, 0), * resize (VET, 0) to 7.5 KB * * (VET, 2) Y 10 KB N N 0 dirty (VET, 0) @@ -9888,11 +9888,11 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) * (VET, 5) Y 5 KB Y N 7 - * * (VET, 6) Y 10 KB N N - - - * + * * (VET, 7) Y 10 KB N Y - dirty (VET, 6) * - * Recall that in this test bed, flush operations are excuted the - * first time the associated entry is flushed, and are then + * Recall that in this test bed, flush operations are excuted the + * first time the associated entry is flushed, and are then * deleted. */ @@ -9900,14 +9900,14 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) for ( i = 0; i < 31; i++ ) { protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i); - unprotect_entry_with_size_change(cache_ptr, MONSTER_ENTRY_TYPE, i, + unprotect_entry_with_size_change(cache_ptr, MONSTER_ENTRY_TYPE, i, H5C__DIRTIED_FLAG, (size_t)0); } for ( i = 0; i < 1; i++ ) { protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i); - unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i, + unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i, H5C__DIRTIED_FLAG, (size_t)0); } @@ -9926,9 +9926,9 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) /* verify the expected status of all entries we have loaded to date: */ num_large_entries = 1; - verify_entry_status(cache_ptr, + verify_entry_status(cache_ptr, 0, - (num_variable_entries + num_monster_entries + num_large_entries), + (num_variable_entries + num_monster_entries + num_large_entries), expected); } } @@ -9936,8 +9936,8 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) if ( pass ) { - /* Now load a large entry. This should result in the eviction - * of (VET,1), and the increase in the size of (VET, 0) from .5 + /* Now load a large entry. This should result in the eviction + * of (VET,1), and the increase in the size of (VET, 0) from .5 * VARIABLE_ENTRY_SIZE to .75 VARIABLE_ENTRY_SIZE. * * The following table illustrates the intended state of affairs @@ -9945,7 +9945,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) * * in * entry: cache? size: dirty? pinned? pins: flush operations: - * + * * (VET, 0) Y 7.5 KB Y Y - - * * (VET, 1) N 10 KB N N - - @@ -9962,7 +9962,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) * (VET, 5) Y 5 KB Y N 7 - * * (VET, 6) Y 10 KB N N - - - * + * * (VET, 7) Y 10 KB Y Y - dirty (VET, 6) * * Start by updating the expected table for the expected changes in entry status: @@ -9975,7 +9975,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) num_large_entries = 2; protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 1); - unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, 1, + unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, 1, H5C__DIRTIED_FLAG, (size_t)0); if ( ( cache_ptr->index_len != 40 ) || @@ -9994,25 +9994,25 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) } /* verify entry status */ - verify_entry_status(cache_ptr, + verify_entry_status(cache_ptr, 1, - (num_variable_entries + num_monster_entries + num_large_entries), + (num_variable_entries + num_monster_entries + num_large_entries), expected); } if ( pass ) { - /* Now load another large entry. This should result in the eviction + /* Now load another large entry. This should result in the eviction * of (VET, 2), the increase in the size of (VET, 0) from .75 * VARIABLE_ENTRY_SIZE to 1.0 VARIABLE_ENTRY_SIZE, and the renaming * of (VET, 0) to its alternate address. * - * The following table shows the expected states of the variable + * The following table shows the expected states of the variable * size entries after the test. * * in * entry: cache? size: dirty? pinned? pins: flush operations: - * + * * (VET, 0) Y 10 KB Y Y - - * * (VET, 1) N 10 KB N N - - @@ -10027,7 +10027,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) * (VET, 5) Y 5 KB Y N 7 - * * (VET, 6) Y 10 KB N N - - - * + * * (VET, 7) Y 10 KB Y Y - dirty (VET, 6) * * Start by updating the expected table for the expected changes in entry status: @@ -10041,7 +10041,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) num_large_entries = 3; protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 2); - unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, 2, + unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, 2, H5C__DIRTIED_FLAG, (size_t)0); if ( ( cache_ptr->index_len != 40 ) || @@ -10051,7 +10051,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) (2 * LARGE_ENTRY_SIZE) ) || ( cache_ptr->index_size != ((3 * VARIABLE_ENTRY_SIZE / 2) + (3 * VARIABLE_ENTRY_SIZE) + - (31 * MONSTER_ENTRY_SIZE) + + (31 * MONSTER_ENTRY_SIZE) + (3 * LARGE_ENTRY_SIZE)) ) ) { pass = FALSE; @@ -10059,9 +10059,9 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) } /* verify entry status */ - verify_entry_status(cache_ptr, + verify_entry_status(cache_ptr, 2, - (num_variable_entries + num_monster_entries + num_large_entries), + (num_variable_entries + num_monster_entries + num_large_entries), expected); } @@ -10071,16 +10071,16 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) * flushed, and increasing its size from 1/2 VARIABLE_ENTRY_SIZE to * VARIABLE_ENTRY_SIZE. * - * As a result of this size increase, the cache will have to look + * As a result of this size increase, the cache will have to look * for another entry to evict. After flushing (VET, 4) and (VET, 5), * it should evict (VET, 6), yielding the needed memory. * - * The following table shows the expected states of the variable + * The following table shows the expected states of the variable * size entries after the test. * * in * entry: cache? size: dirty? pinned? pins: flush operations: - * + * * (VET, 0) Y 10 KB Y Y - - * * (VET, 1) N 10 KB N N - - @@ -10094,7 +10094,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) * (VET, 5) Y 5 KB N N 7 - * * (VET, 6) N 10 KB N N - - - * + * * (VET, 7) Y 10 KB Y Y - dirty (VET, 6) * * Start by updating the expected table for the expected changes in entry status: @@ -10114,11 +10114,11 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) num_large_entries = 5; protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 3); - unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, 3, + unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, 3, H5C__DIRTIED_FLAG, (size_t)0); protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 4); - unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, 4, + unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, 4, H5C__DIRTIED_FLAG, (size_t)0); /* verify cache size */ @@ -10137,16 +10137,16 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) } /* verify entry status */ - verify_entry_status(cache_ptr, + verify_entry_status(cache_ptr, 3, - (num_variable_entries + num_monster_entries + num_large_entries), + (num_variable_entries + num_monster_entries + num_large_entries), expected); } if ( pass ) { /* now touch all the non VARIABLE_ENTRY_TYPE entries in the - * cache to bring all the VARIABLE_ENTRY_TYPE entries to the + * cache to bring all the VARIABLE_ENTRY_TYPE entries to the * end of the LRU list. * * Note that we don't have to worry about (VET, 0) and (VET, 7) @@ -10155,14 +10155,14 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) for ( i = 0; i < 31; i++ ) { protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i); - unprotect_entry_with_size_change(cache_ptr, MONSTER_ENTRY_TYPE, i, + unprotect_entry_with_size_change(cache_ptr, MONSTER_ENTRY_TYPE, i, H5C__DIRTIED_FLAG, (size_t)0); } for ( i = 0; i < 5; i++ ) { protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i); - unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i, + unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i, H5C__DIRTIED_FLAG, (size_t)0); } @@ -10177,9 +10177,9 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) } /* verify entry status */ - verify_entry_status(cache_ptr, + verify_entry_status(cache_ptr, 4, - (num_variable_entries + num_monster_entries + num_large_entries), + (num_variable_entries + num_monster_entries + num_large_entries), expected); } @@ -10188,12 +10188,12 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) /* Now load three more large entries. This should result * in the eviction of (VET, 3), and the unpinning of (VET, 0) * - * The following table shows the expected states of the variable + * The following table shows the expected states of the variable * size entries after the test. * * in * entry: cache? size: dirty? pinned? pins: flush operations: - * + * * (VET, 0) Y 10 KB Y N - - * * (VET, 1) N 10 KB N N - - @@ -10207,7 +10207,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) * (VET, 5) Y 5 KB N N 7 - * * (VET, 6) N 10 KB N N - - - * + * * (VET, 7) Y 10 KB Y Y - dirty (VET, 6) * * Start by updating the expected table for the expected changes in entry status: @@ -10222,7 +10222,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) for ( i = 5; i < 8; i++ ) { protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i); - unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i, + unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i, H5C__DIRTIED_FLAG, (size_t)0); } @@ -10241,9 +10241,9 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) } /* verify entry status */ - verify_entry_status(cache_ptr, + verify_entry_status(cache_ptr, 5, - (num_variable_entries + num_monster_entries + num_large_entries), + (num_variable_entries + num_monster_entries + num_large_entries), expected); } @@ -10251,12 +10251,12 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) /* load another large entry. (VET, 4) should be evicted. * - * The following table shows the expected states of the variable + * The following table shows the expected states of the variable * size entries after the test. * * in * entry: cache? size: dirty? pinned? pins: flush operations: - * + * * (VET, 0) Y 10 KB Y N - - * * (VET, 1) N 10 KB N N - - @@ -10270,7 +10270,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) * (VET, 5) Y 5 KB N N 7 - * * (VET, 6) N 10 KB N N - - - * + * * (VET, 7) Y 10 KB Y Y - dirty (VET, 6) * * Start by updating the expected table for the expected changes in entry status: @@ -10284,7 +10284,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) for ( i = 8; i < 9; i++ ) { protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i); - unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i, + unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i, H5C__DIRTIED_FLAG, (size_t)0); } @@ -10304,24 +10304,24 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) } /* verify entry status */ - verify_entry_status(cache_ptr, + verify_entry_status(cache_ptr, 6, - (num_variable_entries + num_monster_entries + num_large_entries), + (num_variable_entries + num_monster_entries + num_large_entries), expected); } if ( pass ) { - /* Load another large entry. + /* Load another large entry. * - * (VET, 5) should be evicted, and (VET, 7) should be unpinned. + * (VET, 5) should be evicted, and (VET, 7) should be unpinned. * - * The following table shows the expected states of the variable + * The following table shows the expected states of the variable * size entries after the test. * * in * entry: cache? size: dirty? pinned? pins: flush operations: - * + * * (VET, 0) Y 10 KB Y N - - * * (VET, 1) N 10 KB N N - - @@ -10335,7 +10335,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) * (VET, 5) N 5 KB N N - - * * (VET, 6) N 10 KB N N - - - * + * * (VET, 7) Y 10 KB Y N - dirty (VET, 6) * * Start by updating the expected table for the expected changes in entry status: @@ -10350,7 +10350,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) for ( i = 9; i < 10; i++ ) { protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i); - unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i, + unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i, H5C__DIRTIED_FLAG, (size_t)0); } @@ -10368,16 +10368,16 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) } /* verify entry status */ - verify_entry_status(cache_ptr, + verify_entry_status(cache_ptr, 7, - (num_variable_entries + num_monster_entries + num_large_entries), + (num_variable_entries + num_monster_entries + num_large_entries), expected); } if ( pass ) { /* Again, touch all the non VARIABLE_ENTRY_TYPE entries in the - * cache to bring all the VARIABLE_ENTRY_TYPE entries to the + * cache to bring all the VARIABLE_ENTRY_TYPE entries to the * end of the LRU list. * * Both (VET, 0) and (VET, 7) have been unpinned, so they are @@ -10386,14 +10386,14 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) for ( i = 0; i < 31; i++ ) { protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i); - unprotect_entry_with_size_change(cache_ptr, MONSTER_ENTRY_TYPE, i, + unprotect_entry_with_size_change(cache_ptr, MONSTER_ENTRY_TYPE, i, H5C__DIRTIED_FLAG, (size_t)0); } for ( i = 0; i < 10; i++ ) { protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i); - unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i, + unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i, H5C__DIRTIED_FLAG, (size_t)0); } @@ -10411,35 +10411,35 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) } /* verify entry status */ - verify_entry_status(cache_ptr, + verify_entry_status(cache_ptr, 8, - (num_variable_entries + num_monster_entries + num_large_entries), + (num_variable_entries + num_monster_entries + num_large_entries), expected); } if ( pass ) { - /* load two more large entries. + /* load two more large entries. * * (VET, 0) should be flushed, but not evicted initially since it is dirty. * - * (VET, 7) should be evicted, but (VET, 7) has an eviction operation that - * dirties (VET, 6). Since (VET, 6) is not in the cache, it will be loaded. + * (VET, 7) should be evicted, but (VET, 7) has an eviction operation that + * dirties (VET, 6). Since (VET, 6) is not in the cache, it will be loaded. * Since this results in no net increase in free space, the cache will * continue to attempt to create free space. * * The cache will then flush all the monster and large entries, but since they - * are all dirty, they will not be evicted. + * are all dirty, they will not be evicted. * * Finally, it will reach (VET, 0) again, and evict it on the second pass. * This finally makes the necessary space. * - * The following table shows the expected states of the variable + * The following table shows the expected states of the variable * size entries after the test. * * in * entry: cache? size: dirty? pinned? pins: flush operations: - * + * * (VET, 0) N 10 KB N N - - * * (VET, 1) N 10 KB N N - - @@ -10453,12 +10453,12 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) * (VET, 5) N 5 KB N N - - * * (VET, 6) Y 10 KB Y N - - - * + * * (VET, 7) N 10 KB N N - - * * Start by updating the expected table for the expected changes in entry status: * - * Note that we reset the loaded, cleared, flushed, and destroyed fields of + * Note that we reset the loaded, cleared, flushed, and destroyed fields of * (VET,6) so we can track what is happening. */ base_addr = entries[VARIABLE_ENTRY_TYPE]; @@ -10486,7 +10486,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) /* a newly loaded entry is not inserted in the cache until after space has been * made for it. Thus (LET, 11) will not be flushed. */ - for ( i = num_variable_entries; + for ( i = num_variable_entries; i < num_variable_entries + num_monster_entries + num_large_entries - 1; i++ ) { @@ -10497,7 +10497,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) for ( i = 10; i < 12; i++ ) { protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i); - unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i, + unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i, H5C__DIRTIED_FLAG, (size_t)0); } @@ -10515,34 +10515,34 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) } /* verify entry status */ - verify_entry_status(cache_ptr, + verify_entry_status(cache_ptr, 9, - (num_variable_entries + num_monster_entries + num_large_entries), + (num_variable_entries + num_monster_entries + num_large_entries), expected); } if ( pass ) { /* Again, touch all the non VARIABLE_ENTRY_TYPE entries in the - * cache to bring the last remaining VARIABLE_ENTRY_TYPE entry to the - * end of the LRU list. + * cache to bring the last remaining VARIABLE_ENTRY_TYPE entry to the + * end of the LRU list. */ for ( i = 0; i < num_monster_entries; i++ ) { protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i); - unprotect_entry_with_size_change(cache_ptr, MONSTER_ENTRY_TYPE, i, + unprotect_entry_with_size_change(cache_ptr, MONSTER_ENTRY_TYPE, i, H5C__DIRTIED_FLAG, (size_t)0); } for ( i = 0; i < num_large_entries; i++ ) { protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i); - unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i, + unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i, H5C__DIRTIED_FLAG, (size_t)0); } /* update the expected array to mark all these entries dirty again. */ - for ( i = num_variable_entries; + for ( i = num_variable_entries; i < num_variable_entries + num_monster_entries + num_large_entries - 1; i++ ) { @@ -10563,27 +10563,27 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) } /* verify entry status */ - verify_entry_status(cache_ptr, + verify_entry_status(cache_ptr, 10, - (num_variable_entries + num_monster_entries + num_large_entries), + (num_variable_entries + num_monster_entries + num_large_entries), expected); } if ( pass ) { - - /* Load two more large entries. + + /* Load two more large entries. * * Since (VET, 6) is dirty, at first this will just cause (VET, 6) to be flushed. * * But all other entries in the cache are dirty, so the cache will flush them all, * and then evict (VET, 6) on the second pass. * - * The following table shows the expected states of the variable + * The following table shows the expected states of the variable * size entries after the test. * * in * entry: cache? size: dirty? pinned? pins: flush operations: - * + * * (VET, 0) N 10 KB N N - - * * (VET, 1) N 10 KB N N - - @@ -10597,7 +10597,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) * (VET, 5) N 5 KB N N - - * * (VET, 6) N 10 KB N N - - - * + * * (VET, 7) N 10 KB N N - - * * Start by updating the expected table for the expected changes in entry status: @@ -10613,7 +10613,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) /* a newly loaded entry is not inserted in the cache until after space has been * made for it. Thus (LET, 13) will not be flushed. */ - for ( i = num_variable_entries; + for ( i = num_variable_entries; i < num_variable_entries + num_monster_entries + num_large_entries - 1; i++ ) { @@ -10624,7 +10624,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) for ( i = 12; i < 14; i++ ) { protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i); - unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i, + unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i, H5C__DIRTIED_FLAG, (size_t)0); } @@ -10641,9 +10641,9 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) } /* verify entry status */ - verify_entry_status(cache_ptr, + verify_entry_status(cache_ptr, 11, - (num_variable_entries + num_monster_entries + num_large_entries), + (num_variable_entries + num_monster_entries + num_large_entries), expected); } @@ -10671,12 +10671,12 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr) } } -#if H5C_COLLECT_CACHE_STATS +#if H5C_COLLECT_CACHE_STATS /* If we are collecting stats, check to see if we get the expected * values. * * Testing the stats code is fairly new, but given the extent - * to which I find myself depending on the stats, I've decided + * to which I find myself depending on the stats, I've decided * to start testing the stats whenever it is convenient to do * so. */ @@ -12544,7 +12544,7 @@ check_flush_cache__single_entry_test(H5C_t * cache_ptr, (int)expected_flushed, (int)(entry_ptr->destroyed), (int)expected_destroyed); -#endif +#endif pass = FALSE; HDsnprintf(msg, (size_t)128, "Unexpected entry status after flush in single entry test #%d.", @@ -13084,7 +13084,7 @@ check_expunge_entry(void) */ result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size, - &in_cache, &is_dirty, &is_protected, + &in_cache, &is_dirty, &is_protected, &is_pinned); if ( result < 0 ) { @@ -13151,14 +13151,14 @@ check_expunge_entry(void) } /* Expunge the entry and then verify that it is no longer in the cache. - * Also verify that the entry was loaded, cleared, and destroyed, but + * Also verify that the entry was loaded, cleared, and destroyed, but * not flushed. */ expunge_entry(cache_ptr, 0, 0); if ( pass ) { - /* entry shouldn't be in cache -- only in_cache should be touched + /* entry shouldn't be in cache -- only in_cache should be touched * by the status call. Thus, only check that boolean. */ @@ -13193,7 +13193,7 @@ check_expunge_entry(void) /* now repeat the process with a different entry. On unprotect * mark the entry as dirty. Verify that it is not flushed. */ - + base_addr = entries[0]; entry_ptr = &(base_addr[1]); @@ -13204,7 +13204,7 @@ check_expunge_entry(void) */ result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size, - &in_cache, &is_dirty, &is_protected, + &in_cache, &is_dirty, &is_protected, &is_pinned); if ( result < 0 ) { @@ -13243,7 +13243,7 @@ check_expunge_entry(void) if ( pass ) { result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size, - &in_cache, &is_dirty, &is_protected, + &in_cache, &is_dirty, &is_protected, &is_pinned); if ( result < 0 ) { @@ -13279,12 +13279,12 @@ check_expunge_entry(void) if ( pass ) { - /* entry shouldn't be in cache -- only in_cache should be touched + /* entry shouldn't be in cache -- only in_cache should be touched * by the status call. Thus, only check that boolean. */ result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size, - &in_cache, &is_dirty, &is_protected, + &in_cache, &is_dirty, &is_protected, &is_pinned); if ( result < 0 ) { @@ -13333,7 +13333,7 @@ check_expunge_entry(void) /*------------------------------------------------------------------------- * Function: check_multiple_read_protect() * - * Purpose: Verify that multiple, simultaneous read protects of a + * Purpose: Verify that multiple, simultaneous read protects of a * single entry perform as expectd. * * Return: void @@ -13390,7 +13390,7 @@ check_multiple_read_protect(void) entry_ptr = &((entries[0])[0]); - if ( ( entry_ptr->header.is_protected ) || + if ( ( entry_ptr->header.is_protected ) || ( entry_ptr->header.is_read_only ) || ( entry_ptr->header.ro_ref_count != 0 ) ) { @@ -13413,7 +13413,7 @@ check_multiple_read_protect(void) { protect_entry_ro(cache_ptr, 0, 0); - if ( ( ! ( entry_ptr->header.is_protected ) ) || + if ( ( ! ( entry_ptr->header.is_protected ) ) || ( ! ( entry_ptr->header.is_read_only ) ) || ( entry_ptr->header.ro_ref_count != 1 ) ) { @@ -13436,7 +13436,7 @@ check_multiple_read_protect(void) { protect_entry_ro(cache_ptr, 0, 0); - if ( ( ! ( entry_ptr->header.is_protected ) ) || + if ( ( ! ( entry_ptr->header.is_protected ) ) || ( ! ( entry_ptr->header.is_read_only ) ) || ( entry_ptr->header.ro_ref_count != 2 ) ) { @@ -13459,7 +13459,7 @@ check_multiple_read_protect(void) { unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__NO_FLAGS_SET); - if ( ( ! ( entry_ptr->header.is_protected ) ) || + if ( ( ! ( entry_ptr->header.is_protected ) ) || ( ! ( entry_ptr->header.is_read_only ) ) || ( entry_ptr->header.ro_ref_count != 1 ) ) { @@ -13482,7 +13482,7 @@ check_multiple_read_protect(void) { protect_entry_ro(cache_ptr, 0, 0); - if ( ( ! ( entry_ptr->header.is_protected ) ) || + if ( ( ! ( entry_ptr->header.is_protected ) ) || ( ! ( entry_ptr->header.is_read_only ) ) || ( entry_ptr->header.ro_ref_count != 2 ) ) { @@ -13505,7 +13505,7 @@ check_multiple_read_protect(void) { protect_entry_ro(cache_ptr, 0, 0); - if ( ( ! ( entry_ptr->header.is_protected ) ) || + if ( ( ! ( entry_ptr->header.is_protected ) ) || ( ! ( entry_ptr->header.is_read_only ) ) || ( entry_ptr->header.ro_ref_count != 3 ) ) { @@ -13528,7 +13528,7 @@ check_multiple_read_protect(void) { unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__NO_FLAGS_SET); - if ( ( ! ( entry_ptr->header.is_protected ) ) || + if ( ( ! ( entry_ptr->header.is_protected ) ) || ( ! ( entry_ptr->header.is_read_only ) ) || ( entry_ptr->header.ro_ref_count != 2 ) ) { @@ -13551,7 +13551,7 @@ check_multiple_read_protect(void) { unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__NO_FLAGS_SET); - if ( ( ! ( entry_ptr->header.is_protected ) ) || + if ( ( ! ( entry_ptr->header.is_protected ) ) || ( ! ( entry_ptr->header.is_read_only ) ) || ( entry_ptr->header.ro_ref_count != 1 ) ) { @@ -13574,7 +13574,7 @@ check_multiple_read_protect(void) { unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__NO_FLAGS_SET); - if ( ( entry_ptr->header.is_protected ) || + if ( ( entry_ptr->header.is_protected ) || ( entry_ptr->header.is_read_only ) || ( entry_ptr->header.ro_ref_count != 0 ) ) { @@ -13594,7 +13594,7 @@ check_multiple_read_protect(void) #endif /* H5C_COLLECT_CACHE_STATS */ - /* If we get this far, do a write protect and unprotect to verify + /* If we get this far, do a write protect and unprotect to verify * that the stats are getting collected properly here as well. */ @@ -13602,7 +13602,7 @@ check_multiple_read_protect(void) { protect_entry(cache_ptr, 0, 0); - if ( ( ! ( entry_ptr->header.is_protected ) ) || + if ( ( ! ( entry_ptr->header.is_protected ) ) || ( entry_ptr->header.is_read_only ) || ( entry_ptr->header.ro_ref_count != 0 ) ) { @@ -13625,7 +13625,7 @@ check_multiple_read_protect(void) { unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__NO_FLAGS_SET); - if ( ( entry_ptr->header.is_protected ) || + if ( ( entry_ptr->header.is_protected ) || ( entry_ptr->header.is_read_only ) || ( entry_ptr->header.ro_ref_count != 0 ) ) { @@ -13645,7 +13645,7 @@ check_multiple_read_protect(void) #endif /* H5C_COLLECT_CACHE_STATS */ - /* Finally, mix things up a little, using a mix of reads and + /* Finally, mix things up a little, using a mix of reads and * and writes on different entries. Also include a pin to verify * that it works as well. * @@ -14142,7 +14142,7 @@ check_resize_entry(void) /* Setup a cache and verify that it is empty. * - * Then force the load of an entry by protecting it, and verify that + * Then force the load of an entry by protecting it, and verify that * the entry and cache have the expected sizes. * * Then unprotect the entry with the size changed flag and a reduced @@ -14150,10 +14150,10 @@ check_resize_entry(void) * sizes. * * Use a second protect/unprotect cycle to restore the entry to - * its original size. Verify that the entry and cache have the + * its original size. Verify that the entry and cache have the * expected sizes. * - * Protect and unprotect the entry again to pin it. Use + * Protect and unprotect the entry again to pin it. Use * H5C_resize_entry to reduce its size. Verify that the entry * and cache have the expected sizes. * @@ -14165,7 +14165,7 @@ check_resize_entry(void) * * * Obesrve that all the above tests have been done with only one - * entry in the cache. Repeat the tests with several entries in + * entry in the cache. Repeat the tests with several entries in * the cache. */ @@ -14218,8 +14218,8 @@ check_resize_entry(void) if ( pass ) { - result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, - &reported_entry_size, &in_cache, + result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, + &reported_entry_size, &in_cache, &is_dirty, &is_protected, &is_pinned); if ( result < 0 ) { @@ -14249,9 +14249,9 @@ check_resize_entry(void) if ( pass ) { - result = H5C_unprotect(NULL, -1, -1, cache_ptr, + result = H5C_unprotect(NULL, -1, -1, cache_ptr, &(types[LARGE_ENTRY_TYPE]), entry_ptr->addr, - (void *)entry_ptr, + (void *)entry_ptr, H5C__SIZE_CHANGED_FLAG | H5C__DIRTIED_FLAG, (LARGE_ENTRY_SIZE / 2)); @@ -14288,8 +14288,8 @@ check_resize_entry(void) if ( pass ) { - result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, - &reported_entry_size, &in_cache, + result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, + &reported_entry_size, &in_cache, &is_dirty, &is_protected, &is_pinned); if ( result < 0 ) { @@ -14322,9 +14322,9 @@ check_resize_entry(void) if ( pass ) { - result = H5C_unprotect(NULL, -1, -1, cache_ptr, + result = H5C_unprotect(NULL, -1, -1, cache_ptr, &(types[LARGE_ENTRY_TYPE]), entry_ptr->addr, - (void *)entry_ptr, + (void *)entry_ptr, (H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG), LARGE_ENTRY_SIZE); @@ -14361,8 +14361,8 @@ check_resize_entry(void) if ( pass ) { - result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, - &reported_entry_size, &in_cache, + result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, + &reported_entry_size, &in_cache, &is_dirty, &is_protected, &is_pinned); if ( result < 0 ) { @@ -14397,17 +14397,17 @@ check_resize_entry(void) if ( pass ) { - result = H5C_resize_pinned_entry(cache_ptr, (void *)entry_ptr, + result = H5C_resize_pinned_entry(cache_ptr, (void *)entry_ptr, (LARGE_ENTRY_SIZE / 4)); if ( result < 0 ) { pass = FALSE; - HDsnprintf(msg, (size_t)128, + HDsnprintf(msg, (size_t)128, "H5C_resize_pinned_entry() reports failure 1."); failure_mssg = msg; - } + } } if ( pass ) { @@ -14426,8 +14426,8 @@ check_resize_entry(void) if ( pass ) { - result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, - &reported_entry_size, &in_cache, + result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, + &reported_entry_size, &in_cache, &is_dirty, &is_protected, &is_pinned); if ( result < 0 ) { @@ -14458,17 +14458,17 @@ check_resize_entry(void) if ( pass ) { - result = H5C_resize_pinned_entry(cache_ptr, (void *)entry_ptr, + result = H5C_resize_pinned_entry(cache_ptr, (void *)entry_ptr, LARGE_ENTRY_SIZE); if ( result < 0 ) { pass = FALSE; - HDsnprintf(msg, (size_t)128, + HDsnprintf(msg, (size_t)128, "H5C_resize_pinned_entry() reports failure 2."); failure_mssg = msg; - } + } } if ( pass ) { @@ -14487,8 +14487,8 @@ check_resize_entry(void) if ( pass ) { - result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, - &reported_entry_size, &in_cache, + result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, + &reported_entry_size, &in_cache, &is_dirty, &is_protected, &is_pinned); if ( result < 0 ) { @@ -14519,13 +14519,13 @@ check_resize_entry(void) protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0); - unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0, FALSE, + unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0, FALSE, H5C__UNPIN_ENTRY_FLAG | H5C__DELETED_FLAG); if ( pass ) { result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size, - &in_cache, &is_dirty, &is_protected, + &in_cache, &is_dirty, &is_protected, &is_pinned); if ( result < 0 ) { @@ -14630,8 +14630,8 @@ check_resize_entry(void) if ( pass ) { - result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, - &reported_entry_size, &in_cache, + result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, + &reported_entry_size, &in_cache, &is_dirty, &is_protected, &is_pinned); if ( result < 0 ) { @@ -14661,9 +14661,9 @@ check_resize_entry(void) if ( pass ) { - result = H5C_unprotect(NULL, -1, -1, cache_ptr, + result = H5C_unprotect(NULL, -1, -1, cache_ptr, &(types[LARGE_ENTRY_TYPE]), entry_ptr->addr, - (void *)entry_ptr, + (void *)entry_ptr, H5C__SIZE_CHANGED_FLAG | H5C__DIRTIED_FLAG, (LARGE_ENTRY_SIZE / 2)); @@ -14687,10 +14687,10 @@ check_resize_entry(void) if ( pass ) { if ( ( cache_ptr->index_len != 4 ) || - ( cache_ptr->index_size != + ( cache_ptr->index_size != ((3 * LARGE_ENTRY_SIZE) + (LARGE_ENTRY_SIZE / 2)) ) || ( cache_ptr->slist_len != 2 ) || - ( cache_ptr->slist_size != + ( cache_ptr->slist_size != (LARGE_ENTRY_SIZE + (LARGE_ENTRY_SIZE / 2)) ) ) { pass = FALSE; @@ -14702,8 +14702,8 @@ check_resize_entry(void) if ( pass ) { - result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, - &reported_entry_size, &in_cache, + result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, + &reported_entry_size, &in_cache, &is_dirty, &is_protected, &is_pinned); if ( result < 0 ) { @@ -14736,9 +14736,9 @@ check_resize_entry(void) if ( pass ) { - result = H5C_unprotect(NULL, -1, -1, cache_ptr, + result = H5C_unprotect(NULL, -1, -1, cache_ptr, &(types[LARGE_ENTRY_TYPE]), entry_ptr->addr, - (void *)entry_ptr, + (void *)entry_ptr, (H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG), LARGE_ENTRY_SIZE); @@ -14775,8 +14775,8 @@ check_resize_entry(void) if ( pass ) { - result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, - &reported_entry_size, &in_cache, + result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, + &reported_entry_size, &in_cache, &is_dirty, &is_protected, &is_pinned); if ( result < 0 ) { @@ -14811,26 +14811,26 @@ check_resize_entry(void) if ( pass ) { - result = H5C_resize_pinned_entry(cache_ptr, (void *)entry_ptr, + result = H5C_resize_pinned_entry(cache_ptr, (void *)entry_ptr, (LARGE_ENTRY_SIZE / 4)); if ( result < 0 ) { pass = FALSE; - HDsnprintf(msg, (size_t)128, + HDsnprintf(msg, (size_t)128, "H5C_resize_pinned_entry() reports failure 3."); failure_mssg = msg; - } + } } if ( pass ) { if ( ( cache_ptr->index_len != 4 ) || - ( cache_ptr->index_size != + ( cache_ptr->index_size != ((3 * LARGE_ENTRY_SIZE) + (LARGE_ENTRY_SIZE / 4)) ) || ( cache_ptr->slist_len != 2 ) || - ( cache_ptr->slist_size != + ( cache_ptr->slist_size != (LARGE_ENTRY_SIZE + (LARGE_ENTRY_SIZE / 4)) ) ) { pass = FALSE; @@ -14842,8 +14842,8 @@ check_resize_entry(void) if ( pass ) { - result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, - &reported_entry_size, &in_cache, + result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, + &reported_entry_size, &in_cache, &is_dirty, &is_protected, &is_pinned); if ( result < 0 ) { @@ -14874,17 +14874,17 @@ check_resize_entry(void) if ( pass ) { - result = H5C_resize_pinned_entry(cache_ptr, (void *)entry_ptr, + result = H5C_resize_pinned_entry(cache_ptr, (void *)entry_ptr, LARGE_ENTRY_SIZE); if ( result < 0 ) { pass = FALSE; - HDsnprintf(msg, (size_t)128, + HDsnprintf(msg, (size_t)128, "H5C_resize_pinned_entry() reports failure 4."); failure_mssg = msg; - } + } } if ( pass ) { @@ -14903,8 +14903,8 @@ check_resize_entry(void) if ( pass ) { - result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, - &reported_entry_size, &in_cache, + result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, + &reported_entry_size, &in_cache, &is_dirty, &is_protected, &is_pinned); if ( result < 0 ) { @@ -14935,13 +14935,13 @@ check_resize_entry(void) protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 3); - unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 3, FALSE, + unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 3, FALSE, H5C__UNPIN_ENTRY_FLAG | H5C__DELETED_FLAG); if ( pass ) { result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size, - &in_cache, &is_dirty, &is_protected, + &in_cache, &is_dirty, &is_protected, &is_pinned); if ( result < 0 ) { @@ -15028,7 +15028,7 @@ check_resize_entry(void) /*------------------------------------------------------------------------- * Function: check_evictions_enabled() * - * Purpose: Verify that H5C_get_evictions_enabled() and + * Purpose: Verify that H5C_get_evictions_enabled() and * H5C_set_evictions_enabled() functions perform as expected. * * Return: void @@ -15077,7 +15077,7 @@ check_evictions_enabled(void) * Load another entry -- verify that this does not cause an entry * to be evicted. * - * Insert an entry -- verify that this does not cause an entry to + * Insert an entry -- verify that this does not cause an entry to * be evicted. * * Use H5C_set_evictions_enabled() to re-enable evictions. Verify @@ -15090,7 +15090,7 @@ check_evictions_enabled(void) * Protect an entry not in the cache. Verify that this causes * two evictions. * - * Used H5C_set_evictions_enabled() to disable evictions again. + * Used H5C_set_evictions_enabled() to disable evictions again. * Verify with a call to H5C_get_evictions_enabled(). * * Now flush and discard the cache -- should succeed. @@ -15159,7 +15159,7 @@ check_evictions_enabled(void) for ( i = 0; i < 16 ; i++ ) { protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i); - unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i, + unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i, FALSE, H5C__NO_FLAGS_SET); } @@ -15190,7 +15190,7 @@ check_evictions_enabled(void) /* protect and unprotect another entry */ protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 16); - unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 16, + unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 16, FALSE, H5C__NO_FLAGS_SET); if ( show_progress ) /* 7 */ @@ -15221,7 +15221,7 @@ check_evictions_enabled(void) entry_ptr = &(base_addr[0]); - result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, + result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, NULL, &in_cache, NULL, NULL, NULL); if ( result < 0 ) { @@ -15284,7 +15284,7 @@ check_evictions_enabled(void) entry_ptr = &(base_addr[1]); - result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, + result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, NULL, &in_cache, NULL, NULL, NULL); if ( result < 0 ) { @@ -15355,7 +15355,7 @@ check_evictions_enabled(void) /* protect and unprotect another entry */ protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 18); - unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 18, + unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 18, FALSE, H5C__NO_FLAGS_SET); if ( show_progress ) /* 15 */ @@ -15428,7 +15428,7 @@ check_evictions_enabled(void) /* protect and unprotect an entry that is in the cache */ protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 19); - unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 19, + unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 19, FALSE, H5C__NO_FLAGS_SET); if ( show_progress ) /* 20 */ @@ -15457,14 +15457,14 @@ check_evictions_enabled(void) /* protect and unprotect an entry that isn't in the cache */ protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 20); - unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 20, + unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 20, FALSE, H5C__NO_FLAGS_SET); if ( show_progress ) /* 22 */ HDfprintf(stdout, "%s() - %0d -- pass = %d\n", fcn_name, mile_stone++, (int)pass); - /* verify that the entries have been evicted to bring the + /* verify that the entries have been evicted to bring the * cache back down to its normal size. */ @@ -15491,7 +15491,7 @@ check_evictions_enabled(void) entry_ptr = &(base_addr[2]); - result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, + result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, NULL, &in_cache, NULL, NULL, NULL); if ( result < 0 ) { @@ -15527,7 +15527,7 @@ check_evictions_enabled(void) entry_ptr = &(base_addr[3]); - result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, + result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, NULL, &in_cache, NULL, NULL, NULL); if ( result < 0 ) { @@ -15576,11 +15576,11 @@ check_evictions_enabled(void) HDfprintf(stdout, "%s() - %0d -- pass = %d\n", fcn_name, mile_stone++, (int)pass); - /* protect and unprotect an entry that isn't in the cache, forcing + /* protect and unprotect an entry that isn't in the cache, forcing * the cache to grow. */ protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 21); - unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 21, + unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 21, FALSE, H5C__NO_FLAGS_SET); @@ -15656,7 +15656,7 @@ check_evictions_enabled(void) entry_ptr = &(base_addr[4]); - result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, + result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, NULL, &in_cache, NULL, NULL, NULL); if ( result < 0 ) { @@ -16777,7 +16777,7 @@ check_expunge_entry_errs(void) if ( pass ) { - result = H5C_expunge_entry(NULL, -1, -1, cache_ptr, + result = H5C_expunge_entry(NULL, -1, -1, cache_ptr, &(types[0]), entry_ptr->addr); if ( result > 0 ) { @@ -16795,7 +16795,7 @@ check_expunge_entry_errs(void) if ( pass ) { - result = H5C_expunge_entry(NULL, -1, -1, cache_ptr, + result = H5C_expunge_entry(NULL, -1, -1, cache_ptr, &(types[0]), entry_ptr->addr); if ( result > 0 ) { @@ -16813,7 +16813,7 @@ check_expunge_entry_errs(void) if ( pass ) { - result = H5C_expunge_entry(NULL, -1, -1, cache_ptr, + result = H5C_expunge_entry(NULL, -1, -1, cache_ptr, &(types[0]), entry_ptr->addr); if ( result < 0 ) { @@ -16874,11 +16874,11 @@ check_resize_entry_errs(void) pass = TRUE; - /* Allocate a cache, protect an entry, and then call + /* Allocate a cache, protect an entry, and then call * H5C_resize_pinned_entry() to resize it -- this should fail. * * Unprotect the the entry with the pinned flag, and then call - * H5C_resize_pinned_entry() again with new size of zero. + * H5C_resize_pinned_entry() again with new size of zero. * This should fail too. * * Finally, unpin the entry and destroy the cache. @@ -16980,7 +16980,7 @@ check_unprotect_ro_dirty_err(void) pass = TRUE; - /* allocate a cache, protect an entry read only, and then unprotect it + /* allocate a cache, protect an entry read only, and then unprotect it * with the dirtied flag set. This should fail. Destroy the cache * -- should succeed. */ @@ -17022,8 +17022,8 @@ check_unprotect_ro_dirty_err(void) takedown_cache(cache_ptr, FALSE, FALSE); } - /* allocate a another cache, protect an entry read only twice, and - * then unprotect it with the dirtied flag set. This should fail. + /* allocate a another cache, protect an entry read only twice, and + * then unprotect it with the dirtied flag set. This should fail. * Unprotect it with no flags set twice and then destroy the cache. * This should succeed. */ @@ -17110,9 +17110,9 @@ check_protect_ro_rw_err(void) pass = TRUE; - /* allocate a cache, protect an entry read only, and then try to protect + /* allocate a cache, protect an entry read only, and then try to protect * it again rw. This should fail. - * + * * Unprotect the entry and destroy the cache -- should succeed. */ @@ -17166,7 +17166,7 @@ check_protect_ro_rw_err(void) /*------------------------------------------------------------------------- * Function: check_evictions_enabled_err() * - * Purpose: Verify that H5C_get_evictions_enabled() and + * Purpose: Verify that H5C_get_evictions_enabled() and * H5C_set_evictions_enabled() generate errors as expected. * * Return: void @@ -17200,7 +17200,7 @@ check_check_evictions_enabled_err(void) * * Repeat with a NULL evictions_enabled_ptr, should fail as well. * - * Configure the cache to use auto cache resize. Call + * Configure the cache to use auto cache resize. Call * H5C_set_evictions_enabled() to disable evictions. Should fail. * * Unprotect the entry and destroy the cache -- should succeed. @@ -17317,7 +17317,7 @@ check_check_evictions_enabled_err(void) * * John Mainzer 1/8/08 * Added a basic set of tests for the flash cache size - * increment code. + * increment code. * *------------------------------------------------------------------------- */ @@ -17372,7 +17372,7 @@ check_auto_cache_resize(void) /* hbool_t apply_max_increment = */ TRUE, /* size_t max_increment = */ (4 * 1024 * 1024), - /* enum H5C_cache_flash_incr_mode */ + /* enum H5C_cache_flash_incr_mode */ /* flash_incr_mode = */ H5C_flash_incr__off, /* double flash_multiple = */ 2.0, /* double flash_threshold = */ 0.5, @@ -20523,10 +20523,10 @@ check_auto_cache_resize(void) } /* now test the flash cache size increment code. At least at present, - * there should be no interaction between the regular auto-resize - * code and the flash cache size increment code other than a reset + * there should be no interaction between the regular auto-resize + * code and the flash cache size increment code other than a reset * of the counter and stats collection used by the regular auto-resize - * code. Thus we do only limited tests of the two pieces of code + * code. Thus we do only limited tests of the two pieces of code * operating together. * * Start with simple test to verify that the flash cache increment @@ -20535,7 +20535,7 @@ check_auto_cache_resize(void) if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++); - /* allocate a cache, enable the flash cache size increase code, and + /* allocate a cache, enable the flash cache size increase code, and * then force the flash size increase code through all its operational * modes. Verify that all performs as expected. */ @@ -20648,7 +20648,7 @@ check_auto_cache_resize(void) /* Now load a monster entry. Since a monster entry is larger than * half the size of the cache, and there is not sufficient space - * for a monster entry in the cache, we will add space to the + * for a monster entry in the cache, we will add space to the * cache to make room for the entry. */ if ( pass ) { @@ -20664,7 +20664,7 @@ check_auto_cache_resize(void) ( ( ( cache_ptr->max_cache_size != (80 * 1024) ) || ( cache_ptr->min_clean_size != (40 * 1024) ) || ( cache_ptr->index_len != 2 ) || - ( cache_ptr->index_size != (HUGE_ENTRY_SIZE + + ( cache_ptr->index_size != (HUGE_ENTRY_SIZE + MONSTER_ENTRY_SIZE) ) || ( cache_ptr->cache_accesses != 1 ) ) ) ) { @@ -20726,9 +20726,9 @@ check_auto_cache_resize(void) if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++); - /* delete existing entries to prepare for next test, and reset + /* delete existing entries to prepare for next test, and reset * the size of the cache. - */ + */ if ( pass ) { expunge_entry(cache_ptr, MONSTER_ENTRY_TYPE, 1); @@ -20736,12 +20736,12 @@ check_auto_cache_resize(void) if ( pass ) { - result = H5C_set_cache_auto_resize_config(cache_ptr, + result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl); if ( result != SUCCEED ) { - pass = FALSE; + pass = FALSE; failure_mssg = "H5C_set_cache_auto_resize_config failed 13.\n"; } } @@ -20758,7 +20758,7 @@ check_auto_cache_resize(void) } } - /* repeat the above basic test, only this time, use inserts to add + /* repeat the above basic test, only this time, use inserts to add * entries to the cache, not protects. */ @@ -20793,7 +20793,7 @@ check_auto_cache_resize(void) /* Now insert a monster entry. Since a monster entry is larger than * half the size of the cache, and there is not sufficient space - * for a monster entry in the cache, we will add space to the + * for a monster entry in the cache, we will add space to the * cache to make room for the entry. */ if ( pass ) { @@ -20805,7 +20805,7 @@ check_auto_cache_resize(void) ( ( ( cache_ptr->max_cache_size != (80 * 1024) ) || ( cache_ptr->min_clean_size != (40 * 1024) ) || ( cache_ptr->index_len != 2 ) || - ( cache_ptr->index_size != + ( cache_ptr->index_size != HUGE_ENTRY_SIZE + MONSTER_ENTRY_SIZE ) || ( cache_ptr->cache_accesses != 0 ) ) ) ) { @@ -20820,14 +20820,14 @@ check_auto_cache_resize(void) */ if ( pass ) { - insert_entry(cache_ptr, MONSTER_ENTRY_TYPE, 5, TRUE, + insert_entry(cache_ptr, MONSTER_ENTRY_TYPE, 5, TRUE, H5C__NO_FLAGS_SET); if ( ( pass ) && ( ( ( cache_ptr->max_cache_size != (144 * 1024) ) || ( cache_ptr->min_clean_size != ( 72 * 1024) ) || ( cache_ptr->index_len != 3 ) || - ( cache_ptr->index_size != + ( cache_ptr->index_size != 2 * MONSTER_ENTRY_SIZE + HUGE_ENTRY_SIZE ) || ( cache_ptr->cache_accesses != 0 ) ) ) ) { @@ -20862,11 +20862,11 @@ check_auto_cache_resize(void) if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++); - /* delete existing entries to prepare for next test, and reset + /* delete existing entries to prepare for next test, and reset * the size of the cache. We must also change the size of the needed - * variable entries before we run the test, so will protect and + * variable entries before we run the test, so will protect and * unprotect them now so as to get the correct initial size. - */ + */ if ( pass ) { expunge_entry(cache_ptr, MONSTER_ENTRY_TYPE, 5); @@ -20894,12 +20894,12 @@ check_auto_cache_resize(void) if ( pass ) { auto_size_ctl.initial_size = 6 * 1024; - result = H5C_set_cache_auto_resize_config(cache_ptr, + result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl); if ( result != SUCCEED ) { - pass = FALSE; + pass = FALSE; failure_mssg = "H5C_set_cache_auto_resize_config failed 13.\n"; } } @@ -20922,11 +20922,11 @@ check_auto_cache_resize(void) if ( pass ) { protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10); - unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE, + unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE, H5C__NO_FLAGS_SET); protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11); - unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE, + unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE, H5C__NO_FLAGS_SET); protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12); @@ -21049,7 +21049,7 @@ check_auto_cache_resize(void) if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++); /* re-size the variable entries back down to their initial size, and - * restore the cache to its initial size as well, in preparation + * restore the cache to its initial size as well, in preparation * for the next test. */ if ( pass ) { @@ -21067,12 +21067,12 @@ check_auto_cache_resize(void) if ( pass ) { auto_size_ctl.initial_size = 6 * 1024; - result = H5C_set_cache_auto_resize_config(cache_ptr, + result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl); if ( result != SUCCEED ) { - pass = FALSE; + pass = FALSE; failure_mssg = "H5C_set_cache_auto_resize_config failed 14.\n"; } } @@ -21096,7 +21096,7 @@ check_auto_cache_resize(void) if ( pass ) { protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10); - unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE, + unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE, H5C__PIN_ENTRY_FLAG); resize_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, 2 * 1024, TRUE); @@ -21135,7 +21135,7 @@ check_auto_cache_resize(void) if ( pass ) { protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11); - unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE, + unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE, H5C__PIN_ENTRY_FLAG); resize_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, 10 * 1024, TRUE); @@ -21156,7 +21156,7 @@ check_auto_cache_resize(void) if ( pass ) { protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12); - unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE, + unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE, H5C__PIN_ENTRY_FLAG); resize_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, 10 * 1024, TRUE); @@ -21180,15 +21180,15 @@ check_auto_cache_resize(void) if ( pass ) { protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10); - unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE, + unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE, H5C__UNPIN_ENTRY_FLAG); protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11); - unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE, + unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE, H5C__UNPIN_ENTRY_FLAG); protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12); - unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE, + unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE, H5C__UNPIN_ENTRY_FLAG); if ( ( pass ) && @@ -21206,7 +21206,7 @@ check_auto_cache_resize(void) if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++); /* re-size the variable entries back down to their initial size, and - * restore the cache to its initial size as well, in preparation + * restore the cache to its initial size as well, in preparation * for the next test. */ if ( pass ) { @@ -21224,12 +21224,12 @@ check_auto_cache_resize(void) if ( pass ) { auto_size_ctl.initial_size = 6 * 1024; - result = H5C_set_cache_auto_resize_config(cache_ptr, + result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl); if ( result != SUCCEED ) { - pass = FALSE; + pass = FALSE; failure_mssg = "H5C_set_cache_auto_resize_config failed 15.\n"; } } @@ -21249,7 +21249,7 @@ check_auto_cache_resize(void) if ( pass ) { protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10); - unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE, + unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE, H5C__PIN_ENTRY_FLAG); resize_pinned_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, 2 * 1024); @@ -21288,7 +21288,7 @@ check_auto_cache_resize(void) if ( pass ) { protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11); - unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE, + unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE, H5C__PIN_ENTRY_FLAG); resize_pinned_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, 10 * 1024); @@ -21309,7 +21309,7 @@ check_auto_cache_resize(void) if ( pass ) { protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12); - unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE, + unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE, H5C__PIN_ENTRY_FLAG); resize_pinned_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, 10 * 1024); @@ -21333,15 +21333,15 @@ check_auto_cache_resize(void) if ( pass ) { protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10); - unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE, + unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE, H5C__UNPIN_ENTRY_FLAG); protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11); - unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE, + unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE, H5C__UNPIN_ENTRY_FLAG); protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12); - unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE, + unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE, H5C__UNPIN_ENTRY_FLAG); if ( ( pass ) && @@ -21455,14 +21455,14 @@ check_auto_cache_resize(void) if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++); /* protect and unprotect a large entry -- no change in cache size since - * a large entry will just fill the available space in the cache. + * a large entry will just fill the available space in the cache. */ if ( pass ) { rpt_fcn_called = FALSE; protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0); - unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0, NO_CHANGE, + unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0, NO_CHANGE, H5C__NO_FLAGS_SET); if ( ( pass ) && @@ -21480,7 +21480,7 @@ check_auto_cache_resize(void) if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++); - /* protect and unprotect another a large entry -- should trigger a + /* protect and unprotect another a large entry -- should trigger a * flash cache size increase to 12 KB (remember that flash_multiple is * set to 2.0). */ @@ -21489,7 +21489,7 @@ check_auto_cache_resize(void) rpt_fcn_called = FALSE; protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 1); - unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 1, NO_CHANGE, + unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 1, NO_CHANGE, H5C__NO_FLAGS_SET); if ( ( pass ) && @@ -21507,7 +21507,7 @@ check_auto_cache_resize(void) if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++); - /* protect and unprotect two more large entries -- shouldnt trigger a + /* protect and unprotect two more large entries -- shouldnt trigger a * flash cache size increase. */ if ( pass ) { @@ -21515,10 +21515,10 @@ check_auto_cache_resize(void) rpt_fcn_called = FALSE; protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 2); - unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 2, NO_CHANGE, + unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 2, NO_CHANGE, H5C__NO_FLAGS_SET); protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 3); - unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 3, NO_CHANGE, + unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 3, NO_CHANGE, H5C__NO_FLAGS_SET); if ( ( pass ) && @@ -21536,7 +21536,7 @@ check_auto_cache_resize(void) if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++); - /* do many accesses of a single entry to talk the cache into reducing + /* do many accesses of a single entry to talk the cache into reducing * its size to the minimum. */ if ( pass ) { @@ -21572,17 +21572,17 @@ check_auto_cache_resize(void) rpt_fcn_called = FALSE; protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0); - unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0, NO_CHANGE, + unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0, NO_CHANGE, H5C__NO_FLAGS_SET); if ( ( pass ) && ( ( ( cache_ptr->max_cache_size != (4 * 1024 + 128) ) || ( cache_ptr->min_clean_size != (2 * 1024 + 64) ) || ( cache_ptr->index_len != 2 ) || - ( cache_ptr->index_size != + ( cache_ptr->index_size != LARGE_ENTRY_SIZE + TINY_ENTRY_SIZE ) || ( cache_ptr->cache_accesses != 1 ) || - ( rpt_fcn_called == FALSE ) || + ( rpt_fcn_called == FALSE ) || ( rpt_status != flash_increase ) ) ) ) { pass = FALSE; @@ -21610,7 +21610,7 @@ check_auto_cache_resize(void) if ( ( cache_ptr->max_cache_size != (20 * 1024) ) || ( cache_ptr->min_clean_size != (10 * 1024) ) || - ( rpt_fcn_called == FALSE ) || + ( rpt_fcn_called == FALSE ) || ( rpt_status != at_max_size ) ) { pass = FALSE; @@ -21654,7 +21654,7 @@ check_auto_cache_resize(void) * * Modifications: * - * Added code to include the flash cache size increment + * Added code to include the flash cache size increment * code in this test. * JRM -- 1/10/08 * @@ -21695,7 +21695,7 @@ check_auto_cache_resize_disable(void) /* hbool_t apply_max_increment = */ TRUE, /* size_t max_increment = */ (4 * 1024 * 1024), - /* enum H5C_cache_flash_incr_mode */ + /* enum H5C_cache_flash_incr_mode */ /* flash_incr_mode = */ H5C_flash_incr__off, /* double flash_multiple = */ 1.0, /* double flash_threshold = */ 0.25, @@ -24207,27 +24207,27 @@ check_auto_cache_resize_disable(void) if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++); /* Now test the flash cache size increment code to verify that it - * is disabled when it should be. + * is disabled when it should be. * - * Since the flash size increase code doesn't look at hit rate, or + * Since the flash size increase code doesn't look at hit rate, or * use epochs (other than to start a new epoch if a flash cache size * increase is triggered), we go about these tests somewhat differently * than the rest of the tests in this function. * - * As of this writing, there is only one flash cache size increment + * As of this writing, there is only one flash cache size increment * mode (add space), which is triggered whenever the size of a newly * loaded or inserted entry, or the delta between old and new entry * sizes exceeds some fraction of the current maximum cache size, and * the cache doesn't have enough free space to accomodate the new/ * resize entry without performing evictions. The range of permissible * values for the flash_threshold (0.1 to 1.0 as of this writing), and - * for the flash_multiple (0.1 to 10.0) do not permit the facility to + * for the flash_multiple (0.1 to 10.0) do not permit the facility to * be turned off by configuration. Thus, flash cache size increases - * can be disabled only via the flash_incr_mode, and by setting the + * can be disabled only via the flash_incr_mode, and by setting the * current max_cache_size equal to max_size. * * We have already tested the latter in check_auto_cache_resize(), so - * we need only thest the former here. Do this by disabling flash + * we need only thest the former here. Do this by disabling flash * cache size increments via the flash_incr_mode, and then creating * situations that would trigger flash cache size increases were that * code enabled. @@ -24339,7 +24339,7 @@ check_auto_cache_resize_disable(void) * size increment code was active, this would trigger an increase. * Verify that it doesn't. * - * This finishes the additional tests needed for the flash cache + * This finishes the additional tests needed for the flash cache * size increase code. */ if ( pass ) { @@ -24446,7 +24446,7 @@ check_auto_cache_resize_epoch_markers(void) /* hbool_t apply_max_increment = */ TRUE, /* size_t max_increment = */ (4 * 1024 * 1024), - /* enum H5C_cache_flash_incr_mode */ + /* enum H5C_cache_flash_incr_mode */ /* flash_incr_mode = */ H5C_flash_incr__off, /* double flash_multiple = */ 2.0, /* double flash_threshold = */ 0.5, @@ -25116,7 +25116,7 @@ check_auto_cache_resize_epoch_markers(void) * * Modifications: * - * Added code to verify that errors in the flash cache size + * Added code to verify that errors in the flash cache size * increment related fields are caught as well. * * JRM -- 1/17/08 @@ -25186,7 +25186,7 @@ check_auto_cache_resize_input_errs(void) /* hbool_t apply_max_increment = */ TRUE, /* size_t max_increment = */ (4 * 1024 * 1024), - /* enum H5C_cache_flash_incr_mode */ + /* enum H5C_cache_flash_incr_mode */ /* flash_incr_mode = */ H5C_flash_incr__off, /* double flash_multiple = */ 2.0, /* double flash_threshold = */ 0.5, @@ -26567,7 +26567,7 @@ check_auto_cache_resize_input_errs(void) invalid_auto_size_ctl.apply_max_increment = TRUE; invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024); - invalid_auto_size_ctl.flash_incr_mode = + invalid_auto_size_ctl.flash_incr_mode = (enum H5C_cache_flash_incr_mode) -1; /* INVALID */ invalid_auto_size_ctl.flash_multiple = 2.0; invalid_auto_size_ctl.flash_threshold = 0.5; @@ -26643,7 +26643,7 @@ check_auto_cache_resize_input_errs(void) invalid_auto_size_ctl.apply_max_increment = TRUE; invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024); - invalid_auto_size_ctl.flash_incr_mode = + invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__add_space; invalid_auto_size_ctl.flash_multiple = 0.09; /* INVALID */ invalid_auto_size_ctl.flash_threshold = 0.5; @@ -26717,7 +26717,7 @@ check_auto_cache_resize_input_errs(void) invalid_auto_size_ctl.apply_max_increment = TRUE; invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024); - invalid_auto_size_ctl.flash_incr_mode = + invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__add_space; invalid_auto_size_ctl.flash_multiple = 10.01; /* INVALID */ invalid_auto_size_ctl.flash_threshold = 0.5; @@ -26793,7 +26793,7 @@ check_auto_cache_resize_input_errs(void) invalid_auto_size_ctl.apply_max_increment = TRUE; invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024); - invalid_auto_size_ctl.flash_incr_mode = + invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__add_space; invalid_auto_size_ctl.flash_multiple = 1.0; invalid_auto_size_ctl.flash_threshold = 0.09; /* INVALID */ @@ -26867,7 +26867,7 @@ check_auto_cache_resize_input_errs(void) invalid_auto_size_ctl.apply_max_increment = TRUE; invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024); - invalid_auto_size_ctl.flash_incr_mode = + invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__add_space; invalid_auto_size_ctl.flash_multiple = 1.0; invalid_auto_size_ctl.flash_threshold = 1.001; /* INVALID */ @@ -27632,7 +27632,7 @@ check_auto_cache_resize_aux_fcns(void) /* hbool_t apply_max_increment = */ TRUE, /* size_t max_increment = */ (4 * 1024 * 1024), - /* enum H5C_cache_flash_incr_mode */ + /* enum H5C_cache_flash_incr_mode */ /* flash_incr_mode = */ H5C_flash_incr__off, /* double flash_multiple = */ 2.0, /* double flash_threshold = */ 0.5, |