/* Simplified pseudocode of vlib_main_loop (src/vlib/main.c) */
while (1) {
  /* 1. Poll all INPUT nodes */
  foreach input_node:
    vectors = input_node.fn(vm, node, frame);
    /* vectors returned drives adaptive polling rate */

  /* 2. Run INTERNAL nodes that have pending frames */
  while pending_frames:
    dispatch_node(next_pending_node);
    /* this may enqueue more frames to other nodes */

  /* 3. Run PROCESS nodes that are ready */
  foreach ready_process:
    resume_process(proc);

  /* 4. Adaptive sleep if no work (avoids busy-spin at 0 pps) */
  if (total_vectors == 0):
    sleep_us(min(sleep_us * 2, max_sleep_us));
  else:
    sleep_us = 0;  /* busy poll when traffic present */
}

/* Get pointer to current header (L2, L3, or wherever we are) */
void *hdr = vlib_buffer_get_current(b);

/* Advance past current header (e.g. past Ethernet to reach IP) */
vlib_buffer_advance(b, sizeof(ethernet_header_t));
/* current_data += sizeof(eth_hdr); current_length -= sizeof(eth_hdr) */

/* Step back (e.g. to prepend an encap header) */
vlib_buffer_advance(b, -sizeof(ip4_header_t));

/* Access vnet buffer opaque (contains L3/L4 metadata) */
vnet_buffer_opaque_t *vo = vnet_buffer(b);
u32 adj_idx   = vo->ip.adj_index[VLIB_TX];
u32 sw_if_idx = vo->sw_if_index[VLIB_RX];

/* Get buffer from index (O(1) - base + offset) */
vlib_buffer_t *b = vlib_get_buffer(vm, buf_index);

/* Get buffer index from pointer */
u32 bi = vlib_get_buffer_index(vm, b);

/* Prefetch next buffer's header - critical for dual-loop perf */
vlib_buffer_t *p2 = vlib_get_buffer(vm, from[2]);
CLIB_PREFETCH(&p2->data, sizeof(*ip0), LOAD);

/* Allocate and free buffers */
u32 bi;
vlib_buffer_alloc(vm, &bi, 1);    /* allocate 1 buffer */
vlib_buffer_free(vm, &bi, 1);     /* free 1 buffer */

/* Clone a buffer (reference counting) */
vlib_buffer_clone(vm, src_bi, &dst_bi, 1, head_end_offset);

static uword
my_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
            vlib_frame_t *frame)
{
  u32 n_left_from, *from;
  u16 nexts[VLIB_FRAME_SIZE], *next = nexts;

  from        = vlib_frame_vector_args(frame);
  n_left_from = frame->n_vectors;

  /* ── Prefetch first 4 buffers before entering loop ── */
  {
    vlib_buffer_t *p;
    p = vlib_get_buffer(vm, from[0]); vlib_prefetch_buffer_header(p, LOAD);
    p = vlib_get_buffer(vm, from[1]); vlib_prefetch_buffer_header(p, LOAD);
    p = vlib_get_buffer(vm, from[2]); vlib_prefetch_buffer_header(p, LOAD);
    p = vlib_get_buffer(vm, from[3]); vlib_prefetch_buffer_header(p, LOAD);
  }

  /* ── DUAL LOOP: 2 packets per iteration ─────────── */
  while (n_left_from >= 4) {
    vlib_buffer_t *b0, *b1;
    u32 bi0, bi1;

    /* Prefetch 2 buffers ahead (hides DRAM latency) */
    {
      vlib_buffer_t *p2 = vlib_get_buffer(vm, from[2]);
      vlib_buffer_t *p3 = vlib_get_buffer(vm, from[3]);
      vlib_prefetch_buffer_header(p2, LOAD);
      vlib_prefetch_buffer_header(p3, LOAD);
      CLIB_PREFETCH(p2->data, CLIB_CACHE_LINE_BYTES, LOAD);
      CLIB_PREFETCH(p3->data, CLIB_CACHE_LINE_BYTES, LOAD);
    }

    bi0 = from[0]; bi1 = from[1];
    from += 2; n_left_from -= 2;

    b0 = vlib_get_buffer(vm, bi0);   /* now in cache - no stall */
    b1 = vlib_get_buffer(vm, bi1);

    /* ── YOUR PROCESSING LOGIC FOR b0 AND b1 ── */
    ip4_header_t *ip0 = vlib_buffer_get_current(b0);
    ip4_header_t *ip1 = vlib_buffer_get_current(b1);

    next[0] = classify_packet(ip0);   /* determine next node */
    next[1] = classify_packet(ip1);
    next += 2;
    /* ─────────────────────────────────────────── */
  }

  /* ── SINGLE LOOP: handle remaining 0-3 packets ── */
  while (n_left_from > 0) {
    vlib_buffer_t *b0 = vlib_get_buffer(vm, from[0]);
    next[0] = classify_packet(vlib_buffer_get_current(b0));
    from++; next++; n_left_from--;
  }

  /* Enqueue all packets to their respective next nodes */
  vlib_buffer_enqueue_to_next(vm, node, vlib_frame_vector_args(frame),
                              nexts, frame->n_vectors);
  return frame->n_vectors;
}

/* Define errors with a foreach macro (standard VPP convention) */
#define foreach_my_node_error  \
  _(PROCESSED,   "packets processed") \
  _(NO_FLOW,     "flow not found")    \
  _(CHECKSUM,    "checksum error")

typedef enum {
#define _(n,s) MY_NODE_ERROR_##n,
  foreach_my_node_error
#undef _
  MY_NODE_N_ERROR,
} my_node_error_t;

static char * my_node_error_strings[] = {
#define _(n,s) s,
  foreach_my_node_error
#undef _
};

/* Increment a counter (atomic, safe from any worker) */
vlib_node_increment_counter(vm, my_node.index,
                            MY_NODE_ERROR_PROCESSED, n_processed);