cne_vec.h

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright (c) 2016-2022 Intel Corporation
 */
 
#ifndef __CNE_VEC_H
#define __CNE_VEC_H
 
#include <stdint.h>        // for uint16_t, uint32_t, uint64_t
#include <stdio.h>         // for NULL, FILE
#include <stdlib.h>        // for free
 
#include <cne_common.h>        // for __cne_always_inline, CNDP_API
#include <cne_prefetch.h>
#include <cne_stdio.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define VEC_REALLOC_SIZE 8 
typedef struct vec_hdr {
    uint32_t len;     
    uint32_t alen;    
    uint16_t esize;   
    uint16_t rsvd[3]; 
    uint8_t data[0];  
} vec_hdr_t;
 
#define _V(_x) _v_##_x
 
static inline vec_hdr_t *
vec_header(void *vec)
{
    return (vec_hdr_t *)((vec) ? CNE_PTR_SUB(vec, sizeof(vec_hdr_t)) : NULL);
}
 
#define vec_end(vec) &(vec)[vec_header(vec)->len]
 
#define vec_init(hv, al, es)                 \
    ({                                       \
        vec_hdr_t *_V(hx);                   \
        _V(hx)          = (vec_hdr_t *)(hv); \
        _V(hx)->len     = 0;                 \
        _V(hx)->alen    = al;                \
        _V(hx)->esize   = es;                \
        _V(hx)->rsvd[0] = 0;                 \
        _V(hx)->rsvd[1] = 0;                 \
        _V(hx)->rsvd[2] = 0;                 \
        (void *)_V(hx)->data;                \
    })
 
static __cne_always_inline void *
_vec_realloc_data(void *vec, uint32_t nelem, uint32_t esize)
{
    vec_hdr_t *h;
    uint32_t sz = (nelem * esize) + sizeof(vec_hdr_t);
 
    h = (vec) ? vec_header(vec) : NULL;
    h = realloc(h, sz);
    if (!h)
        return NULL;
    if (!vec)
        memset(h, 0, sz);
    h->alen  = nelem;
    h->esize = esize;
    return (void *)h->data;
}
 
#define _vec_realloc(vec, nelem, esize) _vec_realloc_data((vec), nelem, esize)
 
#define vec_free(v)              \
    ({                           \
        if (v)                   \
            free(vec_header(v)); \
        NULL;                    \
    })
 
#define vec_alloc(vec, nelem)                                     \
    ({                                                            \
        if ((vec))                                                \
            CNE_ERR("Vector all ready allocated\n");              \
        else                                                      \
            (vec) = _vec_realloc((vec), nelem, sizeof((vec)[0])); \
        (vec);                                                    \
    })
 
#define vec_foreach(var, vec) for ((var) = (vec); (vec) && (var < vec_end(vec)); var++)
 
#define vec_foreach_ptr(var, vec) \
    for (uint32_t _V(_i) = 0; (vec) && (var = (vec)[_V(_i)], _V(_i) < vec_len(vec)); _V(_i)++)
 
#define vec_calc_size(n, _t) \
    CNE_ALIGN_CEIL((n * sizeof(_t)) + sizeof(vec_hdr_t), CNE_CACHE_LINE_SIZE)
 
#define vec_len(v) ((v) ? vec_header(v)->len : 0)
 
static inline void
vec_set_len(void *v, int len)
{
    vec_hdr_t *hdr = (vec_hdr_t *)vec_header(v);
 
    if (hdr)
        hdr->len = len;
}
 
#define vec_max_len(v) ((v) ? vec_header(v)->alen : 0)
 
#define vec_dec_len(v) ((v) ? vec_header(v)->len-- : 0)
 
#define vec_at_index(vec, n) (vec)[(n)]
 
#define vec_addr_at_index(vec, n) &(vec)[(n)]
 
#define vec_pop(vec) ((vec) ? (vec)[--vec_header(vec)->len] : 0)
 
#define vec_inc_len(v) ((v) ? vec_header(v)->len++ : 0)
 
static inline int
_vec_find_index(void **vec, void *v)
{
    for (uint32_t i = 0; i < vec_len(vec); i++) {
        if (v == vec_at_index(vec, i))
            return i;
    }
    return -1;
}
 
#define vec_find_index(vec, v) _vec_find_index((void **)vec, (void *)v)
 
#define vec_add(vec, v)                                                              \
    ({                                                                               \
        if ((vec) == NULL) {                                                         \
            (vec) = _vec_realloc(NULL, VEC_REALLOC_SIZE, sizeof((vec)[0]));          \
            (vec) = vec_init(vec_header((vec)), VEC_REALLOC_SIZE, sizeof((vec)[0])); \
        }                                                                            \
        vec_hdr_t *_V(h) = vec_header((vec));                                        \
        int _V(l)        = _V(h)->len;                                               \
        if (_V(h)->len >= _V(h)->alen) {                                             \
            _V(h)->alen += VEC_REALLOC_SIZE;                                         \
            (vec) = _vec_realloc((vec), _V(h)->alen, _V(h)->esize);                  \
            _V(h) = vec_header((vec));                                               \
        }                                                                            \
        (vec)[_V(h)->len++] = (v);                                                   \
        _V(l);                                                                       \
    })
 
#define vec_full(vec)                               \
    ({                                              \
        vec_hdr_t *_V(h) = vec_header(vec);         \
        (_V(h)->len >= _V(h)->alen) ? true : false; \
    })
 
#define vec_move_at_index(t, f, n)      \
    do {                                \
        vec_add(t, vec_at_index(f, n)); \
        vec_at_index(f, n) = 0;         \
    } while (0)
 
#define vec_copy_at_index(to, from, idx)          \
    do {                                          \
        typeof(from) v = vec_at_index(from, idx); \
        vec_add(to, v);                           \
    } while (0)
 
static inline void
vec_remove(void *v, uint32_t nb)
{
    vec_hdr_t *h = vec_header(v);
 
    if (h && h->len && nb <= h->len) {
        int n = h->len - nb;
 
        if (n > 0)
            memmove(v, CNE_PTR_ADD(v, (nb * h->esize)), n * h->esize);
        h->len = n;
    }
}
 
static inline void
vec_dump(const char *msg, void *vec)
{
    vec_hdr_t *h;
 
    cne_printf("  [orange]%-8s[]  ", msg ? msg : "");
    if (!vec) {
        cne_printf(" *** Vector is NULL ***\n");
        return;
    }
 
    h = vec_header(vec);
 
    cne_printf(" @  %p, ", vec);
    cne_printf("len    %5d, ", h->len);
    cne_printf("alen   %5d, ", h->alen);
    cne_printf("esize  %5d\n", h->esize);
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* __CNE_VEC_H */