// SPDX-License-Identifier: BSD-2-Clause
/* Copyright (C) 2018 - 2020 Intel Corporation. */

#include <memkind.h>
#include "allocator_perf_tool/TimerSysTime.hpp"
#include "common.h"

#define STRESS_TIME (3*24*60*60)

extern const char  *PMEM_DIR;

static const size_t small_size[] = {8, 16, 32, 48, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384,
                                    448, 512, 640, 768, 896, 1 * KB, 1280, 1536, 1792, 2 * KB, 2560, 3 * KB,
                                    3584, 4 * KB, 5 * KB, 6 * KB, 7 * KB, 8 * KB, 10 * KB, 12 * KB, 14 * KB
                                   };

static const size_t large_size[] = {16 * KB, 32 * KB, 20 * KB, 24 * KB, 28 * KB, 32 * KB, 40 * KB, 48 * KB,
                                    56 * KB, 64 * KB, 80 * KB, 96 * KB, 112 * KB, 128 * KB, 160 * KB, 192 * KB,
                                    224 * KB, 256 * KB, 320 * KB, 384 * KB, 448 * KB, 512 * KB, 640 * KB,
                                    768 * KB, 896 * KB, 1 * MB, 1280 * KB, 1536 * KB, 1792 * KB, 2 * MB,
                                    2560 * KB, 3 * MB, 3584 * KB, 4 * MB, 5 * MB, 6 * MB, 7 * MB, 8 * MB
                                   };

class MemkindPmemLongTimeStress: public :: testing::Test
{

protected:
    memkind_t pmem_kind;
    void SetUp()
    {
        int err = memkind_create_pmem(PMEM_DIR, 0, &pmem_kind);
        ASSERT_EQ(0, err);
        ASSERT_NE(nullptr, pmem_kind);
    }

    void TearDown()
    {
        int err = memkind_destroy_kind(pmem_kind);
        ASSERT_EQ(0, err);
    }
};

TEST_F(MemkindPmemLongTimeStress, DISABLED_test_TC_MEMKIND_PmemStressSmallSize)
{
    void *test = nullptr;
    TimerSysTime timer;
    timer.start();

    do {
        for (size_t i = 0; i < ARRAY_SIZE(small_size); i++) {
            test = memkind_malloc(pmem_kind, small_size[i]);
            ASSERT_NE(test, nullptr);
            memkind_free(pmem_kind, test);
        }
    } while (timer.getElapsedTime() < STRESS_TIME);
}

TEST_F(MemkindPmemLongTimeStress, DISABLED_test_TC_MEMKIND_PmemStressLargeSize)
{
    void *test = nullptr;
    TimerSysTime timer;
    timer.start();

    do {
        for (size_t i = 0; i < ARRAY_SIZE(large_size); i++) {
            test = memkind_malloc(pmem_kind, large_size[i]);
            ASSERT_NE(test, nullptr);
            memkind_free(pmem_kind, test);
        }
    } while (timer.getElapsedTime() < STRESS_TIME);
}

TEST_F(MemkindPmemLongTimeStress,
       DISABLED_test_TC_MEMKIND_PmemStressSmallAndLargeSize)
{
    void *test = nullptr;
    size_t i = 0, j = 0;
    TimerSysTime timer;
    timer.start();

    do {
        if (i < ARRAY_SIZE(small_size)) {
            test = memkind_malloc(pmem_kind, small_size[i]);
            ASSERT_NE(test, nullptr);
            memkind_free(pmem_kind, test);
            i++;
        } else
            i = 0;

        if (j < ARRAY_SIZE(large_size)) {
            test = memkind_malloc(pmem_kind, large_size[j]);
            ASSERT_NE(test, nullptr);
            memkind_free(pmem_kind, test);
            j++;
        } else
            j = 0;

    } while (timer.getElapsedTime() < STRESS_TIME);
}