rte_graph_model_mcore_dispatch.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(C) 2023 Intel Corporation
 */
 
#ifndef _RTE_GRAPH_MODEL_MCORE_DISPATCH_H_
#define _RTE_GRAPH_MODEL_MCORE_DISPATCH_H_
 
#include <rte_errno.h>
#include <rte_mempool.h>
#include <rte_memzone.h>
#include <rte_ring.h>
 
#include "rte_graph_worker_common.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define RTE_GRAPH_SCHED_WQ_SIZE_MULTIPLIER  8
#define RTE_GRAPH_SCHED_WQ_SIZE(nb_nodes)   \
    ((typeof(nb_nodes))((nb_nodes) * RTE_GRAPH_SCHED_WQ_SIZE_MULTIPLIER))
 
bool __rte_noinline __rte_graph_mcore_dispatch_sched_node_enqueue(struct rte_node *node,
                                  struct rte_graph_rq_head *rq);
 
void __rte_graph_mcore_dispatch_sched_wq_process(struct rte_graph *graph);
 
int rte_graph_model_mcore_dispatch_node_lcore_affinity_set(const char *name,
                               unsigned int lcore_id);
 
static inline void
rte_graph_walk_mcore_dispatch(struct rte_graph *graph)
{
    const uint16_t nwords = graph->nb_sched_words;
    struct rte_node *node;
    uint16_t word, bit;
 
    if (graph->dispatch.wq != NULL)
        __rte_graph_mcore_dispatch_sched_wq_process(graph);
 
    /* Seed pending bitmap with source nodes bound to this lcore */
    for (word = 0; word < nwords; word++)
        graph->pending[word] |= graph->src_pending[word];
 
    for (;;) {
        /* find first word with any pending bit */
        for (word = 0; word < nwords; word++)
            if (graph->pending[word])
                break;
        if (word == nwords)
            break; /* no more pending nodes */
 
        bit = rte_ctz64(graph->pending[word]);
        graph->pending[word] &= ~(1ULL << bit);
        node = __rte_graph_pending_node(graph, word, bit);
 
        /* Schedule the node until all task/objs are done */
        if (node->dispatch.lcore_id != RTE_MAX_LCORE &&
            graph->dispatch.lcore_id != node->dispatch.lcore_id &&
            graph->dispatch.rq != NULL &&
            __rte_graph_mcore_dispatch_sched_node_enqueue(node, graph->dispatch.rq))
            continue;
 
        __rte_node_process(graph, node);
    }
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* _RTE_GRAPH_MODEL_MCORE_DISPATCH_H_ */