path: root/test/gheap.c

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * Copyright by The HDF Group.                                               *
 * Copyright by the Board of Trustees of the University of Illinois.         *
 * All rights reserved.                                                      *
 *                                                                           *
 * This file is part of HDF5.  The full HDF5 copyright notice, including     *
 * terms governing use, modification, and redistribution, is contained in    *
 * the COPYING file, which can be found at the root of the source code       *
 * distribution tree, or in https://support.hdfgroup.org/ftp/HDF5/releases.  *
 * If you do not have access to either file, you may request a copy from     *
 * help@hdfgroup.org.                                                        *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

/*
 * Programmer:  Robb Matzke <matzke@llnl.gov>
 *              Tuesday, March 31, 1998
 *
 * Purpose:     Tests the global heap.  The global heap is the set of all
 *              collections but the collections are not related to one
 *              another by anything that appears in the file format.
 */
#include "h5test.h"
#include "H5ACprivate.h"
#include "H5CXprivate.h"        /* API Contexts                         */
#include "H5Eprivate.h"
#include "H5Fprivate.h"
#include "H5Gprivate.h"
#include "H5HGprivate.h"
#include "H5Iprivate.h"
#include "H5Pprivate.h"

/* Macros for printing error messages in loops.  These print up to
 * GHEAP_REPEATED_ERR_LIM errors, and suppress the rest */
#define GHEAP_REPEATED_ERR_LIM 20

/* Number of heap objects to test */
#define GHEAP_TEST_NOBJS        1024

#define GHEAP_REPEATED_ERR(MSG)                                                \
{                                                                              \
    nerrors++;                                                                 \
    if(nerrors <= GHEAP_REPEATED_ERR_LIM) {                                    \
        H5_FAILED();                                                           \
        puts(MSG);                                                             \
        if(nerrors == GHEAP_REPEATED_ERR_LIM)                                  \
            puts("    Suppressing further errors...");                         \
    } /* end if */                                                             \
} /* end GHEAP_REPEATED_ERR */

const char *FILENAME[] = {
    "gheap1",
    "gheap2",
    "gheap3",
    "gheap4",
    "gheapooo",
    NULL
};


/*-------------------------------------------------------------------------
 * Function:    test_1
 *
 * Purpose:     Writes a sequence of objects to the global heap where each
 *              object is larger than the one before.
 *
 * Return:      Success:    0
 *
 *              Failure:    number of errors
 *
 * Programmer:    Robb Matzke
 *              Tuesday, March 31, 1998
 *
 *-------------------------------------------------------------------------
 */
