/*
* Copyright (C) 2014 - 2019 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 <fstream>
#include <algorithm>
#include <numa.h>
#include <errno.h>
#include <limits.h>
#include <sys/sysinfo.h>
#include "common.h"
#include "check.h"
#include "omp.h"
#include "trial_generator.h"
#include "allocator_perf_tool/HugePageOrganizer.hpp"
/* Set of negative test cases for memkind, its main goal are to verify that the
* library behaves accordingly to documentation when calling an API with
* invalid inputs, incorrect usage, NULL pointers.
*/
class NegativeTest: public ::testing::Test
{};
class NegativeTestHuge: public ::testing::Test
{
private:
//Enable huge pages to avoid false positive test result.
HugePageOrganizer huge_page_organizer = HugePageOrganizer(8);
};
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_create_kind_zero_memtype)
{
memkind_t kind;
int ret = memkind_create_kind(
memkind_memtype_t(), //Set incorrect value.
MEMKIND_POLICY_PREFERRED_LOCAL,
memkind_bits_t(),
&kind);
ASSERT_EQ(ret, MEMKIND_ERROR_INVALID);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_create_kind_incorrect_memtype)
{
memkind_memtype_t memtype_flags;
//Set incorrect value.
memset(&memtype_flags, -1, sizeof(memtype_flags));
memkind_t kind;
int ret = memkind_create_kind(
memtype_flags,
MEMKIND_POLICY_PREFERRED_LOCAL,
memkind_bits_t(),
&kind);
ASSERT_EQ(ret, MEMKIND_ERROR_INVALID);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_create_kind_incorrect_policy)
{
memkind_policy_t policy;
//Set incorrect value.
memset(&policy, -1, sizeof(policy));
memkind_t kind;
int ret = memkind_create_kind(
MEMKIND_MEMTYPE_DEFAULT,
policy,
memkind_bits_t(),
&kind);
ASSERT_EQ(ret, MEMKIND_ERROR_INVALID);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_create_kind_incorrect_mask)
{
memkind_bits_t flags;
//Set incorrect value.
memset(&flags, 255, sizeof(flags));
memkind_t kind;
int ret = memkind_create_kind(
MEMKIND_MEMTYPE_DEFAULT,
MEMKIND_POLICY_PREFERRED_LOCAL,
flags,
&kind);
ASSERT_EQ(ret, MEMKIND_ERROR_INVALID);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_create_kind_DEFAULT_BIND_LOCAL)
{
memkind_t kind;
int ret = memkind_create_kind(
MEMKIND_MEMTYPE_DEFAULT,
MEMKIND_POLICY_BIND_LOCAL,
memkind_bits_t(),
&kind);
ASSERT_EQ(ret, MEMKIND_ERROR_INVALID);
}
TEST_F(NegativeTest,
test_TC_MEMKIND_Negative_create_kind_DEFAULT_BIND_LOCAL_PAGE_SIZE_2MB)
{
memkind_t kind;
int ret = memkind_create_kind(
MEMKIND_MEMTYPE_DEFAULT,
MEMKIND_POLICY_BIND_LOCAL,
MEMKIND_MASK_PAGE_SIZE_2MB,
&kind);
ASSERT_EQ(ret, MEMKIND_ERROR_INVALID);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_create_kind_DEFAULT_BIND_ALL)
{
memkind_t kind;
int ret = memkind_create_kind(
MEMKIND_MEMTYPE_DEFAULT,
MEMKIND_POLICY_BIND_ALL,
memkind_bits_t(),
&kind);
ASSERT_EQ(ret, MEMKIND_ERROR_INVALID);
}
TEST_F(NegativeTest,
test_TC_MEMKIND_Negative_create_kind_DEFAULT_BIND_ALL_PAGE_SIZE_2MB)
{
memkind_t kind;
int ret = memkind_create_kind(
MEMKIND_MEMTYPE_DEFAULT,
MEMKIND_POLICY_BIND_ALL,
MEMKIND_MASK_PAGE_SIZE_2MB,
&kind);
ASSERT_EQ(ret, MEMKIND_ERROR_INVALID);
}
TEST_F(NegativeTest,
test_TC_MEMKIND_Negative_create_kind_DEFAULT_INTERLEAVE_LOCAL)
{
memkind_t kind;
int ret = memkind_create_kind(
MEMKIND_MEMTYPE_DEFAULT,
MEMKIND_POLICY_INTERLEAVE_LOCAL,
memkind_bits_t(),
&kind);
ASSERT_EQ(ret, MEMKIND_ERROR_INVALID);
}
TEST_F(NegativeTest,
test_TC_MEMKIND_Negative_create_kind_DEFAULT_INTERLEAVE_LOCAL_PAGE_SIZE_2MB)
{
memkind_t kind;
int ret = memkind_create_kind(
MEMKIND_MEMTYPE_DEFAULT,
MEMKIND_POLICY_INTERLEAVE_LOCAL,
MEMKIND_MASK_PAGE_SIZE_2MB,
&kind);
ASSERT_EQ(ret, MEMKIND_ERROR_INVALID);
}
TEST_F(NegativeTest,
test_TC_MEMKIND_Negative_create_kind_DEFAULT_INTERLEAVE_ALL)
{
memkind_t kind;
int ret = memkind_create_kind(
MEMKIND_MEMTYPE_DEFAULT,
MEMKIND_POLICY_INTERLEAVE_ALL,
memkind_bits_t(),
&kind);
ASSERT_EQ(ret, MEMKIND_ERROR_INVALID);
}
TEST_F(NegativeTest,
test_TC_MEMKIND_Negative_create_kind_DEFAULT_INTERLEAVE_ALL_PAGE_SIZE_2MB)
{
memkind_t kind;
int ret = memkind_create_kind(
MEMKIND_MEMTYPE_DEFAULT,
MEMKIND_POLICY_INTERLEAVE_ALL,
MEMKIND_MASK_PAGE_SIZE_2MB,
&kind);
ASSERT_EQ(ret, MEMKIND_ERROR_INVALID);
}
TEST_F(NegativeTest,
test_TC_MEMKIND_Negative_create_kind_HIGH_BANDWIDTH_INTERLEAVE_LOCAL)
{
memkind_t kind;
int ret = memkind_create_kind(
MEMKIND_MEMTYPE_HIGH_BANDWIDTH,
MEMKIND_POLICY_INTERLEAVE_LOCAL,
memkind_bits_t(),
&kind);
ASSERT_EQ(ret, MEMKIND_ERROR_INVALID);
}
TEST_F(NegativeTest,
test_TC_MEMKIND_Negative_create_kind_HIGH_BANDWIDTH_INTERLEAVE_LOCAL_PAGE_SIZE_2MB)
{
memkind_t kind;
int ret = memkind_create_kind(
MEMKIND_MEMTYPE_HIGH_BANDWIDTH,
MEMKIND_POLICY_INTERLEAVE_LOCAL,
MEMKIND_MASK_PAGE_SIZE_2MB,
&kind);
ASSERT_EQ(ret, MEMKIND_ERROR_INVALID);
}
TEST_F(NegativeTest,
test_TC_MEMKIND_Negative_create_kind_HIGH_BANDWIDTH_INTERLEAVE_ALL_PAGE_SIZE_2MB)
{
memkind_t kind;
int ret = memkind_create_kind(
MEMKIND_MEMTYPE_HIGH_BANDWIDTH,
MEMKIND_POLICY_INTERLEAVE_ALL,
MEMKIND_MASK_PAGE_SIZE_2MB,
&kind);
ASSERT_EQ(ret, MEMKIND_ERROR_INVALID);
}
TEST_F(NegativeTest,
test_TC_MEMKIND_Negative_create_kind_DEFAULT_HIGH_BANDWIDTH_BIND_ALL)
{
memkind_t kind;
int flags_tmp = MEMKIND_MEMTYPE_DEFAULT | MEMKIND_MEMTYPE_HIGH_BANDWIDTH;
memkind_memtype_t memtype_flags;
memcpy(&memtype_flags, &flags_tmp, sizeof(memtype_flags));
int ret = memkind_create_kind(
memtype_flags,
MEMKIND_POLICY_BIND_ALL,
memkind_bits_t(),
&kind);
ASSERT_EQ(ret, MEMKIND_ERROR_INVALID);
}
TEST_F(NegativeTest,
test_TC_MEMKIND_Negative_create_kind_DEFAULT_HIGH_BANDWIDTH_INTERLEAVE_ALL_PAGE_SIZE_2MB)
{
memkind_t kind;
int flags_tmp = MEMKIND_MEMTYPE_DEFAULT | MEMKIND_MEMTYPE_HIGH_BANDWIDTH;
memkind_memtype_t memtype_flags;
memcpy(&memtype_flags, &flags_tmp, sizeof(memtype_flags));
int ret = memkind_create_kind(
memtype_flags,
MEMKIND_POLICY_INTERLEAVE_ALL,
MEMKIND_MASK_PAGE_SIZE_2MB,
&kind);
ASSERT_EQ(ret, MEMKIND_ERROR_INVALID);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_ErrorMemAlign)
{
int ret = 0;
void *ptr = NULL;
int err = EINVAL;
errno = 0;
ret = memkind_posix_memalign(MEMKIND_DEFAULT,
&ptr,
5,
100);
EXPECT_EQ(err, ret);
EXPECT_EQ(errno, 0);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_DefaultSizeZero)
{
int ret = 0;
void *ptr = NULL;
int err = 0;
errno = 0;
ret = memkind_posix_memalign(MEMKIND_DEFAULT,
&ptr,
16,
0);
EXPECT_EQ(err, ret);
EXPECT_EQ(errno, 0);
ASSERT_TRUE(ptr == NULL);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_ErrorAlignment)
{
int ret = 0;
void *ptr = NULL;
int err = EINVAL;
errno = 0;
ret = memkind_posix_memalign(MEMKIND_HBW,
&ptr,
5,
100);
EXPECT_EQ(err, ret);
EXPECT_EQ(errno, 0);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_HBWSizeZero)
{
int ret = 0;
void *ptr = NULL;
int err = 0;
errno = 0;
ret = memkind_posix_memalign(MEMKIND_HBW,
&ptr,
16,
0);
EXPECT_EQ(err, ret);
EXPECT_EQ(errno, 0);
ASSERT_TRUE(ptr == NULL);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_ErrorAllocM)
{
int ret = 0;
void *ptr = NULL;
int err = ENOMEM;
struct sysinfo info;
unsigned long long MemTotal = 0;
ret = sysinfo(&info);
EXPECT_EQ(ret, 0);
//Determine total memory size as totalram (total usable main memory size)
//multiplied by mem_unit (memory unit size in bytes). This value is equal
//to MemTotal field in /proc/meminfo.
MemTotal = info.totalram * info.mem_unit;
RecordProperty("MemTotal_kB", MemTotal/KB);
errno = 0;
ret = memkind_posix_memalign(MEMKIND_HBW,
&ptr,
16,
2*MemTotal);
EXPECT_EQ(err, ret);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_hbw_malloc_over_size)
{
void *ptr = hbw_malloc(SIZE_MAX);
ASSERT_TRUE(ptr == NULL);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_hbw_malloc_size_zero)
{
void *ptr = hbw_malloc(0);
ASSERT_TRUE(ptr == NULL);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_memkind_malloc_over_size)
{
void *ptr = memkind_malloc(MEMKIND_HBW, SIZE_MAX);
ASSERT_TRUE(ptr == NULL);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_memkind_malloc_size_zero)
{
void *ptr = memkind_malloc(MEMKIND_HBW, 0);
ASSERT_TRUE(ptr == NULL);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_hbw_calloc_over_size)
{
void *ptr = hbw_calloc(1, SIZE_MAX);
ASSERT_TRUE(ptr == NULL);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_hbw_calloc_size_zero)
{
void *ptr = hbw_calloc(1, 0);
ASSERT_TRUE(ptr == NULL);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_memkind_calloc_over_size)
{
void *ptr = memkind_calloc(MEMKIND_HBW, 1, SIZE_MAX);
ASSERT_TRUE(ptr == NULL);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_memkind_calloc_size_zero)
{
void *ptr = memkind_calloc(MEMKIND_HBW, 1, 0);
ASSERT_TRUE(ptr == NULL);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_hbw_realloc_over_size)
{
void *ptr = hbw_realloc(NULL, SIZE_MAX);
ASSERT_TRUE(ptr == NULL);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_memkind_realloc_over_size)
{
void *ptr = memkind_realloc(MEMKIND_HBW, NULL, SIZE_MAX);
ASSERT_TRUE(ptr == NULL);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_hbw_posix_memalign_over_size)
{
void *ptr = NULL;
int ret = hbw_posix_memalign(&ptr, 4096, SIZE_MAX);
EXPECT_TRUE(ptr == NULL);
EXPECT_EQ(ENOMEM, ret);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_hbw_posix_memalign_size_zero)
{
void *ptr = NULL;
errno = 0;
int ret = hbw_posix_memalign(&ptr, 4096, 0);
EXPECT_TRUE(ptr == NULL);
EXPECT_EQ(0, ret);
EXPECT_EQ(0, errno);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_memkind_posix_memalign_over_size)
{
void *ptr = NULL;
int ret = memkind_posix_memalign(MEMKIND_HBW, &ptr, 4096, SIZE_MAX);
EXPECT_TRUE(ptr == NULL);
EXPECT_EQ(ENOMEM, ret);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_GBFailureMemalign)
{
int ret = 0;
void *ptr = NULL;
int err = EINVAL;
ret = hbw_posix_memalign_psize(&ptr,
1073741824,
1073741826,
HBW_PAGESIZE_1GB_STRICT);
EXPECT_EQ(ret, err);
EXPECT_TRUE(ptr == NULL);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_RegularReallocWithMemAllign)
{
int ret = 0;
void *ptr = NULL;
ret = hbw_posix_memalign_psize(&ptr,
4096,
4096,
HBW_PAGESIZE_4KB);
EXPECT_EQ(ret, 0);
ASSERT_TRUE(ptr != NULL);
memset(ptr, 0, 4096);
ptr = hbw_realloc(ptr, 8192);
memset(ptr, 0, 8192);
hbw_free(ptr);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_SetPolicy)
{
// First call should be successful, consequent should generate a warning
// and be ignored
EXPECT_EQ(hbw_set_policy(HBW_POLICY_PREFERRED), 0);
EXPECT_EQ(hbw_set_policy(HBW_POLICY_BIND), EPERM);
EXPECT_EQ(hbw_set_policy(HBW_POLICY_INTERLEAVE), EPERM);
EXPECT_EQ(hbw_get_policy(), HBW_POLICY_PREFERRED);
EXPECT_EQ(hbw_set_policy((hbw_policy_t)0xFF), EINVAL);
}
//Check if hbw_set_policy() will be ignored after malloc.
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_SetPolicyAfterMalloc)
{
void *ptr = hbw_malloc(512);
EXPECT_TRUE(ptr != NULL);
EXPECT_EQ(hbw_set_policy(HBW_POLICY_BIND), EPERM);
EXPECT_NE(hbw_get_policy(), HBW_POLICY_BIND);
EXPECT_EQ(hbw_get_policy(), HBW_POLICY_PREFERRED);
hbw_free(ptr);
}
//Check if hbw_set_policy() will be ignored after calloc.
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_SetPolicyAfterCalloc)
{
void *ptr = hbw_calloc(512, 1);
EXPECT_TRUE(ptr != NULL);
EXPECT_EQ(hbw_set_policy(HBW_POLICY_BIND), EPERM);
EXPECT_NE(hbw_get_policy(), HBW_POLICY_BIND);
EXPECT_EQ(hbw_get_policy(), HBW_POLICY_PREFERRED);
hbw_free(ptr);
}
//Check if hbw_set_policy() will be ignored after realloc.
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_SetPolicyAfterRealloc)
{
void *ptr = hbw_malloc(512);
EXPECT_TRUE(ptr != NULL);
hbw_realloc(ptr, 512);
EXPECT_EQ(hbw_set_policy(HBW_POLICY_BIND), EPERM);
EXPECT_NE(hbw_get_policy(), HBW_POLICY_BIND);
EXPECT_EQ(hbw_get_policy(), HBW_POLICY_PREFERRED);
hbw_free(ptr);
}
//Check if hbw_set_policy() will be ignored after hbw_posix_memalign.
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_SetPolicyAfterHbwPosixMemalign)
{
void *ptr = NULL;
hbw_posix_memalign(&ptr, 2048, 2048);
EXPECT_TRUE(ptr != NULL);
EXPECT_EQ(hbw_set_policy(HBW_POLICY_BIND), EPERM);
EXPECT_NE(hbw_get_policy(), HBW_POLICY_BIND);
EXPECT_EQ(hbw_get_policy(), HBW_POLICY_PREFERRED);
hbw_free(ptr);
}
//Check if hbw_set_policy() will be ignored after hbw_posix_memalign_psize.
TEST_F(NegativeTest,
test_TC_MEMKIND_Negative_SetPolicyAfterHbwPosixMemalignPsize)
{
void *ptr = NULL;
hbw_posix_memalign_psize(&ptr, 2048, 2048, HBW_PAGESIZE_4KB);
EXPECT_TRUE(ptr != NULL);
EXPECT_EQ(hbw_set_policy(HBW_POLICY_BIND), EPERM);
EXPECT_NE(hbw_get_policy(), HBW_POLICY_BIND);
EXPECT_EQ(hbw_get_policy(), HBW_POLICY_PREFERRED);
hbw_free(ptr);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_GBMemalignPsizeAllign)
{
void *ptr = NULL;
int ret = 0;
int err = EINVAL;
ret = hbw_posix_memalign_psize(&ptr, -1, 1024, HBW_PAGESIZE_1GB);
EXPECT_EQ(err, ret);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_GBNullRealloc)
{
void *ptr = NULL;
ptr = memkind_realloc(MEMKIND_HBW_GBTLB, NULL, -1);
EXPECT_TRUE(ptr == NULL);
}
TEST_F(NegativeTest, test_TC_MEMKIND_Negative_GBNullFree)
{
memkind_free(MEMKIND_GBTLB, NULL);
}
TEST_F(NegativeTestHuge,
test_TC_MEMKIND_hbwmalloc_memalign_psize_Interleave_Policy_PAGE_SIZE_2MB)
{
void *ptr = NULL;
hbw_set_policy(HBW_POLICY_INTERLEAVE);
int ret = hbw_posix_memalign_psize(&ptr, 4096, 4096, HBW_PAGESIZE_2MB);
ASSERT_EQ(EINVAL, ret);
}