/*
 * Copyright (c) 2021 Intel.
 *
 * 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.
 */

#include <config.h>
#include <errno.h>
#include <stdint.h>
#include <string.h>

#include "dpif-netdev-private-thread.h"
#include "openvswitch/vlog.h"
#include "ovs-thread.h"

VLOG_DEFINE_THIS_MODULE(dpif_mfex_extract_study);

static atomic_uint32_t mfex_study_pkts_count = MFEX_MAX_PKT_COUNT;

/* Struct to hold miniflow study stats. */
struct study_stats {
    uint32_t pkt_count;
    uint32_t impl_hitcount[MFEX_IMPL_MAX];
};

/* Define per thread data to hold the study stats. */
DEFINE_PER_THREAD_MALLOCED_DATA(struct study_stats *, study_stats);

/* Allocate per thread PMD pointer space for study_stats. */
static inline struct study_stats *
mfex_study_get_study_stats_ptr(void)
{
    struct study_stats *stats = study_stats_get();
    if (OVS_UNLIKELY(!stats)) {
        stats = xzalloc(sizeof *stats);
        study_stats_set_unsafe(stats);
    }
    return stats;
}

int
mfex_set_study_pkt_cnt(uint32_t pkt_cmp_count, const char *name)
{
    struct dpif_miniflow_extract_impl *miniflow_funcs;
    miniflow_funcs = dpif_mfex_impl_info_get();

    /* If the packet count is set and implementation called is study then
     * set packet counter to requested number else return -EINVAL.
     */
    if ((strcmp(miniflow_funcs[MFEX_IMPL_STUDY].name, name) == 0) &&
        (pkt_cmp_count != 0)) {

        atomic_store_relaxed(&mfex_study_pkts_count, pkt_cmp_count);
        return 0;
    }

    return -EINVAL;
}

uint32_t
mfex_study_traffic(struct dp_packet_batch *packets,
                   struct netdev_flow_key *keys,
                   uint32_t keys_size, odp_port_t in_port,
                   struct dp_netdev_pmd_thread *pmd_handle)
{
    uint32_t hitmask = 0;
    uint32_t mask = 0;
    struct dp_netdev_pmd_thread *pmd = pmd_handle;
    struct dpif_miniflow_extract_impl *miniflow_funcs;
    struct study_stats *stats = mfex_study_get_study_stats_ptr();
    miniflow_funcs = dpif_mfex_impl_info_get();

    /* Run traffic optimized miniflow_extract to collect the hitmask
     * to be compared after certain packets have been hit to choose
     * the best miniflow_extract version for that traffic.
     */
    for (int i = MFEX_IMPL_START_IDX; i < MFEX_IMPL_MAX; i++) {
        if (!miniflow_funcs[i].available) {
            continue;
        }

        hitmask = miniflow_funcs[i].extract_func(packets, keys, keys_size,
                                                 in_port, pmd_handle);
        stats->impl_hitcount[i] += count_1bits(hitmask);

        /* If traffic is not classified then we dont overwrite the keys
         * array in minfiflow implementations so its safe to create a
         * mask for all those packets whose miniflow have been created.
         */
        mask |= hitmask;
    }

    stats->pkt_count += dp_packet_batch_size(packets);

    /* Choose the best implementation after a minimum packets have been
     * processed.
     */
    uint32_t study_cnt_pkts;
    atomic_read_relaxed(&mfex_study_pkts_count, &study_cnt_pkts);

    if (stats->pkt_count >= study_cnt_pkts) {
        uint32_t best_func_index = MFEX_IMPL_START_IDX;
        uint32_t max_hits = 0;
        for (int i = MFEX_IMPL_START_IDX; i < MFEX_IMPL_MAX; i++) {
            if (stats->impl_hitcount[i] > max_hits) {
                max_hits = stats->impl_hitcount[i];
                best_func_index = i;
            }
        }

        /* If 50% of the packets hit, enable the function. */
        if (max_hits >= (mfex_study_pkts_count / 2)) {
            miniflow_extract_func mf_func =
                        miniflow_funcs[best_func_index].extract_func;
            atomic_uintptr_t *pmd_func = (void *)&pmd->miniflow_extract_opt;
            atomic_store_relaxed(pmd_func, (uintptr_t) mf_func);
            VLOG_INFO("MFEX study chose impl %s: (hits %u/%u pkts)",
                      miniflow_funcs[best_func_index].name, max_hits,
                      stats->pkt_count);
        } else {
            /* Set the implementation to null for default miniflow. */
            miniflow_extract_func mf_func =
                        miniflow_funcs[MFEX_IMPL_SCALAR].extract_func;
            atomic_uintptr_t *pmd_func = (void *)&pmd->miniflow_extract_opt;
            atomic_store_relaxed(pmd_func, (uintptr_t) mf_func);
            VLOG_INFO("Not enough packets matched (%u/%u), disabling"
                      " optimized MFEX.", max_hits, stats->pkt_count);
        }

        /* In debug mode show stats for all the counters. */
        if (VLOG_IS_DBG_ENABLED()) {

            for (int i = MFEX_IMPL_START_IDX; i < MFEX_IMPL_MAX; i++) {
                VLOG_DBG("MFEX study results for implementation %s:"
                         " (hits %u/%u pkts)", miniflow_funcs[i].name,
                         stats->impl_hitcount[i], stats->pkt_count);
            }
        }

        /* Reset stats so that study function can be called again
         * for next traffic type and optimal function ptr can be
         * chosen.
         */
        memset(stats, 0, sizeof(struct study_stats));
    }
    return mask;
}
