rte_graph.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(C) 2020 Marvell International Ltd.
 */

#ifndef _RTE_GRAPH_H_
#define _RTE_GRAPH_H_

#include <stdbool.h>
#include <stdio.h>

#include <rte_common.h>
#include <rte_compat.h>

#ifdef __cplusplus
extern "C" {
#endif

#define RTE_GRAPH_NAMESIZE 64 
#define RTE_NODE_NAMESIZE 64  
#define RTE_NODE_XSTAT_DESC_SIZE 64  
#define RTE_GRAPH_PCAP_FILE_SZ 64 
#define RTE_GRAPH_OFF_INVALID UINT32_MAX 
#define RTE_NODE_ID_INVALID UINT32_MAX   
#define RTE_EDGE_ID_INVALID UINT16_MAX   
#define RTE_GRAPH_ID_INVALID UINT16_MAX  
#define RTE_GRAPH_FENCE 0xdeadbeef12345678ULL 
typedef uint32_t rte_graph_off_t;  
typedef uint32_t rte_node_t;       
typedef uint16_t rte_edge_t;       
typedef uint16_t rte_graph_t;      
#if RTE_GRAPH_BURST_SIZE == 1
#define RTE_GRAPH_BURST_SIZE_LOG2 0  
#elif RTE_GRAPH_BURST_SIZE == 2
#define RTE_GRAPH_BURST_SIZE_LOG2 1  
#elif RTE_GRAPH_BURST_SIZE == 4
#define RTE_GRAPH_BURST_SIZE_LOG2 2  
#elif RTE_GRAPH_BURST_SIZE == 8
#define RTE_GRAPH_BURST_SIZE_LOG2 3  
#elif RTE_GRAPH_BURST_SIZE == 16
#define RTE_GRAPH_BURST_SIZE_LOG2 4  
#elif RTE_GRAPH_BURST_SIZE == 32
#define RTE_GRAPH_BURST_SIZE_LOG2 5  
#elif RTE_GRAPH_BURST_SIZE == 64
#define RTE_GRAPH_BURST_SIZE_LOG2 6  
#elif RTE_GRAPH_BURST_SIZE == 128
#define RTE_GRAPH_BURST_SIZE_LOG2 7  
#elif RTE_GRAPH_BURST_SIZE == 256
#define RTE_GRAPH_BURST_SIZE_LOG2 8  
#else
#error "Unsupported burst size"
#endif

/* Forward declaration */
struct rte_node;  
struct rte_graph; 
struct rte_graph_cluster_stats;      
struct rte_graph_cluster_node_stats; 
typedef uint16_t (*rte_node_process_t)(struct rte_graph *graph,
                       struct rte_node *node, void **objs,
                       uint16_t nb_objs);

typedef int (*rte_node_init_t)(const struct rte_graph *graph,
                   struct rte_node *node);

typedef void (*rte_node_fini_t)(const struct rte_graph *graph,
                struct rte_node *node);

typedef int (*rte_graph_cluster_stats_cb_t)(bool is_first, bool is_last,
         void *cookie, const struct rte_graph_cluster_node_stats *stats);

typedef void (*packets_enqueued_cb)(struct rte_graph *graph, uint64_t cb_priv);

struct rte_graph_param {
    int socket_id; 
    uint16_t nb_node_patterns;  
    const char **node_patterns;
    bool pcap_enable; 
    uint64_t num_pkt_to_capture; 
    char *pcap_filename; 
    union {
        struct {
            uint64_t rsvd; 
        } rtc;
        struct {
            uint32_t wq_size_max; 
            uint32_t mp_capacity; 
            packets_enqueued_cb notify_cb;
            uint64_t cb_priv;
        } dispatch;
    };
};

struct rte_graph_cluster_stats_param {
    int socket_id;
    rte_graph_cluster_stats_cb_t fn;
    union {
        void *cookie;
        FILE *f; 
    };
    uint16_t nb_graph_patterns;  
    const char **graph_patterns;
};

struct __rte_cache_aligned rte_graph_cluster_node_stats {
    uint64_t ts;        
    uint64_t calls;     
    uint64_t objs;      
    uint64_t cycles;    
    uint64_t prev_ts;   
    uint64_t prev_calls;    
    uint64_t prev_objs; 
    uint64_t prev_cycles;   
    union {
        struct {
            uint64_t sched_objs;
            uint64_t sched_fail;
        } dispatch;
    };

    uint64_t realloc_count; 
    uint8_t xstat_cntrs;                  
    char (*xstat_desc)[RTE_NODE_XSTAT_DESC_SIZE]; 
    uint64_t *xstat_count;                
    rte_node_t id;  
    uint64_t hz;    
    char name[RTE_NODE_NAMESIZE];   
};

rte_graph_t rte_graph_create(const char *name, struct rte_graph_param *prm);

int rte_graph_destroy(rte_graph_t id);

rte_graph_t rte_graph_clone(rte_graph_t id, const char *name, struct rte_graph_param *prm);

rte_graph_t rte_graph_from_name(const char *name);

char *rte_graph_id_to_name(rte_graph_t id);

int rte_graph_export(const char *name, FILE *f);

int rte_graph_model_mcore_dispatch_core_bind(rte_graph_t id, int lcore);

void rte_graph_model_mcore_dispatch_core_unbind(rte_graph_t id);

struct rte_graph *rte_graph_lookup(const char *name);

rte_graph_t rte_graph_max_count(void);

void rte_graph_dump(FILE *f, rte_graph_t id);

void rte_graph_list_dump(FILE *f);

void rte_graph_obj_dump(FILE *f, struct rte_graph *graph, bool all);

#define rte_graph_foreach_node(count, off, graph, node)                        \
    for (count = 0, off = graph->nodes_start,                              \
         node = RTE_PTR_ADD(graph, off);                                   \
         count < graph->nb_nodes;                                          \
         off = node->next, node = RTE_PTR_ADD(graph, off), count++)

struct rte_node *rte_graph_node_get(rte_graph_t graph_id, rte_node_t node_id);

struct rte_node *rte_graph_node_get_by_name(const char *graph,
                        const char *name);

struct rte_graph_cluster_stats *rte_graph_cluster_stats_create(
            const struct rte_graph_cluster_stats_param *prm);

void rte_graph_cluster_stats_destroy(struct rte_graph_cluster_stats *stat);

void rte_graph_cluster_stats_get(struct rte_graph_cluster_stats *stat,
                 bool skip_cb);

void rte_graph_cluster_stats_reset(struct rte_graph_cluster_stats *stat);

struct rte_node_xstats {
    uint16_t nb_xstats;              
    char xstat_desc[][RTE_NODE_XSTAT_DESC_SIZE]; 
};

struct rte_node_register {
    char name[RTE_NODE_NAMESIZE]; 
    uint64_t flags;           
#define RTE_NODE_SOURCE_F (1ULL << 0) 
    rte_node_process_t process; 
    rte_node_init_t init;       
    rte_node_fini_t fini;       
    struct rte_node_xstats *xstats; 
    rte_node_t id;          
    rte_node_t parent_id;       
    rte_edge_t nb_edges;        
    const char *next_nodes[];   
};

rte_node_t __rte_node_register(const struct rte_node_register *node);

#define RTE_NODE_REGISTER(node)                                                \
    RTE_INIT(rte_node_register_##node)                                     \
    {                                                                      \
        node.parent_id = RTE_NODE_ID_INVALID;                          \
        node.id = __rte_node_register(&node);                          \
    }

rte_node_t rte_node_clone(rte_node_t id, const char *name);

rte_node_t rte_node_from_name(const char *name);

char *rte_node_id_to_name(rte_node_t id);

rte_edge_t rte_node_edge_count(rte_node_t id);

rte_edge_t rte_node_edge_update(rte_node_t id, rte_edge_t from,
                const char **next_nodes, uint16_t nb_edges);

rte_edge_t rte_node_edge_shrink(rte_node_t id, rte_edge_t size);

rte_node_t rte_node_edge_get(rte_node_t id, char *next_nodes[]);

rte_node_t rte_node_max_count(void);

void rte_node_dump(FILE *f, rte_node_t id);

void rte_node_list_dump(FILE *f);

static __rte_always_inline int
rte_node_is_invalid(rte_node_t id)
{
    return (id == RTE_NODE_ID_INVALID);
}

__rte_experimental
int rte_node_free(rte_node_t id);

static __rte_always_inline int
rte_edge_is_invalid(rte_edge_t id)
{
    return (id == RTE_EDGE_ID_INVALID);
}

static __rte_always_inline int
rte_graph_is_invalid(rte_graph_t id)
{
    return (id == RTE_GRAPH_ID_INVALID);
}

static __rte_always_inline int
rte_graph_has_stats_feature(void)
{
#ifdef RTE_LIBRTE_GRAPH_STATS
    return RTE_LIBRTE_GRAPH_STATS;
#else
    return 0;
#endif
}

#ifdef __cplusplus
}
#endif

#endif /* _RTE_GRAPH_H_ */