futriix/test/hbw_verify_function_test.cpp

/*
 * Copyright (C) 2016 - 2018 Intel Corporation.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * 1. Redistributions of source code must retain the above copyright notice(s),
 *    this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice(s),
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
 * EVENT SHALL THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "memkind.h"
#include "memkind/internal/memkind_hbw.h"
#include "allocator_perf_tool/HugePageOrganizer.hpp"
#include "hbwmalloc.h"
#include "common.h"

#include <sys/mman.h>
#include <numaif.h>
#include <numa.h>
#include <stdint.h>

#define SHIFT_BYTES(ptr, bytes) ((char*)(ptr)+(bytes))

/*
 * Set of tests for hbw_verify_memory_region() function,
 * which intend to check if allocated memory fully fall into high bandwidth memory.
 * Note: in this tests we are using internal function memkind_hbw_all_get_mbind_nodemask().
 * In future we intend to rewrite this function when we will have replacement in new API.
 */
class HbwVerifyFunctionTest: public :: testing::Test
{
protected:
    const size_t BLOCK_SIZE = 64;
    const size_t page_size = sysconf(_SC_PAGESIZE);
    const int flags = MAP_ANONYMOUS | MAP_PRIVATE;
};

/*
 * Group of basic tests for different sizes of allocations
 */
TEST_F(HbwVerifyFunctionTest, test_TC_MEMKIND_HBW_page_size_not_round)
{
    size_t size = page_size * 1024 + 5;
    char *ptr = (char *) hbw_malloc(size);
    ASSERT_FALSE(ptr == NULL);
    EXPECT_EQ(hbw_verify_memory_region(ptr, size, HBW_TOUCH_PAGES), 0);
    hbw_free(ptr);
}

TEST_F(HbwVerifyFunctionTest, test_TC_MEMKIND_HBW_page_size_round)
{
    size_t size = page_size * 1024;
    char *ptr = (char *) hbw_malloc(size);
    ASSERT_FALSE(ptr == NULL);
    EXPECT_EQ(hbw_verify_memory_region(ptr, size, HBW_TOUCH_PAGES), 0);
    hbw_free(ptr);
}

TEST_F(HbwVerifyFunctionTest, test_TC_MEMKIND_HBW_iterate_1_byte_to_8194_bytes)
{
    for (size_t size = 1; size <= (page_size * 2 + 2);
         size++) { //iterate through 2 pages and 2 bytes
        char *ptr = (char *) hbw_malloc(size);
        ASSERT_FALSE(ptr == NULL);
        EXPECT_EQ(hbw_verify_memory_region(ptr, size, HBW_TOUCH_PAGES), 0);
        hbw_free(ptr);
    }
}

TEST_F(HbwVerifyFunctionTest, test_TC_MEMKIND_HBW_ext_5GB)
{
    size_t size = 5ull*(1<<30); //5GB - big allocation
    char *ptr = (char *) hbw_malloc(size);
    ASSERT_FALSE(ptr == NULL);
    EXPECT_EQ(hbw_verify_memory_region(ptr, size, HBW_TOUCH_PAGES), 0);
    hbw_free(ptr);
}

/*
 * Test setting memory without HBW_TOUCH_PAGES flag
 */
TEST_F(HbwVerifyFunctionTest, test_TC_MEMKIND_HBW_setting_memory_without_flag)
{
    size_t size = page_size;
    char *ptr = (char *) hbw_malloc(size);
    ASSERT_FALSE(ptr == NULL);
    memset(ptr, '.', size);
    EXPECT_EQ(hbw_verify_memory_region(ptr, size, 0), 0);
    for (size_t i = 0; i < size; i++) { //check that content is unchanged
        EXPECT_TRUE(ptr[i] == '.');
    }
    hbw_free(ptr);
}

/*
 * Test HBW_TOUCH_PAGES flag
 */
TEST_F(HbwVerifyFunctionTest,
       test_TC_MEMKIND_HBW_TOUCH_PAGES_check_overwritten_content)
{
    size_t size = 5 * page_size;
    char *ptr = (char *) hbw_malloc(size);
    ASSERT_FALSE(ptr == NULL);
    memset(ptr, '.', size);
    EXPECT_EQ(hbw_verify_memory_region(ptr, size, HBW_TOUCH_PAGES), 0);
    for (size_t i = 0; i < size;
         i++) { //check that content of all pages doesn't change
        EXPECT_TRUE(ptr[i] == '.');
    }
    hbw_free(ptr);
}

/*
 * Tests check if number of 64-page blocks are working correctly
 */
