cne_graph.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright (c) 2020 Marvell International Ltd.
 */
 
#ifndef _CNE_GRAPH_H_
#define _CNE_GRAPH_H_
 
#include <stdbool.h>
#include <stdio.h>
 
#include <cne_common.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define CNE_GRAPH_BURST_SIZE  256
#define CNE_GRAPH_NAMESIZE    64                    
#define CNE_NODE_NAMESIZE     64                    
#define CNE_GRAPH_OFF_INVALID UINT32_MAX            
#define CNE_NODE_ID_INVALID   UINT32_MAX            
#define CNE_EDGE_ID_INVALID   UINT16_MAX            
#define CNE_GRAPH_ID_INVALID  UINT16_MAX            
#define CNE_GRAPH_FENCE       0xdeadbeef12345678ULL 
typedef uint32_t cne_graph_off_t; 
typedef uint32_t cne_node_t;      
typedef uint16_t cne_edge_t;      
typedef uint16_t cne_graph_t;     
#if CNE_GRAPH_BURST_SIZE == 1
#define CNE_GRAPH_BURST_SIZE_LOG2 0 
#elif CNE_GRAPH_BURST_SIZE == 2
#define CNE_GRAPH_BURST_SIZE_LOG2 1 
#elif CNE_GRAPH_BURST_SIZE == 4
#define CNE_GRAPH_BURST_SIZE_LOG2 2 
#elif CNE_GRAPH_BURST_SIZE == 8
#define CNE_GRAPH_BURST_SIZE_LOG2 3 
#elif CNE_GRAPH_BURST_SIZE == 16
#define CNE_GRAPH_BURST_SIZE_LOG2 4 
#elif CNE_GRAPH_BURST_SIZE == 32
#define CNE_GRAPH_BURST_SIZE_LOG2 5 
#elif CNE_GRAPH_BURST_SIZE == 64
#define CNE_GRAPH_BURST_SIZE_LOG2 6 
#elif CNE_GRAPH_BURST_SIZE == 128
#define CNE_GRAPH_BURST_SIZE_LOG2 7 
#elif CNE_GRAPH_BURST_SIZE == 256
#define CNE_GRAPH_BURST_SIZE_LOG2 8 
#else
#error "Unsupported burst size"
#endif
 
/* Forward declaration */
struct cne_node;                     
struct cne_graph;                    
struct cne_graph_cluster_stats;      
struct cne_graph_cluster_node_stats; 
typedef uint16_t (*cne_node_process_t)(struct cne_graph *graph, struct cne_node *node, void **objs,
                                       uint16_t nb_objs);
 
typedef int (*cne_node_init_t)(const struct cne_graph *graph, struct cne_node *node);
 
typedef void (*cne_node_fini_t)(const struct cne_graph *graph, struct cne_node *node);
 
typedef int (*cne_graph_cluster_stats_cb_t)(bool is_first, bool is_last,
                                            const struct cne_graph_cluster_node_stats *stats);
 
struct cne_graph_cluster_stats_param {
    cne_graph_cluster_stats_cb_t fn;
 
    uint16_t nb_graph_patterns;  
    const char **graph_patterns; 
};
 
struct cne_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; 
    uint64_t realloc_count; 
    cne_node_t id;                
    uint64_t hz;                  
    char name[CNE_NODE_NAMESIZE]; 
} __cne_cache_aligned;
 
CNDP_API cne_graph_t cne_graph_create(const char *name, const char **patterns);
 
CNDP_API int cne_graph_destroy(cne_graph_t id);
 
CNDP_API cne_graph_t cne_graph_from_name(const char *name);
 
CNDP_API char *cne_graph_id_to_name(cne_graph_t id);
 
CNDP_API int cne_graph_export(const char *name, FILE *f);
 
typedef struct {
    int (*header)(FILE *f, const char *name); 
    int (*body)(FILE *f, char *node_name, char **adj_names, cne_edge_t nb_edges,
                int src);    
    int (*trailer)(FILE *f); 
} cne_graph_export_t;
 
CNDP_API int cne_graph_export_cb(const char *name, FILE *f, cne_graph_export_t *exp);
 