static int
test_1 (hid_t fapl)
{
    hid_t       file = H5I_INVALID_HID;
    H5F_t       *f = NULL;
    H5HG_t      *obj = NULL;
    uint8_t     out[GHEAP_TEST_NOBJS];
    uint8_t     in[GHEAP_TEST_NOBJS];
    size_t      u;
    size_t      size;
    herr_t      status;
    int         nerrors = 0;
    char        filename[1024];

    TESTING("monotonically increasing lengths");

    /* Allocate buffer for H5HG_t */
    if(NULL == (obj = (H5HG_t *)HDmalloc(sizeof(H5HG_t) * GHEAP_TEST_NOBJS)))
        goto error;

    /* Open a clean file */
    h5_fixname(FILENAME[0], fapl, filename, sizeof filename);
    if((file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
        goto error;
    if(NULL == (f = (H5F_t *)H5I_object(file))) {
        H5_FAILED();
        HDputs("    Unable to create file");
        goto error;
    }

    /*
     * Write the objects, monotonically increasing in length.  Since this is
     * a clean file, the addresses allocated for the collections should also
     * be monotonically increasing.
     */
    for(u = 0; u < GHEAP_TEST_NOBJS; u++) {
        size = u + 1;
        HDmemset(out, (int)('A' + u % 26), size);
        H5Eclear2(H5E_DEFAULT);
        status = H5HG_insert(f, size, out, obj + u);
        if(status < 0) {
            H5_FAILED();
            HDputs("    Unable to insert object into global heap");
            nerrors++;
        }
        else if(u && H5F_addr_gt(obj[u - 1].addr, obj[u].addr)) {
            H5_FAILED();
            HDputs("    Collection addresses are not monotonically increasing");
            nerrors++;
        }
    }

    /*
     * Now try to read each object back.
     */
    for(u = 0; u < GHEAP_TEST_NOBJS; u++) {
        size = u + 1;
        HDmemset(out, (int)('A' + u % 26), size);
        H5Eclear2(H5E_DEFAULT);
        if(NULL == H5HG_read(f, obj + u, in, NULL)) {
            H5_FAILED();
            HDputs("    Unable to read object");
            nerrors++;
        }
        else if(HDmemcmp(in, out, size)) {
            H5_FAILED();
            HDputs("    Value read doesn't match value written");
            nerrors++;
        }
    }

    /* Release buffer */
    HDfree(obj);
    obj = NULL;

    if(H5Fclose(file) < 0)
        goto error;
    if(nerrors)
        goto error;

    PASSED();
    return 0;

error:
    H5E_BEGIN_TRY {
        H5Fclose(file);
    } H5E_END_TRY;
    if(obj)
        HDfree(obj);
    return MAX(1, nerrors);
}


/*-------------------------------------------------------------------------
 * Function:    test_2
 *
 * Purpose:     Writes a sequence of objects to the global heap where each
 *              object is smaller than the one before.
 *
 * Return:      Success:    0
 *
 *              Failure:     number of errors
 *
 * Programmer:  Robb Matzke
 *              Tuesday, March 31, 1998
 *
 *-------------------------------------------------------------------------
 */
static int
test_2 (hid_t fapl)
{
    hid_t       file = H5I_INVALID_HID;
    H5F_t       *f = NULL;
    H5HG_t      *obj = NULL;
    uint8_t     out[GHEAP_TEST_NOBJS];
    uint8_t     in[GHEAP_TEST_NOBJS];
    size_t      u;
    size_t      size;
    int         nerrors = 0;
    char        filename[1024];

    TESTING("monotonically decreasing lengths");

    /* Allocate buffer for H5HG_t */
    if(NULL == (obj = (H5HG_t *)HDmalloc(sizeof(H5HG_t) * GHEAP_TEST_NOBJS)))
        goto error;

    /* Open a clean file */
    h5_fixname(FILENAME[1], fapl, filename, sizeof filename);
    if((file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
        goto error;
    if(NULL == (f = (H5F_t *)H5I_object(file))) {
        H5_FAILED();
        HDputs("    Unable to create file");
        goto error;
    }

    /*
     * Write the objects, monotonically decreasing in length.
     */
    for(u = 0; u < GHEAP_TEST_NOBJS; u++) {
        size = GHEAP_TEST_NOBJS - u;
        HDmemset(out, (int)('A' + u % 26), size);
        H5Eclear2(H5E_DEFAULT);
        if(H5HG_insert(f, size, out, obj + u) < 0) {
            H5_FAILED();
            HDputs("    Unable to insert object into global heap");
            nerrors++;
        }
    }

    /*
     * Now try to read each object back.
     */
    for(u = 0; u < GHEAP_TEST_NOBJS; u++) {
        size = GHEAP_TEST_NOBJS - u;
        HDmemset(out, (int)('A' + u % 26), size);
        H5Eclear2(H5E_DEFAULT);
        if(NULL == H5HG_read(f, obj + u, in, NULL)) {
            H5_FAILED();
            HDputs("    Unable to read object");
            nerrors++;
        }
        else if (memcmp (in, out, size)) {
            H5_FAILED();
            HDputs("    Value read doesn't match value written");
            nerrors++;
        }
    }

    /* Release buffer */
    HDfree(obj);
    obj = NULL;

    if(H5Fclose(file) < 0)
        goto error;
    if(nerrors)
        goto error;

    PASSED();
    return 0;

 error:
    H5E_BEGIN_TRY {
        H5Fclose(file);
    } H5E_END_TRY;
    if(obj)
        HDfree(obj);
    return MAX(1, nerrors);
}


/*-------------------------------------------------------------------------
 * Function:    test_3
 *
 * Purpose:     Creates a few global heap objects and then removes them all.
 *              The collection should also be removed.
 *
 * Return:      Success:    0
 *
 *              Failure:    number of errors
 *
 * Programmer:    Robb Matzke
 *              Tuesday, March 31, 1998
 *
 *-------------------------------------------------------------------------
 */
static int
test_3 (hid_t fapl)
{
    hid_t       file = H5I_INVALID_HID;
    H5F_t       *f = NULL;
    H5HG_t      *obj = NULL;
    uint8_t     out[GHEAP_TEST_NOBJS];
    size_t      u;
    size_t      size;
    herr_t      status;
    int         nerrors = 0;
    char        filename[1024];

    TESTING("complete object removal");

    /* Allocate buffer for H5HG_t */
    if(NULL == (obj = (H5HG_t *)HDmalloc(sizeof(H5HG_t) * GHEAP_TEST_NOBJS)))
        goto error;

    /* Open a clean file */
    h5_fixname(FILENAME[2], fapl, filename, sizeof filename);
    if((file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
        goto error;
    if(NULL == (f = (H5F_t *)H5I_object(file))) {
        H5_FAILED();
        HDputs("    Unable to create file");
        goto error;
    }

    /* Create some stuff */
    for(u = 0; u < GHEAP_TEST_NOBJS; u++) {
        size = u % 30 + 100;
        HDmemset(out, (int)('A' + u % 26), size);
        H5Eclear2(H5E_DEFAULT);
        status = H5HG_insert(f, size, out, obj + u);
        if (status<0) {
            H5_FAILED();
            HDputs("    Unable to insert object into global heap");
            nerrors++;
        }
    }

    /* Remove everything */
    for(u = 0; u < GHEAP_TEST_NOBJS; u++) {
        status = H5HG_remove(f, obj + u);
        if (status<0) {
            H5_FAILED();
            HDputs("    Unable to remove object");
            nerrors++;
        }
    }

    /* Release buffer */
    HDfree(obj);
    obj = NULL;

    if(H5Fclose(file) < 0)
        goto error;
    if(nerrors)
        goto error;

    PASSED();
    return 0;

 error:
    H5E_BEGIN_TRY {
        H5Fclose(file);
    } H5E_END_TRY;
    if(obj)
        HDfree(obj);
    return MAX(1, nerrors);
}


/*-------------------------------------------------------------------------
 * Function:    test_4
 *
 * Purpose:     Tests the H5HG_remove() feature by writing lots of objects
 *              and occassionally removing some.  When we're done they're all
 *              removed.
 *
 * Return:      Success:    0
 *
 *              Failure:    number of errors
 *
 * Programmer:    Robb Matzke
 *              Tuesday, March 31, 1998
 *
 *-------------------------------------------------------------------------
 */
static int
test_4 (hid_t fapl)
{
    hid_t       file = H5I_INVALID_HID;
    H5F_t       *f = NULL;
    H5HG_t      *obj = NULL;
    uint8_t     out[GHEAP_TEST_NOBJS];
    size_t      u;
    size_t      size;
    herr_t      status;
    int         nerrors = 0;
    char        filename[1024];

    TESTING("partial object removal");

    /* Allocate buffer for H5HG_t */
    if(NULL == (obj = (H5HG_t *)HDmalloc(sizeof(H5HG_t) * GHEAP_TEST_NOBJS)))
        goto error;

    /* Open a clean file */
    h5_fixname(FILENAME[3], fapl, filename, sizeof filename);
    if((file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
        goto error;
    if(NULL == (f = (H5F_t *)H5I_object(file))) {
        H5_FAILED();
        HDputs("    Unable to create file");
        goto error;
    }

    for(u = 0; u < GHEAP_TEST_NOBJS; u++) {
        /* Insert */
        size = u % 30 + 100;
        HDmemset(out, (int)('A' + u % 26), size);
        H5Eclear2(H5E_DEFAULT);
        status = H5HG_insert(f, size, out, obj + u);
        if (status<0) {
            H5_FAILED();
            HDputs("    Unable to insert object into global heap");
            nerrors++;
        }

        /* Remove every third one beginning with the second, but after the
         * next one has already been inserted.  That is, insert A, B, C;
         * remove B, insert D, E, F; remove E; etc.
         */
        if(1 == (u % 3)) {
            H5Eclear2(H5E_DEFAULT);
            status = H5HG_remove(f, obj + u - 1);
            if (status<0) {
                H5_FAILED();
                HDputs("    Unable to remove object");
                nerrors++;
            }
            HDmemset(obj + u - 1, 0, sizeof *obj);
        }
    }

    /* Release buffer */
    HDfree(obj);
    obj = NULL;

    if(H5Fclose(file) < 0)
        goto error;
    if(nerrors)
        goto error;

    PASSED();
    return 0;

 error:
    H5E_BEGIN_TRY {
        H5Fclose(file);
    } H5E_END_TRY;
    if(obj)
        HDfree(obj);
    return MAX(1, nerrors);
}


/*-------------------------------------------------------------------------
 * Function:    test_ooo_indices
 *
 * Purpose:     Tests that indices can be stored out of order.  This can
 *              happen when the indices "wrap around" due to many
 *              insertions and deletions (for example, from rewriting a
 *              VL dataset).
 *
 * Return:      Success:    0
 *
 *              Failure:    number of errors
 *
 * Programmer:    Neil Fortner
 *              Monday, October 26, 2009
 *
 *-------------------------------------------------------------------------
 */
static int
test_ooo_indices(hid_t fapl)
{
    hid_t       file = H5I_INVALID_HID;
    H5F_t       *f = NULL;
    unsigned    i, j;
    H5HG_t      *obj = NULL;
    herr_t      status;
    int         nerrors = 0;
    char        filename[1024];

    TESTING("out of order indices");

    if(NULL == (obj = (H5HG_t *)HDmalloc(2000 * sizeof(*obj))))
        goto error;

    /* Open a clean file */
    h5_fixname(FILENAME[4], fapl, filename, sizeof filename);
    if((file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
        goto error;
    if(NULL == (f = (H5F_t *)H5I_object(file))) {
        H5_FAILED();
        HDputs("    Unable to create file");
        goto error;
    }

    /* Alternately insert 1000 entries and remove the previous group of 1000
     * entries, until the indices wrap around.
     */
    for(i = 0; i < 66; i++) {
        /* Insert 1000 entries.  The index into the obj array will alternate up
         * and down by 1000 so the previous set of insertions is preserved and
         * can be deleted.
         */
        for(j=1000*((~i&1)); j<1000*((~i&1)+1); j++) {
            H5Eclear2(H5E_DEFAULT);
            status = H5HG_insert(f, sizeof(j), &j, &obj[j]);
            if (status<0)
                GHEAP_REPEATED_ERR("    Unable to insert object into global heap")

            /* Check that the index is as expected */
            if(obj[j].idx != ((1000 * i) + j - (1000 * ((~i & 1)))) % ((1u << 16) - 1) + 1)
                GHEAP_REPEATED_ERR("    Unexpected global heap index");
        }

        /* Remove the previous 1000 entries */
        if(i>0)
            for(j=1000*(i&1); j<1000*((i&1)+1); j++) {
                H5Eclear2(H5E_DEFAULT);
                status = H5HG_remove(f, &obj[j]);
                if (status<0)
                    GHEAP_REPEATED_ERR("    Unable to remove object from global heap");
            }
    }

    /* The indices should have "wrapped around" on the last iteration */
    HDassert(obj[534].idx == 65535);
    HDassert(obj[535].idx == 1);

    /* Reopen the file */
    if (H5Fclose(file) < 0)
        goto error;
    if((file = H5Fopen(filename, H5F_ACC_RDWR, fapl)) < 0)
        goto error;
    if(NULL == (f = (H5F_t *)H5I_object(file))) {
        H5_FAILED();
        HDputs("    Unable to open file");
        goto error;
    } /* end if */

    /* Read the objects to make sure the heap is still readable */
    for(i=0; i<1000; i++) {
        if(NULL == H5HG_read(f, &obj[i], &j, NULL))
            goto error;
        if(i != j) {
            H5_FAILED();
            HDputs("    Incorrect read value");
            goto error;
        }
    }

    if(H5Fclose(file) < 0)
        goto error;
    if(nerrors)
        goto error;
    HDfree(obj);
    obj = NULL;

    PASSED();
    return 0;

 error:
    H5E_BEGIN_TRY {
        H5Fclose(file);
    } H5E_END_TRY;
    if(obj)
        HDfree(obj);
    return MAX(1, nerrors);
} /* end test_ooo_indices */


/*-------------------------------------------------------------------------
 * Function:	main
 *
 * Purpose:     Tests global heap.
 *
 * Return:      EXIT_SUCCESS/EXIT_FAILURE
 *
 *-------------------------------------------------------------------------
 */
int
main (void)
{
    int         nerrors = 0;
    hid_t       fapl_id = H5I_INVALID_HID;
    hbool_t     api_ctx_pushed = FALSE;             /* Whether API context pushed */

    h5_reset();
    if ((fapl_id = h5_fileaccess()) < 0)
        goto error;

    /* Push API context */
    if(H5CX_push() < 0) FAIL_STACK_ERROR
    api_ctx_pushed = TRUE;

    nerrors += test_1(fapl_id);
    nerrors += test_2(fapl_id);
    nerrors += test_3(fapl_id);
    nerrors += test_4(fapl_id);
    nerrors += test_ooo_indices(fapl_id);

    /* Verify symbol table messages are cached */
    nerrors += (h5_verify_cached_stabs(FILENAME, fapl_id) < 0 ? 1 : 0);

    if (nerrors)
        goto error;

    HDputs("All global heap tests passed.");

    /* Pop API context */
    if(api_ctx_pushed && H5CX_pop() < 0) FAIL_STACK_ERROR
    api_ctx_pushed = FALSE;

    h5_cleanup(FILENAME, fapl_id);
    HDexit(EXIT_SUCCESS);

 error:
    H5E_BEGIN_TRY {
        H5Pclose(fapl_id);
    } H5E_END_TRY;

    if(api_ctx_pushed) H5CX_pop();

    HDputs("*** TESTS FAILED ***");
    HDexit(EXIT_FAILURE);
} /* end main() */