TEST_F(HbwVerifyFunctionTest, test_TC_MEMKIND_HBW_many_blocks_round)
{
    size_t size = 16 * (BLOCK_SIZE * page_size); //exactly 16 * 64-page blocks
    char *ptr = (char *) hbw_malloc(size);
    ASSERT_FALSE(ptr == NULL);
    EXPECT_EQ(hbw_verify_memory_region(ptr, size, HBW_TOUCH_PAGES), 0);
    hbw_free(ptr);
}

TEST_F(HbwVerifyFunctionTest, test_TC_MEMKIND_HBW_many_blocks_not_round)
{
    size_t size = (16 * BLOCK_SIZE * page_size) + (8 *
                                                   page_size); //16 * 64-page blocks and 1 * 8-paged block
    char *ptr = (char *) hbw_malloc(size);
    ASSERT_FALSE(ptr == NULL);
    EXPECT_EQ(hbw_verify_memory_region(ptr, size, HBW_TOUCH_PAGES), 0);
    hbw_free(ptr);
}

/*
 * Check if 2 blocks and parts of the third block are working correctly.
 * With this test we can be sure that different sizes of allocation (not only whole blocks) are ok.
 */
TEST_F(HbwVerifyFunctionTest, test_TC_MEMKIND_HBW_iterate_not_round)
{
    for (size_t i = 1; i < BLOCK_SIZE; i++) {
        size_t size = (2 * BLOCK_SIZE * page_size) + (i *
                                                      page_size); // 2 * 64-paged blocks and iterate through whole 3rd 64-paged block
        char *ptr = (char *) hbw_malloc(size);
        ASSERT_FALSE(ptr == NULL);
        EXPECT_EQ(hbw_verify_memory_region(ptr, size, HBW_TOUCH_PAGES), 0);
        hbw_free(ptr);
    }
}

/*
 * Tests for other kinds and malloc
 */
TEST_F(HbwVerifyFunctionTest, test_TC_MEMKIND_2MBPages_HBW_HUGETLB)
{
    HugePageOrganizer huge_page_organizer(16);
    size_t size = 2 * 1024 * 1024 * 10; //10 * 2MB pages
    char *ptr = (char *) memkind_malloc(MEMKIND_HBW_HUGETLB, size);
    ASSERT_FALSE(ptr == NULL);
    EXPECT_EQ(hbw_verify_memory_region(ptr, size, HBW_TOUCH_PAGES), 0);
    memkind_free(MEMKIND_HBW_HUGETLB, ptr);
}

TEST_F(HbwVerifyFunctionTest, test_TC_MEMKIND_DEFAULT)
{
    size_t size = page_size * 1024;
    char *ptr = (char *) memkind_malloc(MEMKIND_DEFAULT, size);
    ASSERT_FALSE(ptr == NULL);
    EXPECT_EQ(hbw_verify_memory_region(ptr, size, HBW_TOUCH_PAGES), -1);
    memkind_free(MEMKIND_DEFAULT, ptr);
}

TEST_F(HbwVerifyFunctionTest, test_TC_MEMKIND_malloc)
{
    size_t size = page_size * 1024;
    char *ptr = (char *) malloc(size);
    ASSERT_FALSE(ptr == NULL);
    EXPECT_EQ(hbw_verify_memory_region(ptr, size, HBW_TOUCH_PAGES), -1);
    free(ptr);
}

/*
 * Group of negative tests
 */
TEST_F(HbwVerifyFunctionTest,
       test_TC_MEMKIND_Negative_size_0_and_SET_MEMORY_flag)
{
    void *ptr = hbw_malloc(page_size);
    ASSERT_FALSE(ptr == NULL);
    EXPECT_EQ(hbw_verify_memory_region(ptr, 0, HBW_TOUCH_PAGES), EINVAL);
    hbw_free(ptr);
}

TEST_F(HbwVerifyFunctionTest, test_TC_MEMKIND_Negative_size_0_without_flag)
{
    void *ptr = hbw_malloc(page_size);
    ASSERT_FALSE(ptr == NULL);
    EXPECT_EQ(hbw_verify_memory_region(ptr, 0, 0), EINVAL);
    hbw_free(ptr);
}

TEST_F(HbwVerifyFunctionTest,
       test_TC_MEMKIND_Negative_Uninitialized_Memory_without_flag)
{
    void *ptr = NULL;
    EXPECT_EQ(hbw_verify_memory_region(ptr, page_size * 1024, 0), EINVAL);
}

