#include "H5private.h"

#include "H5CXprivate.h" /* API Contexts */

#include "H5MMprivate.h"

#include "cache_common.h"

bool pass = true; /* set to false on error */

const char *failure_mssg = NULL;

static char tmp_msg_buf[256];

static test_entry_t *pico_entries = NULL, *orig_pico_entries = NULL;

static test_entry_t *nano_entries = NULL, *orig_nano_entries = NULL;

static test_entry_t *micro_entries = NULL, *orig_micro_entries = NULL;

static test_entry_t *tiny_entries = NULL, *orig_tiny_entries = NULL;

static test_entry_t *small_entries = NULL, *orig_small_entries = NULL;

static test_entry_t *medium_entries = NULL, *orig_medium_entries = NULL;

static test_entry_t *large_entries = NULL, *orig_large_entries = NULL;

static test_entry_t *huge_entries = NULL, *orig_huge_entries = NULL;

static test_entry_t *monster_entries = NULL, *orig_monster_entries = NULL;

static test_entry_t *variable_entries = NULL, *orig_variable_entries = NULL;

static test_entry_t *notify_entries = NULL, *orig_notify_entries = NULL;

bool orig_entry_arrays_init = false;

static herr_t pico_get_initial_load_size(void *udata_ptr, size_t *image_len_ptr);

static herr_t nano_get_initial_load_size(void *udata_ptr, size_t *image_len_ptr);

static herr_t micro_get_initial_load_size(void *udata_ptr, size_t *image_len_ptr);

static herr_t tiny_get_initial_load_size(void *udata_ptr, size_t *image_len_ptr);

static herr_t small_get_initial_load_size(void *udata_ptr, size_t *image_len_ptr);

static herr_t medium_get_initial_load_size(void *udata_ptr, size_t *image_len_ptr);

static herr_t large_get_initial_load_size(void *udata_ptr, size_t *image_len_ptr);

static herr_t huge_get_initial_load_size(void *udata_ptr, size_t *image_len_ptr);

static herr_t monster_get_initial_load_size(void *udata_ptr, size_t *image_len_ptr);

static herr_t variable_get_initial_load_size(void *udata_ptr, size_t *image_len_ptr);

static herr_t notify_get_initial_load_size(void *udata_ptr, size_t *image_len_ptr);

static herr_t variable_get_final_load_size(const void *image, size_t image_len, void *udata,

size_t *actual_len);

static htri_t variable_verify_chksum(const void *image_ptr, size_t len, void *udata_ptr);

static void *pico_deserialize(const void *image_ptr, size_t len, void *udata_ptr, bool *dirty_ptr);

static void *nano_deserialize(const void *image_ptr, size_t len, void *udata_ptr, bool *dirty_ptr);

static void *micro_deserialize(const void *image_ptr, size_t len, void *udata_ptr, bool *dirty_ptr);

static void *tiny_deserialize(const void *image_ptr, size_t len, void *udata_ptr, bool *dirty_ptr);

static void *small_deserialize(const void *image_ptr, size_t len, void *udata_ptr, bool *dirty_ptr);

static void *medium_deserialize(const void *image_ptr, size_t len, void *udata_ptr, bool *dirty_ptr);

static void *large_deserialize(const void *image_ptr, size_t len, void *udata_ptr, bool *dirty_ptr);

static void *huge_deserialize(const void *image_ptr, size_t len, void *udata_ptr, bool *dirty_ptr);

static void *monster_deserialize(const void *image_ptr, size_t len, void *udata_ptr, bool *dirty_ptr);

static void *variable_deserialize(const void *image_ptr, size_t len, void *udata_ptr, bool *dirty_ptr);

static void *notify_deserialize(const void *image_ptr, size_t len, void *udata_ptr, bool *dirty_ptr);

static herr_t pico_image_len(const void *thing, size_t *image_len_ptr);

static herr_t nano_image_len(const void *thing, size_t *image_len_ptr);

static herr_t micro_image_len(const void *thing, size_t *image_len_ptr);

static herr_t tiny_image_len(const void *thing, size_t *image_len_ptr);

static herr_t small_image_len(const void *thing, size_t *image_len_ptr);

static herr_t medium_image_len(const void *thing, size_t *image_len_ptr);

static herr_t large_image_len(const void *thing, size_t *image_len_ptr);

