/* my_node.c — packet counter plugin with canonical 4x loop */
#include <vnet/vnet.h>
#include <vnet/plugin/plugin.h>
#include <vpp/app/version.h>

VLIB_PLUGIN_REGISTER() = {
    .version     = VPP_BUILD_VER,
    .description = "Packet counter plugin",
};

typedef enum { MY_NEXT_IP4_LOOKUP, MY_NEXT_DROP, MY_N_NEXT } my_next_t;

typedef struct {
    u64 pkt_count[VLIB_MAX_WORKERS + 1];  /* per-thread, no locking */
} my_main_t;
my_main_t my_main;

VLIB_NODE_FN(my_counter_node)(vlib_main_t *vm,
                               vlib_node_runtime_t *node,
                               vlib_frame_t *frame)
{
    u32 n_left = frame->n_vectors;
    u32 *from  = vlib_frame_vector_args(frame);
    u16 nexts[VLIB_FRAME_SIZE], *next = nexts;
    u64 pkts = 0;

    /* ── 4x unrolled loop with prefetch ─────────────── */
    while (n_left >= 8) {
        /* Prefetch packet data 4 ahead */
        vlib_prefetch_buffer_with_index(vm, from[4], LOAD);
        vlib_prefetch_buffer_with_index(vm, from[5], LOAD);
        vlib_prefetch_buffer_with_index(vm, from[6], LOAD);
        vlib_prefetch_buffer_with_index(vm, from[7], LOAD);

        /* Get 4 buffers */
        vlib_buffer_t *b0 = vlib_get_buffer(vm, from[0]);
        vlib_buffer_t *b1 = vlib_get_buffer(vm, from[1]);
        vlib_buffer_t *b2 = vlib_get_buffer(vm, from[2]);
        vlib_buffer_t *b3 = vlib_get_buffer(vm, from[3]);
        (void)b0; (void)b1; (void)b2; (void)b3;

        next[0] = next[1] = next[2] = next[3] = MY_NEXT_IP4_LOOKUP;
        from += 4; next += 4; n_left -= 4; pkts += 4;
    }
    /* ── Scalar tail ─────────────────────────────────── */
    while (n_left > 0) {
        next[0] = MY_NEXT_IP4_LOOKUP;
        from++; next++; n_left--; pkts++;
    }

    my_main.pkt_count[vm->thread_index] += pkts;

    vlib_buffer_enqueue_to_next(vm, node,
        vlib_frame_vector_args(frame), nexts, frame->n_vectors);
    return frame->n_vectors;
}

VLIB_REGISTER_NODE(my_counter_node) = {
    .name          = "my-counter",
    .vector_size   = sizeof(u32),
    .type          = VLIB_NODE_TYPE_INTERNAL,
    .n_next_nodes  = MY_N_NEXT,
    .next_nodes    = {
        [MY_NEXT_IP4_LOOKUP] = "ip4-lookup",
        [MY_NEXT_DROP]       = "error-drop",
    },
};

/* Insert into ip4-unicast feature arc on an interface */
/* vnet_feature_enable_disable("ip4-unicast", "my-counter", sw_if_index, 1, 0, 0); */

/* CMakeLists.txt */
# add_vpp_plugin(my_plugin SOURCES my_node.c API_FILES my_plugin.api)
# Plugins auto-loaded from /usr/lib/vpp_plugins/ at VPP startup

/* show run output — interpreting the numbers */
vppctl show run
# Thread 1 vpp_wk_0 (lcore 2):
#   Name               State  Calls  Vectors  Clocks      Vec/Call  Clk/Vec
#   dpdk-input         active  1000  32000    8.70e+06     32.0     272
#   ip4-input          active  1000  32000    1.92e+06     32.0      60
#   ip4-lookup         active  1000  32000    2.84e+06     32.0      89
#   ip4-rewrite        active  1000  32000    1.44e+06     32.0      45
#   my-ngfw-dpi        active  1000  32000    9.60e+06     32.0     300

# Clk/Vec = CPU cycles per packet in this node (at 3GHz: 300 cycles = 100ns)
# Sum of all Clk/Vec = total cycles per packet through the pipeline
# my-ngfw-dpi is the bottleneck here (300 cycles vs 60-89 for built-ins)

/* Optimisation workflow */
1. Run: vppctl clear run; sleep 5; vppctl show run
2. Identify highest Clk/Vec node (your bottleneck)
3. Check: are we prefetching? 4x unrolled? NUMA-local memory?
4. Profile: perf stat -e cycles,cache-misses -C 2 sleep 5
5. Check vector sizes: Vectors/Call < 8 = under-loaded (not batching enough)

/* show errors — drop counter diagnosis */
vppctl show errors
# ip4-input: ip4 src address is multicast    12
# ip4-input: ip4 spoofed local-address       5
# acl-plugin-in-ip4-fa: ACL deny packets  4821

/* Buffer pressure — detect mempool exhaustion */
vppctl show buffers
# If "allocated" approaches "total": mempool running low → increase num-mbufs

/* Per-interface counters */
vppctl show interface GigabitEthernet0/8/0
# RX packets/bytes, TX packets/bytes, drops, errors
vppctl clear interfaces   # reset counters

/* Packet capture in VPP (pcap trace) */
pcap dispatch trace on max 1000 file /tmp/vpp.pcap
# ... generate traffic ...
pcap dispatch trace off
# Open /tmp/vpp.pcap in Wireshark — shows packet at each graph node!