TEST_F(HbwVerifyFunctionTest,
       test_TC_MEMKIND_Negative_Uninitialized_Memory_and_SET_MEMORY_flag)
{
    void *ptr = NULL;
    EXPECT_EQ(hbw_verify_memory_region(ptr, page_size * 1024, HBW_TOUCH_PAGES),
              EINVAL);
}

TEST_F(HbwVerifyFunctionTest, test_TC_MEMKIND_Negative_Without_Memset)
{
    size_t size = page_size * 1024;
    void *ptr = hbw_malloc(size);
    ASSERT_FALSE(ptr == NULL);
    EXPECT_EQ(hbw_verify_memory_region(ptr, size, 0), -1);
    hbw_free(ptr);
}

/*
 * Corner cases: tests for half of pages
 * + HBM memory
 * # HBM memory and verified
 * - not HBM memory, but allocated
 * = not HBM memory and verified
 */

/* 3 pages:
 * |++##|####|##++|
 */
TEST_F(HbwVerifyFunctionTest, test_TC_MEMKIND_Half_Pages)
{
    size_t size = 3 * page_size;
    nodemask_t nodemask;
    struct bitmask hbw_nodemask = {NUMA_NUM_NODES, nodemask.n};
    //function memkind_hbw_all_get_mbind_nodemask() has to be rewritten, when we will have replacement in new API.
    memkind_hbw_all_get_mbind_nodemask(NULL, hbw_nodemask.maskp, hbw_nodemask.size);
    char *ptr = (char *) mmap(NULL, size, PROT_READ | PROT_WRITE, flags, -1, 0);
    ASSERT_FALSE(ptr == NULL);

    //all pages should fall on HBM
    mbind(ptr, size, MPOL_BIND, hbw_nodemask.maskp, NUMA_NUM_NODES, 0);

    //verified are: half of the first page, second page and half of the third page
    EXPECT_EQ(hbw_verify_memory_region(SHIFT_BYTES(ptr, page_size/2),
                                       size - page_size, HBW_TOUCH_PAGES), 0);
    EXPECT_EQ(munmap(ptr, size), 0);
}

/* 3 pages:
 * |####|####|----|
 * |++##|####|==--|
 */
TEST_F(HbwVerifyFunctionTest, test_TC_MEMKIND_Half_Pages_1_and_2_page)
{
    size_t size = 3 * page_size;
    nodemask_t nodemask;
    struct bitmask hbw_nodemask = {NUMA_NUM_NODES, nodemask.n};
    //function memkind_hbw_all_get_mbind_nodemask() has to be rewritten, when we will have replacement in new API.
    memkind_hbw_all_get_mbind_nodemask(NULL, hbw_nodemask.maskp, hbw_nodemask.size);
    char *ptr = (char *) mmap(NULL, size, PROT_READ | PROT_WRITE, flags, -1, 0);
    ASSERT_FALSE(ptr == NULL);

    //first and second page should fall on HBM
    mbind(ptr, size - page_size, MPOL_BIND, hbw_nodemask.maskp, NUMA_NUM_NODES, 0);

    //check if mbind is successful |####|####|----|
    EXPECT_EQ(hbw_verify_memory_region(ptr, size - page_size, HBW_TOUCH_PAGES), 0);

    //verified are: half of the first page, second page and half of the third page |++##|####|==--|
    EXPECT_EQ(hbw_verify_memory_region(SHIFT_BYTES(ptr, page_size/2),
                                       size - page_size, HBW_TOUCH_PAGES), -1);
    EXPECT_EQ(munmap(ptr, size), 0);
}

/* 3 pages:
 * |----|####|####|
 * |--==|####|##++|
 */
TEST_F(HbwVerifyFunctionTest, test_TC_MEMKIND_Half_Pages_2_and_3_page)
{
    size_t size = 3 * page_size;
    nodemask_t nodemask;
    struct bitmask hbw_nodemask = {NUMA_NUM_NODES, nodemask.n};
    //function memkind_hbw_all_get_mbind_nodemask() has to be rewritten, when we will have replacement in new API.
    memkind_hbw_all_get_mbind_nodemask(NULL, hbw_nodemask.maskp, hbw_nodemask.size);
    char *ptr = (char *) mmap(NULL, size, PROT_READ | PROT_WRITE, flags, -1, 0);
    ASSERT_FALSE(ptr == NULL);

    //second and third page should fall on HBM
    mbind(SHIFT_BYTES(ptr, page_size), size - page_size, MPOL_BIND,
          hbw_nodemask.maskp, NUMA_NUM_NODES, 0);

    //check if mbind is successful |----|####|####|
    EXPECT_EQ(hbw_verify_memory_region(SHIFT_BYTES(ptr, page_size),
                                       size - page_size, HBW_TOUCH_PAGES), 0);

    //verified are: half of the first page, second page and half of the third page
    EXPECT_EQ(hbw_verify_memory_region(SHIFT_BYTES(ptr, page_size/2),
                                       size - page_size, HBW_TOUCH_PAGES), -1);
    EXPECT_EQ(munmap(ptr, size), 0);
}