static herr_t huge_image_len(const void *thing, size_t *image_len_ptr);

static herr_t monster_image_len(const void *thing, size_t *image_len_ptr);

static herr_t variable_image_len(const void *thing, size_t *image_len_ptr);

static herr_t notify_image_len(const void *thing, size_t *image_len_ptr);

static herr_t pico_pre_serialize(H5F_t *f, void *thing, haddr_t addr, size_t len, haddr_t *new_addr_ptr,

size_t *new_len_ptr, unsigned *flags_ptr);

static herr_t nano_pre_serialize(H5F_t *f, void *thing, haddr_t addr, size_t len, haddr_t *new_addr_ptr,

size_t *new_len_ptr, unsigned *flags_ptr);

static herr_t micro_pre_serialize(H5F_t *f, void *thing, haddr_t addr, size_t len, haddr_t *new_addr_ptr,

size_t *new_len_ptr, unsigned *flags_ptr);

static herr_t tiny_pre_serialize(H5F_t *f, void *thing, haddr_t addr, size_t len, haddr_t *new_addr_ptr,

size_t *new_len_ptr, unsigned *flags_ptr);

static herr_t small_pre_serialize(H5F_t *f, void *thing, haddr_t addr, size_t len, haddr_t *new_addr_ptr,

size_t *new_len_ptr, unsigned *flags_ptr);

static herr_t medium_pre_serialize(H5F_t *f, void *thing, haddr_t addr, size_t len, haddr_t *new_addr_ptr,

size_t *new_len_ptr, unsigned *flags_ptr);

static herr_t large_pre_serialize(H5F_t *f, void *thing, haddr_t addr, size_t len, haddr_t *new_addr_ptr,

size_t *new_len_ptr, unsigned *flags_ptr);

static herr_t huge_pre_serialize(H5F_t *f, void *thing, haddr_t addr, size_t len, haddr_t *new_addr_ptr,

size_t *new_len_ptr, unsigned *flags_ptr);

static herr_t monster_pre_serialize(H5F_t *f, void *thing, haddr_t addr, size_t len, haddr_t *new_addr_ptr,

size_t *new_len_ptr, unsigned *flags_ptr);

static herr_t variable_pre_serialize(H5F_t *f, void *thing, haddr_t addr, size_t len, haddr_t *new_addr_ptr,

size_t *new_len_ptr, unsigned *flags_ptr);

static herr_t notify_pre_serialize(H5F_t *f, void *thing, haddr_t addr, size_t len, haddr_t *new_addr_ptr,

size_t *new_len_ptr, unsigned *flags_ptr);

static herr_t pico_serialize(const H5F_t *f, void *image_ptr, size_t len, void *thing);

static herr_t nano_serialize(const H5F_t *f, void *image_ptr, size_t len, void *thing);

static herr_t micro_serialize(const H5F_t *f, void *image_ptr, size_t len, void *thing);

static herr_t tiny_serialize(const H5F_t *f, void *image_ptr, size_t len, void *thing);

static herr_t small_serialize(const H5F_t *f, void *image_ptr, size_t len, void *thing);

static herr_t medium_serialize(const H5F_t *f, void *image_ptr, size_t len, void *thing);

static herr_t large_serialize(const H5F_t *f, void *image_ptr, size_t len, void *thing);

static herr_t huge_serialize(const H5F_t *f, void *image_ptr, size_t len, void *thing);

static herr_t monster_serialize(const H5F_t *f, void *image_ptr, size_t len, void *thing);

static herr_t variable_serialize(const H5F_t *f, void *image_ptr, size_t len, void *thing);

static herr_t notify_serialize(const H5F_t *f, void *image_ptr, size_t len, void *thing);

static herr_t pico_free_icr(void *thing);

static herr_t nano_free_icr(void *thing);

static herr_t micro_free_icr(void *thing);

static herr_t tiny_free_icr(void *thing);

static herr_t small_free_icr(void *thing);

static herr_t medium_free_icr(void *thing);

static herr_t large_free_icr(void *thing);

static herr_t huge_free_icr(void *thing);

static herr_t monster_free_icr(void *thing);

static herr_t variable_free_icr(void *thing);

static herr_t notify_free_icr(void *thing);

static herr_t notify_notify(H5C_notify_action_t action, void *thing);

