/*
 * Copyright (C) 2016 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef TNT_UTILS_PROFILER_H
#define TNT_UTILS_PROFILER_H

#include <assert.h>
#include <stdint.h>

#include <array>
#include <chrono>

#if defined(__linux__)
#   include <unistd.h>
#   include <sys/ioctl.h>
#   include <linux/perf_event.h>
#endif

namespace utils {

class Profiler {
    enum {
        INSTRUCTIONS    = 0,   // must be zero
        CPU_CYCLES      = 1,
        DCACHE_REFS     = 2,
        DCACHE_MISSES   = 3,
        BRANCHES        = 4,
        BRANCH_MISSES   = 5,
        ICACHE_REFS     = 6,
        ICACHE_MISSES   = 7,

        // Must be last one
        EVENT_COUNT
    };

public:

    enum {
        EV_CPU_CYCLES = 1 << CPU_CYCLES,
        EV_L1D_REFS   = 1 << DCACHE_REFS,
        EV_L1D_MISSES = 1 << DCACHE_MISSES,
        EV_BPU_REFS   = 1 << BRANCHES,
        EV_BPU_MISSES = 1 << BRANCH_MISSES,
        EV_L1I_REFS   = 1 << ICACHE_REFS,
        EV_L1I_MISSES = 1 << ICACHE_MISSES,
        // helpers
        EV_L1D_RATES = EV_L1D_REFS | EV_L1D_MISSES,
        EV_L1I_RATES = EV_L1I_REFS | EV_L1I_MISSES,
        EV_BPU_RATES = EV_BPU_REFS | EV_BPU_MISSES,
    };

    static Profiler& get() noexcept;


    Profiler(const Profiler& rhs) = delete;
    Profiler(Profiler&& rhs) = delete;
    Profiler& operator=(const Profiler& rhs) = delete;
    Profiler& operator=(Profiler&& rhs) = delete;

    // selects which events are enabled. 
    // By Default: EV_CPU_CYCLES | EV_L1D_RATES | EV_BPU_RATES
    uint32_t resetEvents(uint32_t eventMask) noexcept;

    uint32_t getEnabledEvents() const noexcept { return mEnabledEvents; }

    // could return false if performance counters are not supported/enabled
    bool isValid() const { return mCountersFd[0] >= 0; }

    class Counters {
        friend class Profiler;
        uint64_t nr;
        uint64_t time_enabled;
        uint64_t time_running;
        struct {
            uint64_t value;
            uint64_t id;
        } counters[Profiler::EVENT_COUNT];

        friend Counters operator-(Counters lhs, const Counters& rhs) noexcept {
            lhs.nr -= rhs.nr;
            lhs.time_enabled -= rhs.time_enabled;
            lhs.time_running -= rhs.time_running;
            for (size_t i=0 ; i<EVENT_COUNT ; ++i) {
                lhs.counters[i].value -= rhs.counters[i].value;
            }
            return lhs;
        }

    public:
        uint64_t getInstructions() const        { return counters[INSTRUCTIONS].value; }
        uint64_t getCpuCycles() const           { return counters[CPU_CYCLES].value; }
        uint64_t getL1DReferences() const       { return counters[DCACHE_REFS].value; }
        uint64_t getL1DMisses() const           { return counters[DCACHE_MISSES].value; }
        uint64_t getL1IReferences() const       { return counters[ICACHE_REFS].value; }
        uint64_t getL1IMisses() const           { return counters[ICACHE_MISSES].value; }
        uint64_t getBranchInstructions() const  { return counters[BRANCHES].value; }
        uint64_t getBranchMisses() const        { return counters[BRANCH_MISSES].value; }

        std::chrono::duration<uint64_t, std::nano> getWallTime() const {
            return std::chrono::duration<uint64_t, std::nano>(time_enabled);
        }

        std::chrono::duration<uint64_t, std::nano> getRunningTime() const {
            return std::chrono::duration<uint64_t, std::nano>(time_running);
        }

        double getIPC() const noexcept {
            uint64_t cpuCycles = getCpuCycles();
            uint64_t instructions = getInstructions();
            return double(instructions) / double(cpuCycles);
        }

        double getCPI() const noexcept {
            uint64_t cpuCycles = getCpuCycles();
            uint64_t instructions = getInstructions();
            return double(cpuCycles) / double(instructions);
        }

        double getL1DMissRate() const noexcept {
            uint64_t cacheReferences = getL1DReferences();
            uint64_t cacheMisses = getL1DMisses();
            return double(cacheMisses) / double(cacheReferences);
        }

        double getL1DHitRate() const noexcept {
            return 1.0 - getL1DMissRate();
        }

        double getL1IMissRate() const noexcept {
            uint64_t cacheReferences = getL1IReferences();
            uint64_t cacheMisses = getL1IMisses();
            return double(cacheMisses) / double(cacheReferences);
        }

        double getL1IHitRate() const noexcept {
            return 1.0 - getL1IMissRate();
        }

        double getBranchMissRate() const noexcept {
            uint64_t branchReferences = getBranchInstructions();
            uint64_t branchMisses = getBranchMisses();
            return double(branchMisses) / double(branchReferences);
        }

        double getBranchHitRate() const noexcept {
            return 1.0 - getBranchMissRate();
        }

        double getMPKI(uint64_t misses) const noexcept {
            return (misses * 1000.0) / getInstructions();
        }

    };

#if defined(__linux__)

    void reset() noexcept {
        int fd = mCountersFd[0];
        ioctl(fd, PERF_EVENT_IOC_RESET,  PERF_IOC_FLAG_GROUP);
    }

    void start() noexcept {
        int fd = mCountersFd[0];
        ioctl(fd, PERF_EVENT_IOC_ENABLE, PERF_IOC_FLAG_GROUP);
    }

    void stop() noexcept {
        int fd = mCountersFd[0];
        ioctl(fd, PERF_EVENT_IOC_DISABLE, PERF_IOC_FLAG_GROUP);
    }

    void readCounters(Counters* outCounters) noexcept {
        Counters counters;
        ssize_t n = read(mCountersFd[0], &counters, sizeof(Counters));
        memset(outCounters, 0, sizeof(Counters));
        if (n > 0) {
            outCounters->nr = counters.nr;
            outCounters->time_enabled = counters.time_enabled;
            outCounters->time_running = counters.time_running;
            for (size_t i=0 ; i<size_t(EVENT_COUNT) ; i++) {
                if (mCountersFd[i] >= 0) {
                    outCounters->counters[i] = counters.counters[mIds[i]];
                }
            }
        }
    }

#else // !__linux__

    void reset() noexcept { }
    void start() noexcept { }
    void stop() noexcept { }
    void readCounters(Counters* counters) noexcept { }

#endif // __linux__

    bool hasBranchRates() const noexcept {
        return (mCountersFd[BRANCHES] >= 0) && (mCountersFd[BRANCH_MISSES] >= 0);
    }

    bool hasICacheRates() const noexcept {
        return (mCountersFd[ICACHE_REFS] >= 0) && (mCountersFd[ICACHE_MISSES] >= 0);
    }

private:
    Profiler() noexcept;
    ~Profiler() noexcept;

    std::array<uint8_t, EVENT_COUNT> mIds;
    std::array<int, EVENT_COUNT> mCountersFd;
    uint32_t mEnabledEvents = 0;
};

} // namespace utils

#endif // TNT_UTILS_PROFILER_H