/*

* Copyright (C) 2014 - 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 <algorithm> // sort

#include <math.h> // log2

#include <cassert>

#include <iostream>

#include "framework.hpp"

namespace performance_tests

{

    namespace ch = std::chrono;

    using std::cout;

    using std::endl;

    using std::unique_lock;

    using std::mutex;

#ifdef __DEBUG

    mutex g_coutMutex;

    int g_msgLevel = 1;

#endif

    void Barrier::wait()

    {

        unique_lock<mutex> lock(m_barrierMutex);

        // Decrement number of threads awaited at the barrier

        m_waiting--;

        if (m_waiting == 0) {

            // Called by the last expected thread - notify all waiting threads and exit

            m_cVar.notify_all();

            // Store the time when barrier was released

            if (m_releasedAt.tv_sec == 0 && m_releasedAt.tv_nsec == 0) {

                clock_gettime(CLOCK_MONOTONIC, &m_releasedAt);

            }

            return;

        }

        // Wait unitl the last expected thread calls wait() on Barrier instance, or timeout occurs

        m_cVar.wait_until(lock, ch::system_clock::now() + ch::seconds(10), []() {

            return GetInstance().m_waiting == 0;

        });

    }

    // Worker class

    Worker::Worker(

        uint32_t actionsCount,

        const vector<size_t> &allocationSizes,

        Operation *freeOperation,

        memkind_t kind)

        : m_actionsCount(actionsCount)

        , m_allocationSizes(allocationSizes)

        , m_actions(vector<Action*>(actionsCount, nullptr))

        , m_kind(kind)

    {

        assert(freeOperation->getName() == OperationName::Free);

    }

    Worker::~Worker()

    {

        for (Action *action : m_actions) { //each action

            delete action;

        }

    }

    void Worker::init(const vector<Operation *> &testOperations,

                      Operation *&freeOperation)

    {

        for(uint32_t i = 0 ; i < m_actionsCount ; i++) {

            int bucketSize = rand() % Operation::MaxBucketSize;

            for (Operation *operation : testOperations) { //each operation

                if (operation->checkCondition(bucketSize)) {

                    size_t size = m_allocationSizes[m_allocationSizes.size() > 1 ? rand() %

                                                                             m_allocationSizes.size() : 0];

                    m_actions[i] = new Action(

                        operation,

                        freeOperation,

                        m_kind,

                        size,

                        log2(rand() % size),

                        sizeof(void *) * (1 << ((rand() % Operation::MemalignMaxMultiplier))));

                    break;

                }

            }

        }

    }

    void Worker::run()

    {

        m_thread = new thread(&Worker::work, this);

    }

#ifdef __DEBUG

    uint16_t Worker::getId()

    {

        return m_threadId;

    }

    void Worker::setId(uint16_t threadId)

    {

        m_threadId = threadId;

    }

#endif

    void Worker::finish()

    {

        if (m_thread != nullptr) {

            m_thread->join();

            delete m_thread;

        }

    }

    void Worker::work()

    {

        EMIT(1, "Entering barrier " << m_threadId)

        Barrier::GetInstance().wait();

        EMIT(1, "Starting thread " << m_threadId)

        for (Action *action : m_actions) {

            action->alloc();

        }

    }

    void Worker::clean()

    {

        EMIT(2, "Cleaning thread " << m_threadId)

        for (Action *action : m_actions) {

            action->free();

        }

        EMIT(1, "Thread " << m_threadId << " finished")

    }

    // PerformanceTest class

    PerformanceTest::PerformanceTest(

        size_t repeatsCount,

        size_t threadsCount,

        size_t operationsCount)

        : m_repeatsCount(repeatsCount)

        , m_discardCount(repeatsCount * (distardPercent / 100.0))

        , m_threadsCount(threadsCount)

        , m_operationsCount(operationsCount)

        , m_executionMode(ExecutionMode::SingleInteration)

    {

    }

    void PerformanceTest::setAllocationSizes(const vector<size_t> &allocationSizes)

    {

        m_allocationSizes = allocationSizes;

    }

    void PerformanceTest::setOperations(const vector<vector<Operation *>>

                                        &testOperations, Operation *freeOperation)

    {

        m_testOperations = testOperations;

        m_freeOperation = freeOperation;

    }

    void PerformanceTest::setExecutionMode(ExecutionMode executionMode)

    {

        m_executionMode = executionMode;

    }

    void PerformanceTest::setKind(const vector<memkind_t> &kinds)

    {

        m_kinds = kinds;

    }

    inline void PerformanceTest::runIteration()

    {

        timespec iterationStop, iterationStart;

        Barrier::GetInstance().reset(m_threadsCount);

        for (Worker *worker : m_workers) {

            worker->run();

        }

        for (Worker *worker : m_workers) {

            worker->finish();

        }

        EMIT(1, "Alloc completed");

        clock_gettime(CLOCK_MONOTONIC, &iterationStop);

        iterationStart = Barrier::GetInstance().releasedAt();

        m_durations.push_back(

            (iterationStop.tv_sec  * NanoSecInSec + iterationStop.tv_nsec) -

            (iterationStart.tv_sec * NanoSecInSec + iterationStart.tv_nsec)

        );

        for (Worker *worker : m_workers) {

            worker->clean();

        }

    }

    void PerformanceTest::prepareWorkers()

    {

        for (size_t threadId = 0; threadId < m_threadsCount; threadId++) {

            m_workers.push_back(

                new Worker(

                    m_operationsCount,

                    m_allocationSizes,

                    m_freeOperation,

                    m_kinds.size() > 0 ? m_kinds[threadId % m_kinds.size()] : nullptr)

            );

#ifdef __DEBUG

            m_workers.back()->setId(threadId);

#endif

            if (m_executionMode == ExecutionMode::SingleInteration) {

                // In ManyIterations mode, operations will be set for each thread at the beginning of each iteration

                m_workers.back()->init(m_testOperations[threadId % m_testOperations.size()],

                                       m_freeOperation);

            }

        }

    }

    Metrics PerformanceTest::getMetrics()

    {

        uint64_t totalDuration = 0;

        std::sort(m_durations.begin(), m_durations.end());

        m_durations.erase(m_durations.end() - m_discardCount, m_durations.end());

        for (uint64_t &duration : m_durations) {

            totalDuration += duration;

        }

        Metrics metrics;

        metrics.executedOperations   = m_durations.size() * m_threadsCount *

                                       m_operationsCount;

        metrics.totalDuration        = totalDuration;

        metrics.repeatDuration       = (double) totalDuration /

                                       ((uint64_t)m_durations.size() * NanoSecInSec);

        metrics.iterationDuration    = metrics.repeatDuration;

        if (m_executionMode == ExecutionMode::ManyIterations) {

            metrics.executedOperations *= m_testOperations.size();

            metrics.iterationDuration  /= m_testOperations.size();

        }

        metrics.operationsPerSecond  = (double) metrics.executedOperations *

                                       NanoSecInSec / totalDuration;

        metrics.avgOperationDuration = (double) totalDuration /

                                       metrics.executedOperations;

        assert(metrics.iterationDuration != 0.0);

        return metrics;

    }

    void PerformanceTest::writeMetrics(const string &suiteName,

                                       const string &caseName, const string &fileName)

    {

        Metrics metrics = getMetrics();

        // For thousands separation

        setlocale(LC_ALL, "");

        if (!fileName.empty()) {

            FILE *f;

            if((f = fopen(fileName.c_str(), "a+"))) {

                fprintf(f,

                        "%s;%s;%zu;%zu;%lu;%f;%f;%f;%f\n",

                        suiteName.c_str(),

                        caseName.c_str(),

                        m_repeatsCount,

                        m_threadsCount,

                        metrics.executedOperations,

                        metrics.operationsPerSecond,

                        metrics.avgOperationDuration,

                        metrics.iterationDuration,

                        metrics.repeatDuration);

                fclose(f);

            }

        }

        printf("Operations/sec:\t\t\t%'f\n"

               "Avg. operation duration:\t%f nsec\n"

               "Iteration duration:\t\t%f sec\n"

               "Repeat duration:\t\t%f sec\n",

               metrics.operationsPerSecond,

               metrics.avgOperationDuration,

               metrics.iterationDuration,

               metrics.repeatDuration);

    }

    int PerformanceTest::run()

    {

        if (m_testOperations.empty() ||

            m_allocationSizes.empty() ||

            m_freeOperation == nullptr) {

            cout << "ERROR: Test not initialized" << endl;

            return 1;

        }

        // Create threads

        prepareWorkers();

        //warmup kinds

        void *alloc = nullptr;

        for (const memkind_t &kind : m_kinds) {

            m_testOperations[0][0]->perform(kind, alloc, 1e6);

            m_freeOperation->perform(kind, alloc);

        }

        for (size_t repeat = 0; repeat < m_repeatsCount; repeat++) {

            EMIT(1, "Test run #" << repeat)

            if (m_executionMode == ExecutionMode::SingleInteration) {

                runIteration();

            } else {

                // Perform each operations list in separate iteration, for each thread

                for (vector<Operation *> &ops : m_testOperations) {

                    for (Worker *worker : m_workers) {

                        worker->init(ops, m_freeOperation);

                    }

                    runIteration();

                }

            }

        }

        return 0;

    }

    void PerformanceTest::showInfo()

    {

        printf("Test parameters: %lu repeats, %lu threads, %d operations per thread\n",

               m_repeatsCount,

               m_threadsCount,

               m_operationsCount);

        printf("Thread memory allocation operations:\n");

        for (unsigned long i = 0; i < m_testOperations.size(); i++) {

            if (m_executionMode == ExecutionMode::SingleInteration) {

                printf("\tThread %lu,%lu,...\n", i, i + (m_testOperations.size()));

            } else {

                printf("\tIteration %lu\n", i);

            }

            for (const Operation *op : m_testOperations[i]) {

                printf("\t\t %s (bucket size: %d)\n", op->getNameStr().c_str(),

                       op->getBucketSize());

            }

        }

        printf("Memory free operation:\n\t\t%s\n",

               m_freeOperation->getNameStr().c_str());

        printf("Allocation sizes:\n");

        for (size_t size : m_allocationSizes) {

            printf("\t\t%lu bytes\n", size);

        }

    }

}