static void mark_flush_dep_dirty(test_entry_t *entry_ptr);

static void mark_flush_dep_clean(test_entry_t *entry_ptr);

static herr_t get_initial_load_size(void *udata_ptr, size_t *image_len_ptr, int32_t entry_type);

static herr_t get_final_load_size(const void *image, size_t image_len, void *udata, size_t *actual_len,

int32_t entry_type);

static void *deserialize(const void *image_ptr, size_t len, void *udata_ptr, bool *dirty_ptr,

int32_t entry_type);

static herr_t image_len(const void *thing, size_t *image_len_ptr, int32_t entry_type);

static herr_t pre_serialize(H5F_t *f, void *thing, haddr_t addr, size_t len, haddr_t *new_addr_ptr,

size_t *new_len_ptr, unsigned *flags_ptr);

static herr_t serialize(const H5F_t *f, void *image_ptr, size_t len, void *thing);

static herr_t notify(H5C_notify_action_t action, void *thing, int32_t entry_type);

static herr_t free_icr(test_entry_t *entry, int32_t entry_type);

static void execute_flush_op(H5F_t *file_ptr, struct test_entry_t *entry_ptr, struct flush_op *op_ptr,

unsigned *flags_ptr);

test_entry_t *entries[NUMBER_OF_ENTRY_TYPES];

test_entry_t *orig_entries[NUMBER_OF_ENTRY_TYPES];

const int32_t max_indices[NUMBER_OF_ENTRY_TYPES] = {

NUM_PICO_ENTRIES - 1, NUM_NANO_ENTRIES - 1, NUM_MICRO_ENTRIES - 1, NUM_TINY_ENTRIES - 1,

NUM_SMALL_ENTRIES - 1, NUM_MEDIUM_ENTRIES - 1, NUM_LARGE_ENTRIES - 1, NUM_HUGE_ENTRIES - 1,

NUM_MONSTER_ENTRIES - 1, NUM_VARIABLE_ENTRIES - 1, NUM_NOTIFY_ENTRIES - 1};

const size_t entry_sizes[NUMBER_OF_ENTRY_TYPES] = {PICO_ENTRY_SIZE, NANO_ENTRY_SIZE, MICRO_ENTRY_SIZE,

TINY_ENTRY_SIZE, SMALL_ENTRY_SIZE, MEDIUM_ENTRY_SIZE,

LARGE_ENTRY_SIZE, HUGE_ENTRY_SIZE, MONSTER_ENTRY_SIZE,

VARIABLE_ENTRY_SIZE, NOTIFY_ENTRY_SIZE};

const haddr_t base_addrs[NUMBER_OF_ENTRY_TYPES] = {

PICO_BASE_ADDR, NANO_BASE_ADDR, MICRO_BASE_ADDR, TINY_BASE_ADDR, SMALL_BASE_ADDR, MEDIUM_BASE_ADDR,

LARGE_BASE_ADDR, HUGE_BASE_ADDR, MONSTER_BASE_ADDR, VARIABLE_BASE_ADDR, NOTIFY_BASE_ADDR};

const haddr_t alt_base_addrs[NUMBER_OF_ENTRY_TYPES] = {

PICO_ALT_BASE_ADDR, NANO_ALT_BASE_ADDR, MICRO_ALT_BASE_ADDR, TINY_ALT_BASE_ADDR,

SMALL_ALT_BASE_ADDR, MEDIUM_ALT_BASE_ADDR, LARGE_ALT_BASE_ADDR, HUGE_ALT_BASE_ADDR,

MONSTER_ALT_BASE_ADDR, VARIABLE_ALT_BASE_ADDR, NOTIFY_ALT_BASE_ADDR};

static const H5C_class_t pico_class[1] = {{

PICO_ENTRY_TYPE,

"pico_entry",

H5FD_MEM_DEFAULT,

H5C__CLASS_NO_FLAGS_SET,

pico_get_initial_load_size,

NULL,

NULL,

pico_deserialize,

pico_image_len,

pico_pre_serialize,

pico_serialize,

NULL,

pico_free_icr,

NULL,

}};

static const H5C_class_t nano_class[1] = {{

NANO_ENTRY_TYPE,

"nano_entry",

H5FD_MEM_DEFAULT,

H5C__CLASS_NO_FLAGS_SET,

nano_get_initial_load_size,

NULL,

NULL,

nano_deserialize,

nano_image_len,

nano_pre_serialize,

nano_serialize,

NULL,

nano_free_icr,

NULL,

}};