CNDP_API cne_graph_t cne_graph_max_count(void);
 
CNDP_API struct cne_graph *cne_graph_lookup(const char *name);
 
CNDP_API void cne_graph_dump(FILE *f, cne_graph_t id);
 
CNDP_API void cne_graph_list_dump(FILE *f);
 
CNDP_API void cne_graph_obj_dump(FILE *f, struct cne_graph *graph, bool all);
 
#define cne_graph_foreach_node(count, off, graph, node)                       \
    for (count = 0, off = graph->nodes_start, node = CNE_PTR_ADD(graph, off); \
         count < graph->nb_nodes; off = node->next, node = CNE_PTR_ADD(graph, off), count++)
 
CNDP_API struct cne_node *cne_graph_node_get(cne_graph_t graph_id, cne_node_t node_id);
 
CNDP_API struct cne_node *cne_graph_node_get_by_name(const char *graph, const char *name);
 
CNDP_API struct cne_node *cne_graph_get_node_by_name(const struct cne_graph *graph,
                                                     const char *node_name);
 
CNDP_API struct cne_graph_cluster_stats *
cne_graph_cluster_stats_create(const struct cne_graph_cluster_stats_param *prm);
 
CNDP_API void cne_graph_cluster_stats_destroy(struct cne_graph_cluster_stats *stat);
 
CNDP_API void cne_graph_cluster_stats_get(struct cne_graph_cluster_stats *stat, bool skip_cb);
 
CNDP_API void cne_graph_cluster_stats_reset(struct cne_graph_cluster_stats *stat);
 
CNDP_API int cne_graph_stats_node_count(struct cne_graph_cluster_stats *stat);
 
struct cne_node_register {
    char name[CNE_NODE_NAMESIZE]; 
    uint64_t flags;               
    cne_node_process_t process;   
    cne_node_init_t init;         
    cne_node_fini_t fini;         
    cne_node_t id;                
    cne_node_t parent_id;         
    cne_edge_t nb_edges;          
    const char *next_nodes[];     
};
 
#define CNE_NODE_SOURCE_F (1ULL << 0) 
#define CNE_NODE_INPUT_F  (1ULL << 1) 
#define CNE_NODE_MASK_F   (CNE_NODE_SOURCE_F | CNE_NODE_INPUT_F) 
cne_node_t __cne_node_register(const struct cne_node_register *node);
 
#define CNE_NODE_REGISTER(node)                      \
    CNE_INIT(cne_node_register_##node)               \
    {                                                \
        node.parent_id = CNE_NODE_ID_INVALID;        \
        node.id        = __cne_node_register(&node); \
    }
 
CNDP_API cne_node_t cne_node_clone(cne_node_t id, const char *name);
 
CNDP_API cne_node_t cne_node_from_name(const char *name);
 
CNDP_API char *cne_node_id_to_name(cne_node_t id);
 
CNDP_API cne_edge_t cne_node_edge_count(cne_node_t id);
 
CNDP_API cne_edge_t cne_node_edge_update(cne_node_t id, cne_edge_t from, const char **next_nodes,
                                         uint16_t nb_edges);
 
CNDP_API cne_edge_t cne_node_edge_shrink(cne_node_t id, cne_edge_t size);
 
CNDP_API cne_node_t cne_node_edge_get(cne_node_t id, char *next_nodes[]);
 
CNDP_API cne_node_t cne_node_max_count(void);
 
CNDP_API void cne_node_dump(FILE *f, cne_node_t id);
 
CNDP_API void cne_node_list_dump(FILE *f);
 
static __cne_always_inline int
cne_node_is_invalid(cne_node_t id)
{
    return (id == CNE_NODE_ID_INVALID);
}
 
static __cne_always_inline int
cne_edge_is_invalid(cne_edge_t id)
{
    return (id == CNE_EDGE_ID_INVALID);
}
 
static __cne_always_inline int
cne_graph_is_invalid(cne_graph_t id)
{
    return (id == CNE_GRAPH_ID_INVALID);
}
 
static __cne_always_inline int
cne_graph_has_stats_feature(void)
{
    return 1;
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* _CNE_GRAPH_H_ */