graph_private.h

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright (c) 2020 Marvell International Ltd.
 */
 
#ifndef _CNE_GRAPH_PRIVATE_H_
#define _CNE_GRAPH_PRIVATE_H_
 
#include <inttypes.h>
#include <sys/queue.h>
 
#include <cne_common.h>
 
#include "cne_graph.h"
#include "cne_graph_worker.h"
 
#define GRAPH_LOG(level, ...)                    \
    cne_log(CNE_LOG_##level, __func__, __LINE__, \
            CNE_FMT("GRAPH: " CNE_FMT_HEAD(__VA_ARGS__, ) "\n", CNE_FMT_TAIL(__VA_ARGS__, )))
 
#define graph_err(...)  GRAPH_LOG(ERR, __VA_ARGS__)
#define graph_info(...) GRAPH_LOG(INFO, __VA_ARGS__)
#define graph_dbg(...)  GRAPH_LOG(DEBUG, __VA_ARGS__)
 
#define ID_CHECK(id, id_max)    \
    do {                        \
        if ((id) >= (id_max)) { \
            errno = EINVAL;     \
            goto fail;          \
        }                       \
    } while (0)
 
#define SET_ERR_JMP(err, where, fmt, ...) \
    do {                                  \
        graph_err(fmt, ##__VA_ARGS__);    \
        errno = err;                      \
        goto where;                       \
    } while (0)
 
struct node {
    STAILQ_ENTRY(node) next;              
    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;                  
    char next_nodes[][CNE_NODE_NAMESIZE]; 
};
 
struct graph_node {
    STAILQ_ENTRY(graph_node) next;       
    struct node *node;                   
    bool visited;                        
    struct graph_node *adjacency_list[]; 
};
 
struct graph {
    STAILQ_ENTRY(graph) next;      
    char name[CNE_GRAPH_NAMESIZE]; 
    cne_graph_off_t nodes_start;   
    cne_node_t src_node_count;     
    struct cne_graph *graph;       
    cne_node_t node_count;         
    uint32_t cir_start;            
    uint32_t cir_mask;             
    cne_graph_t id;                
    size_t mem_sz;                 
    STAILQ_HEAD(gnode_list, graph_node) node_list; 
};
 
/* Node functions */
 
STAILQ_HEAD(node_head, node);
 
struct node_head *node_list_head_get(void);
 
struct node *node_from_name(const char *name);
 
/* Graph list functions */
 
STAILQ_HEAD(graph_head, graph);
 
struct graph_head *graph_list_head_get(void);
 
/* Lock functions */
 
void graph_spinlock_lock(void);
 
void graph_spinlock_unlock(void);
 
/* Graph operations */
 
int graph_bfs(struct graph *graph, struct graph_node *start);
 
int graph_has_isolated_node(struct graph *graph);
 
int graph_node_has_edge_to_src_node(struct graph *graph);
 
int graph_node_has_loop_edge(struct graph *graph);
 
cne_node_t graph_src_nodes_count(struct graph *graph);
 
cne_node_t graph_nodes_count(struct graph *graph);
 
void graph_mark_nodes_as_not_visited(struct graph *graph);
 
/* Fast path graph memory populate unctions */
 
int graph_fp_mem_create(struct graph *graph);
 
int graph_fp_mem_destroy(struct graph *graph);
 
/* Lookup functions */
 
struct cne_node *graph_node_id_to_ptr(const struct cne_graph *graph, cne_node_t id);
 
struct cne_node *graph_node_name_to_ptr(const struct cne_graph *graph, const char *node_name);
 
/* Debug functions */
 
void graph_dump(FILE *f, struct graph *g);
 
void node_dump(FILE *f, struct node *n, bool hdr);
 
#endif /* _CNE_GRAPH_PRIVATE_H_ */