static const H5C_class_t micro_class[1] = {{

MICRO_ENTRY_TYPE,

"micro_entry",

H5FD_MEM_DEFAULT,

H5C__CLASS_NO_FLAGS_SET,

micro_get_initial_load_size,

NULL,

NULL,

micro_deserialize,

micro_image_len,

micro_pre_serialize,

micro_serialize,

NULL,

micro_free_icr,

NULL,

}};

static const H5C_class_t tiny_class[1] = {{

TINY_ENTRY_TYPE,

"tiny_entry",

H5FD_MEM_DEFAULT,

H5C__CLASS_NO_FLAGS_SET,

tiny_get_initial_load_size,

NULL,

NULL,

tiny_deserialize,

tiny_image_len,

tiny_pre_serialize,

tiny_serialize,

NULL,

tiny_free_icr,

NULL,

}};

static const H5C_class_t small_class[1] = {{

SMALL_ENTRY_TYPE,

"small_entry",

H5FD_MEM_DEFAULT,

H5C__CLASS_NO_FLAGS_SET,

small_get_initial_load_size,

NULL,

NULL,

small_deserialize,

small_image_len,

small_pre_serialize,

small_serialize,

NULL,

small_free_icr,

NULL,

}};

static const H5C_class_t medium_class[1] = {{

MEDIUM_ENTRY_TYPE,

"medium_entry",

H5FD_MEM_DEFAULT,

H5C__CLASS_NO_FLAGS_SET,

medium_get_initial_load_size,

NULL,

NULL,

medium_deserialize,

medium_image_len,

medium_pre_serialize,

medium_serialize,

NULL,

medium_free_icr,

NULL,

}};

static const H5C_class_t large_class[1] = {{

LARGE_ENTRY_TYPE,

"large_entry",

H5FD_MEM_DEFAULT,

H5C__CLASS_NO_FLAGS_SET,

large_get_initial_load_size,

NULL,

NULL,

large_deserialize,

large_image_len,

large_pre_serialize,

large_serialize,

NULL,

large_free_icr,

NULL,

}};

static const H5C_class_t huge_class[1] = {{

HUGE_ENTRY_TYPE,

"huge_entry",

H5FD_MEM_DEFAULT,

H5C__CLASS_NO_FLAGS_SET,

huge_get_initial_load_size,

NULL,

NULL,

huge_deserialize,

huge_image_len,

huge_pre_serialize,

huge_serialize,

NULL,

huge_free_icr,

NULL,

}};

static const H5C_class_t monster_class[1] = {{

MONSTER_ENTRY_TYPE,

"monster_entry",

H5FD_MEM_DEFAULT,

H5C__CLASS_NO_FLAGS_SET,

monster_get_initial_load_size,

NULL,

NULL,

monster_deserialize,

monster_image_len,

monster_pre_serialize,

monster_serialize,

NULL,

monster_free_icr,

NULL,

}};

static const H5C_class_t variable_class[1] = {{

VARIABLE_ENTRY_TYPE,

"variable_entry",

H5FD_MEM_DEFAULT,

H5C__CLASS_SPECULATIVE_LOAD_FLAG,

variable_get_initial_load_size,

variable_get_final_load_size,

variable_verify_chksum,

variable_deserialize,

variable_image_len,

variable_pre_serialize,

variable_serialize,

NULL,

variable_free_icr,

NULL,

}};

static const H5C_class_t notify_class[1] = {{

NOTIFY_ENTRY_TYPE,

"notify_entry",

H5FD_MEM_DEFAULT,

H5C__CLASS_NO_FLAGS_SET,

notify_get_initial_load_size,

NULL,

NULL,

notify_deserialize,

notify_image_len,

notify_pre_serialize,

notify_serialize,

notify_notify,

notify_free_icr,

NULL,

}};

const H5C_class_t *types[NUMBER_OF_ENTRY_TYPES] = {pico_class, nano_class, micro_class, tiny_class,

small_class, medium_class, large_class, huge_class,

monster_class, variable_class, notify_class};

addr_to_type_and_index(haddr_t addr, int32_t *type_ptr, int32_t *index_ptr)