/* 3 pages:
 * |####|----|++++| and  |++++|----|####|
 * |++##|====|##++|
 */
TEST_F(HbwVerifyFunctionTest, test_TC_MEMKIND_Half_Pages_1_and_3_page)
{
    size_t size = 3 * page_size;
    nodemask_t nodemask;
    struct bitmask hbw_nodemask = {NUMA_NUM_NODES, nodemask.n};
    //function memkind_hbw_all_get_mbind_nodemask() has to be rewritten, when we will have replacement in new API.
    memkind_hbw_all_get_mbind_nodemask(NULL, hbw_nodemask.maskp, hbw_nodemask.size);
    char *ptr = (char *) mmap(NULL, size, PROT_READ | PROT_WRITE, flags, -1, 0);
    ASSERT_FALSE(ptr == NULL);

    //first and third page should fall on HBM
    mbind(ptr, page_size, MPOL_BIND, hbw_nodemask.maskp, NUMA_NUM_NODES, 0);
    mbind(SHIFT_BYTES(ptr, 2 * page_size), page_size, MPOL_BIND, hbw_nodemask.maskp,
          NUMA_NUM_NODES, 0);

    //check if mbind is successful |####|----|++++| and  |++++|----|####|
    EXPECT_EQ(hbw_verify_memory_region(ptr, size - 2*page_size, HBW_TOUCH_PAGES),
              0);
    EXPECT_EQ(hbw_verify_memory_region(SHIFT_BYTES(ptr, 2*page_size),
                                       size - 2*page_size, HBW_TOUCH_PAGES), 0);

    //verified are: half of the first page, second page and half of the third page
    EXPECT_EQ(hbw_verify_memory_region(SHIFT_BYTES(ptr, page_size/2),
                                       size - page_size, HBW_TOUCH_PAGES), -1);
    EXPECT_EQ(munmap(ptr, size), 0);
}

/* 5 pages:
 * |----|+###|####|###+|----|
 */
TEST_F(HbwVerifyFunctionTest, test_TC_MEMKIND_Boundaries_CornerCase)
{
    size_t size = 5 * page_size;
    nodemask_t nodemask;
    struct bitmask hbw_nodemask = {NUMA_NUM_NODES, nodemask.n};
    //function memkind_hbw_all_get_mbind_nodemask() has to be rewritten, when we will have replacement in new API.
    memkind_hbw_all_get_mbind_nodemask(NULL, hbw_nodemask.maskp, hbw_nodemask.size);
    char *ptr = (char *) mmap(NULL, size, PROT_READ | PROT_WRITE, flags, -1, 0);
    ASSERT_FALSE(ptr == NULL);

    size_t tested_pages_size = size - 2 * page_size;

    //second, third and fourth page should fall on HBM
    mbind(SHIFT_BYTES(ptr, page_size), tested_pages_size, MPOL_BIND,
          hbw_nodemask.maskp, NUMA_NUM_NODES, 0);

    //verified are: second byte of the second page to last byte -1 of fourth page
    EXPECT_EQ(hbw_verify_memory_region(SHIFT_BYTES(ptr, page_size + 1),
                                       tested_pages_size - 2, HBW_TOUCH_PAGES), 0);
    EXPECT_EQ(munmap(ptr, size), 0);
}

/* 5 pages:
 * |-###|####|####|####|###-|
 */
TEST_F(HbwVerifyFunctionTest, test_TC_MEMKIND_HBW_partial_verification)
{
    size_t size = 5 * page_size;

    //all pages should fall on HBM
    void *ptr = hbw_malloc(size);
    ASSERT_FALSE(ptr == NULL);

    //but only second byte of the first page to last byte -1 of the last page are touched
    memset(SHIFT_BYTES(ptr, 1), 0, size - 2);

    //verified are: second byte of the first page to last byte -1 of last page
    EXPECT_EQ(hbw_verify_memory_region(SHIFT_BYTES(ptr, 1), size - 2, 0), 0);
    hbw_free(ptr);
}