dao_portq_group_worker.h

Go to the documentation of this file.

/* SPDX-License-Identifier: Marvell-MIT
 * Copyright (c) 2023 Marvell.
 */
 
#ifndef _DAO_PORT_QUEUE_GROUP_WORKER_H_
#define _DAO_PORT_QUEUE_GROUP_WORKER_H_
 
#include <errno.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <stddef.h>
#include <signal.h>
#include <assert.h>
 
#include <rte_common.h>
#include <rte_compat.h>
#include <rte_debug.h>
 
#include <dao_portq_group.h>
#include <dao_log.h>
#include <dao_util.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define DAO_PORTQ_GROUP_NAMELEN         64     
#define DAO_PORTQ_INVALID_VALUE         ((uint32_t)(~1)) 
typedef struct dao_portq_list {
    RTE_MARKER cacheline0 __rte_cache_aligned;
 
    uint32_t num_portqs; 
    uint32_t max_portqs_supported;
 
    dao_portq_t portqs[]; 
} dao_portq_list_t; /* do not cache align */
 
struct dao_portq_group {
    char portq_group_name[DAO_PORTQ_GROUP_NAMELEN]; 
    uint32_t num_cores;
 
    uint32_t portq_group_index;
 
    size_t per_core_portq_list_size;
 
    void *portq_group_main; 
    RTE_MARKER cacheline1 __rte_cache_aligned;
    dao_portq_list_t core_portq_list[];
};
 
typedef struct dao_portq_group_main {
    uint32_t num_portq_groups;
 
    uint32_t max_portq_groups_supported;
 
    struct dao_portq_group *portq_groups[];
 
} dao_portq_group_main_t;
 
extern dao_portq_group_main_t *__portq_group_main;
 
static inline struct dao_portq_group *
dao_portq_group_get(dao_portq_group_t epg)
{
    dao_portq_group_main_t *pm = __portq_group_main;
 
    RTE_VERIFY(epg < pm->max_portq_groups_supported);
 
    return(pm->portq_groups[epg]);
}
 
static inline dao_portq_list_t *
__dao_portq_group_list_get(struct dao_portq_group *epg, uint32_t core_id)
{
    if (unlikely(!epg))
        assert(0);
 
    RTE_VERIFY(core_id < epg->num_cores);
 
    return ((dao_portq_list_t *)((uint8_t *)epg->core_portq_list +
                     (core_id * epg->per_core_portq_list_size)));
}
 
static inline dao_portq_list_t *
dao_portq_group_list_get(dao_portq_group_t epg, uint32_t core_id)
{
    return(__dao_portq_group_list_get(dao_portq_group_get(epg), core_id));
}
 
static inline int32_t
dao_portq_group_portq_get_next(dao_portq_group_t epg, uint32_t core_id, dao_portq_t **portq,
                   int32_t index)
{
    dao_portq_list_t *epl = NULL;
    int32_t iter = index + 1;
 
    epl = dao_portq_group_list_get(epg, core_id);
 
    if (unlikely(iter < 0))
        return -1;
 
    while (epl->max_portqs_supported > (uint32_t)iter) {
        if (epl->portqs[iter].port_id == DAO_PORTQ_INVALID_VALUE) {
            iter++;
            continue;
        }
        break;
    }
    if (likely((uint32_t)iter < epl->max_portqs_supported)) {
        *portq = epl->portqs + iter;
        return iter;
    }
 
    return -1;
}
 
#define DAO_PORTQ_GROUP_FOREACH_CORE(epg, core_id, portq, i)                       \
        for (i = dao_portq_group_portq_get_next(epg, core_id, &portq, -1);         \
            (i > -1) && (portq->port_id != DAO_PORTQ_INVALID_VALUE);           \
            i = dao_portq_group_portq_get_next(epg, core_id, &portq, i))
 
#ifdef __cplusplus
}
#endif
 
#endif