{

int i;

int32_t type;

int32_t idx;

assert(type_ptr);

assert(index_ptr);

/* we only have a small number of entry types, so just do a

i = 1;

if (addr >= PICO_ALT_BASE_ADDR) {

while ((i < NUMBER_OF_ENTRY_TYPES) && (addr >= alt_base_addrs[i])) {

i++;

}

}

else {

while ((i < NUMBER_OF_ENTRY_TYPES) && (addr >= base_addrs[i])) {

i++;

}

}

type = i - 1;

assert((type >= 0) && (type < NUMBER_OF_ENTRY_TYPES));

if (addr >= PICO_ALT_BASE_ADDR) {

idx = (int32_t)((addr - alt_base_addrs[type]) / entry_sizes[type]);

assert((idx >= 0) && (idx <= max_indices[type]));

assert(!((entries[type])[idx].at_main_addr));

assert(addr == (entries[type])[idx].alt_addr);

}

else {

idx = (int32_t)((addr - base_addrs[type]) / entry_sizes[type]);

assert((idx >= 0) && (idx <= max_indices[type]));

assert((entries[type])[idx].at_main_addr);

assert(addr == (entries[type])[idx].main_addr);

}

assert(addr == (entries[type])[idx].addr);

*type_ptr = type;

*index_ptr = idx;

} /* addr_to_type_and_index() */

static herr_t

get_initial_load_size(void *udata, size_t *image_length, int32_t H5_ATTR_NDEBUG_UNUSED entry_type)

{

test_entry_t *entry;

test_entry_t *base_addr;

haddr_t addr = *(const haddr_t *)udata;

int32_t type;

int32_t idx;

addr_to_type_and_index(addr, &type, &idx);

base_addr = entries[type];

entry = &(base_addr[idx]);

assert(entry->type >= 0);

assert(entry->type == type);

assert(entry->type == entry_type);

assert(entry->type < NUMBER_OF_ENTRY_TYPES);

assert(entry->index == idx);

assert(entry->index >= 0);

assert(entry->index <= max_indices[type]);

assert(entry == entry->self);

assert(entry->addr == addr);

*image_length = entry->size;

return (SUCCEED);

} /* get_initial_load_size() */

static herr_t

pico_get_initial_load_size(void *udata, size_t *image_length)

{

return get_initial_load_size(udata, image_length, PICO_ENTRY_TYPE);

}

static herr_t

nano_get_initial_load_size(void *udata, size_t *image_length)

{

return get_initial_load_size(udata, image_length, NANO_ENTRY_TYPE);

}

static herr_t

micro_get_initial_load_size(void *udata, size_t *image_length)

{

return get_initial_load_size(udata, image_length, MICRO_ENTRY_TYPE);

}

static herr_t

tiny_get_initial_load_size(void *udata, size_t *image_length)

{

return get_initial_load_size(udata, image_length, TINY_ENTRY_TYPE);

}

static herr_t

small_get_initial_load_size(void *udata, size_t *image_length)

{

return get_initial_load_size(udata, image_length, SMALL_ENTRY_TYPE);

}

static herr_t

medium_get_initial_load_size(void *udata, size_t *image_length)

{

return get_initial_load_size(udata, image_length, MEDIUM_ENTRY_TYPE);

}

static herr_t

large_get_initial_load_size(void *udata, size_t *image_length)

{

return get_initial_load_size(udata, image_length, LARGE_ENTRY_TYPE);

}

static herr_t

huge_get_initial_load_size(void *udata, size_t *image_length)

{

return get_initial_load_size(udata, image_length, HUGE_ENTRY_TYPE);

}

static herr_t

monster_get_initial_load_size(void *udata, size_t *image_length)

{

return get_initial_load_size(udata, image_length, MONSTER_ENTRY_TYPE);

}

static herr_t

variable_get_initial_load_size(void *udata, size_t *image_length)

{

return get_initial_load_size(udata, image_length, VARIABLE_ENTRY_TYPE);

}

static herr_t

notify_get_initial_load_size(void *udata, size_t *image_length)

{

return get_initial_load_size(udata, image_length, NOTIFY_ENTRY_TYPE);

}

static herr_t

get_final_load_size(const void H5_ATTR_UNUSED *image, size_t H5_ATTR_UNUSED image_len, void *udata,

size_t *actual_len, int32_t H5_ATTR_NDEBUG_UNUSED entry_type)

{

test_entry_t *entry;

test_entry_t *base_addr;

haddr_t addr = *(const haddr_t *)udata;

int32_t type;

int32_t idx;

addr_to_type_and_index(addr, &type, &idx);

base_addr = entries[type];

entry = &(base_addr[idx]);

assert(entry->type >= 0);

assert(entry->type == type);

assert(entry->type == entry_type);

assert(entry->type < NUMBER_OF_ENTRY_TYPES);

assert(entry->index == idx);

assert(entry->index >= 0);

assert(entry->index <= max_indices[type]);

assert(entry == entry->self);

assert(entry->addr == addr);

assert(type == VARIABLE_ENTRY_TYPE);

/* Simulate SPECULATIVE read with a specified actual_len */

if (entry->actual_len) {

*actual_len = entry->actual_len;

entry->size = entry->actual_len;

} /* end if */

else

*actual_len = entry->size;

return (SUCCEED);

} /* get_final_load_size() */

static herr_t

variable_get_final_load_size(const void *image, size_t image_len, void *udata, size_t *actual_len)

{

return get_final_load_size(image, image_len, udata, actual_len, VARIABLE_ENTRY_TYPE);

}

static htri_t

verify_chksum(const void H5_ATTR_UNUSED *image, size_t H5_ATTR_UNUSED len, void *udata,

int32_t H5_ATTR_NDEBUG_UNUSED entry_type)

{

test_entry_t *entry;

test_entry_t *base_addr;

haddr_t addr = *(const haddr_t *)udata;

int32_t type;

int32_t idx;

addr_to_type_and_index(addr, &type, &idx);

base_addr = entries[type];

entry = &(base_addr[idx]);

assert(entry->type >= 0);

assert(entry->type == type);

assert(entry->type == entry_type);

assert(entry->type < NUMBER_OF_ENTRY_TYPES);

assert(type == VARIABLE_ENTRY_TYPE);

assert(entry->index == idx);

assert(entry->index >= 0);

assert(entry->index <= max_indices[type]);

assert(entry == entry->self);

assert(entry->addr == addr);

if (++entry->verify_ct >= entry->max_verify_ct)

return (true);

else

return (false);

} /* verify_chksum() */

static htri_t

variable_verify_chksum(const void *image, size_t len, void *udata)

{

return verify_chksum(image, len, udata, VARIABLE_ENTRY_TYPE);

}

static void *

deserialize(const void *image, size_t H5_ATTR_NDEBUG_UNUSED len, void *udata, bool *dirty,

int32_t H5_ATTR_NDEBUG_UNUSED entry_type)

{

test_entry_t *entry;

test_entry_t *base_addr;

haddr_t addr = *(haddr_t *)udata;

int32_t type;

int32_t idx;

addr_to_type_and_index(addr, &type, &idx);

base_addr = entries[type];

entry = &(base_addr[idx]);

assert(entry->type >= 0);

assert(entry->type == type);

assert(entry->type == entry_type);

assert(entry->type < NUMBER_OF_ENTRY_TYPES);

assert(entry->index == idx);

assert(entry->index >= 0);

assert(entry->index <= max_indices[type]);

assert(entry == entry->self);

assert(entry->addr == addr);

assert(entry->size == len);

assert((entry->type == VARIABLE_ENTRY_TYPE) || (entry->size == entry_sizes[type]));

assert(dirty != NULL);

assert(entry->flush_dep_npar == 0);

assert(entry->flush_dep_nchd == 0);

/* for now *dirty will always be false */

*dirty = false;

/* verify that the image contains the expected data. */

assert(image != NULL);

if ((entry->at_main_addr && entry->written_to_main_addr) ||

(!entry->at_main_addr && entry->written_to_alt_addr)) {

if ((type == PICO_ENTRY_TYPE) || (type == VARIABLE_ENTRY_TYPE) || (type == NOTIFY_ENTRY_TYPE)) {

if ((*((const char *)image)) != (char)(idx & 0xFF)) {

fprintf(stdout, "type = %d, idx = %d, addr = 0x%lx.\n", type, idx, (long)addr);

fprintf(stdout, "*image = 0x%x\n", (int)(*((const char *)image)));

fprintf(stdout, "expected *image = 0x%x\n", (int)(idx & 0xFF));

} /* end if */

assert((*((const char *)image)) == (char)(idx & 0xFF));

} /* end if */

else {

if ((*(((const char *)image) + 2)) != (char)(idx & 0xFF)) {

fprintf(stdout, "type = %d, idx = %d, addr = 0x%lx.\n", type, idx, (long)addr);

fprintf(stdout, "*image = 0x%" PRIx8 " 0x%" PRIx8 " 0x%" PRIx8 "\n",

(*((const uint8_t *)image)), (*(((const uint8_t *)image) + 1)),

(*(((const uint8_t *)image) + 2)));

fprintf(stdout, "expected *image = 0x%02" PRIx32 "%02" PRIx32 "\n", (uint32_t)idx & 0xFF,

(((uint32_t)idx & 0xFF00) >> 8));

} /* end if */

assert((*((const char *)image)) == (char)(type & 0xFF));

assert((*(((const char *)image) + 1)) == (char)((idx & 0xFF00) >> 8));

assert((*(((const char *)image) + 2)) == (char)(idx & 0xFF));

} /* end else */

} /* end if */

entry->deserialized = true;

entry->header.is_dirty = false;

entry->is_dirty = false;

(entry->deserializes)++;

return ((void *)entry);

} /* deserialize() */

void *

pico_deserialize(const void *image, size_t len, void *udata, bool *dirty)

{

return deserialize(image, len, udata, dirty, PICO_ENTRY_TYPE);

}

void *

nano_deserialize(const void *image, size_t len, void *udata, bool *dirty)

{

return deserialize(image, len, udata, dirty, NANO_ENTRY_TYPE);

}

void *

micro_deserialize(const void *image, size_t len, void *udata, bool *dirty)

{

return deserialize(image, len, udata, dirty, MICRO_ENTRY_TYPE);

}

void *

tiny_deserialize(const void *image, size_t len, void *udata, bool *dirty)

{

return deserialize(image, len, udata, dirty, TINY_ENTRY_TYPE);

}

void *

small_deserialize(const void *image, size_t len, void *udata, bool *dirty)

{

return deserialize(image, len, udata, dirty, SMALL_ENTRY_TYPE);

}

void *

medium_deserialize(const void *image, size_t len, void *udata, bool *dirty)

{

return deserialize(image, len, udata, dirty, MEDIUM_ENTRY_TYPE);

}

void *

large_deserialize(const void *image, size_t len, void *udata, bool *dirty)

{

return deserialize(image, len, udata, dirty, LARGE_ENTRY_TYPE);

}

void *

huge_deserialize(const void *image, size_t len, void *udata, bool *dirty)

{

return deserialize(image, len, udata, dirty, HUGE_ENTRY_TYPE);

}

void *

monster_deserialize(const void *image, size_t len, void *udata, bool *dirty)

{

return deserialize(image, len, udata, dirty, MONSTER_ENTRY_TYPE);

}

void *

variable_deserialize(const void *image, size_t len, void *udata, bool *dirty)

{

return deserialize(image, len, udata, dirty, VARIABLE_ENTRY_TYPE);

}

void *

notify_deserialize(const void *image, size_t len, void *udata, bool *dirty)

{

return deserialize(image, len, udata, dirty, NOTIFY_ENTRY_TYPE);

}

image_len(const void *thing, size_t *image_length, int32_t H5_ATTR_NDEBUG_UNUSED entry_type)

{

const test_entry_t *entry;

int32_t type;

assert(thing);

assert(image_length);

entry = (const test_entry_t *)thing;

assert(entry->self == entry);

type = entry->type;

assert((type >= 0) && (type < NUMBER_OF_ENTRY_TYPES));

assert(type == entry_type);

assert((entry->index >= 0) && (entry->index <= max_indices[type]));

assert(entry == &(entries[type][entry->index]));

if (type != VARIABLE_ENTRY_TYPE)

assert(entry->size == entry_sizes[type]);

else {

assert(entry->size <= entry_sizes[type]);

assert(entry->size > 0);

} /* end else */

*image_length = entry->size;

return (SUCCEED);

} /* image_len() */

pico_image_len(const void *thing, size_t *image_length)

{

return image_len(thing, image_length, PICO_ENTRY_TYPE);

}

nano_image_len(const void *thing, size_t *image_length)

{

return image_len(thing, image_length, NANO_ENTRY_TYPE);

}

micro_image_len(const void *thing, size_t *image_length)

{

return image_len(thing, image_length, MICRO_ENTRY_TYPE);

}

tiny_image_len(const void *thing, size_t *image_length)

{

return image_len(thing, image_length, TINY_ENTRY_TYPE);

}

small_image_len(const void *thing, size_t *image_length)

{

return image_len(thing, image_length, SMALL_ENTRY_TYPE);

}

medium_image_len(const void *thing, size_t *image_length)

{

return image_len(thing, image_length, MEDIUM_ENTRY_TYPE);

}

large_image_len(const void *thing, size_t *image_length)

{

return image_len(thing, image_length, LARGE_ENTRY_TYPE);

}

huge_image_len(const void *thing, size_t *image_length)

{

return image_len(thing, image_length, HUGE_ENTRY_TYPE);

}

monster_image_len(const void *thing, size_t *image_length)

{

return image_len(thing, image_length, MONSTER_ENTRY_TYPE);

}

variable_image_len(const void *thing, size_t *image_length)

{

return image_len(thing, image_length, VARIABLE_ENTRY_TYPE);

}

notify_image_len(const void *thing, size_t *image_length)

{

return image_len(thing, image_length, NOTIFY_ENTRY_TYPE);

}

pre_serialize(H5F_t H5_ATTR_NDEBUG_UNUSED *f, void *thing, haddr_t H5_ATTR_NDEBUG_UNUSED addr,

size_t H5_ATTR_NDEBUG_UNUSED len, haddr_t *new_addr_ptr, size_t *new_len_ptr,

unsigned *flags_ptr)

{

test_entry_t *entry;

int32_t i;

assert(f);

assert(thing);

assert(flags_ptr);

*flags_ptr = H5C__SERIALIZE_NO_FLAGS_SET;

assert(new_addr_ptr);

assert(new_len_ptr);

entry = (test_entry_t *)thing;

assert(entry->self == entry);

assert(entry->addr == addr);

assert(entry->size == len);

/* shouldn't serialize the entry unless it is dirty */

assert(entry->is_dirty);

assert((entry->type >= 0) && (entry->type < NUMBER_OF_ENTRY_TYPES));

assert((entry->index >= 0) && (entry->index <= max_indices[entry->type]));

assert(entry == &(entries[entry->type][entry->index]));

assert(entry->num_flush_ops >= 0);

assert(entry->num_flush_ops < MAX_FLUSH_OPS);

if (entry->num_flush_ops > 0) {

for (i = 0; i < entry->num_flush_ops; i++) {

assert(entry->file_ptr);

execute_flush_op(entry->file_ptr, entry, &((entry->flush_ops)[i]), flags_ptr);

} /* end for */

entry->num_flush_ops = 0;

entry->flush_op_self_resize_in_progress = false;

/* This looks wrong, but it isn't -- *flags_ptr will be modified

if (pass && (((*flags_ptr) & H5C__SERIALIZE_RESIZED_FLAG) != 0)) {

/* set *new_len_ptr to the new length. */

assert(entry->type == VARIABLE_ENTRY_TYPE);

assert(entry->size > 0);

assert(entry->size <= VARIABLE_ENTRY_SIZE);

*new_len_ptr = entry->size;

} /* end if */

if (((*flags_ptr) & H5C__SERIALIZE_MOVED_FLAG) != 0) {

assert(((*flags_ptr) | H5C__SERIALIZE_RESIZED_FLAG) != 0);

/* place the new address in *new_addr */

*new_addr_ptr = entry->addr;

} /* end if */

} /* end if */

return (SUCCEED);

} /* pre_serialize() */

pico_pre_serialize(H5F_t *f, void *thing, haddr_t addr, size_t len, haddr_t *new_addr_ptr,

size_t *new_len_ptr, unsigned *flags_ptr)

{

return pre_serialize(f, thing, addr, len, new_addr_ptr, new_len_ptr, flags_ptr);

}

nano_pre_serialize(H5F_t *f, void *thing, haddr_t addr, size_t len, haddr_t *new_addr_ptr,

size_t *new_len_ptr, unsigned *flags_ptr)

{

return pre_serialize(f, thing, addr, len, new_addr_ptr, new_len_ptr, flags_ptr);

}