buffer_node.h File Reference

vlib buffer/node functions More...

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	vlib_validate_buffer_enqueue_x2(vm, node, next_index, to_next, n_left_to_next, bi0, bi1, next0, next1)
	Finish enqueueing two buffers forward in the graph. More...
#define	vlib_validate_buffer_enqueue_x4(vm, node, next_index, to_next, n_left_to_next, bi0, bi1, bi2, bi3, next0, next1, next2, next3)
	Finish enqueueing four buffers forward in the graph. More...
#define	vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next, n_left_to_next, bi0, next0)
	Finish enqueueing one buffer forward in the graph. More...

Functions
static uword	generic_buffer_node_inline (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, uword sizeof_trace, void *opaque1, uword opaque2, void(*two_buffers)(vlib_main_t *vm, void *opaque1, uword opaque2, vlib_buffer_t *b0, vlib_buffer_t *b1, u32 *next0, u32 *next1), void(*one_buffer)(vlib_main_t *vm, void *opaque1, uword opaque2, vlib_buffer_t *b0, u32 *next0))

Detailed Description

vlib buffer/node functions

Definition in file buffer_node.h.

Macro Definition Documentation

#define vlib_validate_buffer_enqueue_x1	(		vm,
			node,
			next_index,
			to_next,
			n_left_to_next,
			bi0,
			next0
	)

Value:

do {                                                                    \
  if (PREDICT_FALSE (next0 != next_index))                              \
    {                                                                   \
      vlib_put_next_frame (vm, node, next_index, n_left_to_next + 1);   \
      next_index = next0;                                               \
      vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); \
                                                                        \
      to_next[0] = bi0;                                                 \
      to_next += 1;                                                     \
      n_left_to_next -= 1;                                              \
    }                                                                   \
} while (0)

Finish enqueueing one buffer forward in the graph.

Standard single loop boilerplate element. This is a MACRO, with MULTIPLE SIDE EFFECTS. In the ideal case, next_index == next0, which means that the speculative enqueue at the top of the single loop has correctly dealt with the packet in hand. In that case, the macro does nothing at all.

Parameters

vm	vlib_main_t pointer, varies by thread
node	current node vlib_node_runtime_t pointer
next_index	speculated next index used for both packets
to_next	speculated vector pointer used for both packets
n_left_to_next	number of slots left in speculated vector
bi0	first buffer index
next0	actual next index to be used for the first packet

Returns

next_index – speculative next index to be used for future packets

to_next – speculative frame to be used for future packets

n_left_to_next – number of slots left in speculative frame

Definition at line 218 of file buffer_node.h.

#define vlib_validate_buffer_enqueue_x2	(		vm,
			node,
			next_index,
			to_next,
			n_left_to_next,
			bi0,
			bi1,
			next0,
			next1
	)

Value:

do {                                                                    \
  int enqueue_code = (next0 != next_index) + 2*(next1 != next_index);   \
                                                                        \
  if (PREDICT_FALSE (enqueue_code != 0))                                \
    {                                                                   \
      switch (enqueue_code)                                             \
        {                                                               \
        case 1:                                                         \
          /* A B A */                                                   \
          to_next[-2] = bi1;                                            \
          to_next -= 1;                                                 \
          n_left_to_next += 1;                                          \
	  vlib_set_next_frame_buffer (vm, node, next0, bi0);           \
          break;                                                        \
                                                                        \
        case 2:                                                         \
          /* A A B */                                                   \
          to_next -= 1;                                                 \
          n_left_to_next += 1;                                          \
	  vlib_set_next_frame_buffer (vm, node, next1, bi1);           \
          break;                                                        \
                                                                        \
        case 3:                                                         \
          /* A B B or A B C */                                          \
          to_next -= 2;                                                 \
          n_left_to_next += 2;                                          \
	  vlib_set_next_frame_buffer (vm, node, next0, bi0);           \
	  vlib_set_next_frame_buffer (vm, node, next1, bi1);           \
          if (next0 == next1)                                           \
            {                                                           \
	      vlib_put_next_frame (vm, node, next_index,               \
                                   n_left_to_next);                     \
              next_index = next1;                                       \
	      vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); \
            }                                                           \
        }                                                               \
    }                                                                   \
} while (0)

Finish enqueueing two buffers forward in the graph.

Standard dual loop boilerplate element. This is a MACRO, with MULTIPLE SIDE EFFECTS. In the ideal case, next_index == next0 == next1, which means that the speculative enqueue at the top of the dual loop has correctly dealt with both packets. In that case, the macro does nothing at all.

Parameters

vm	vlib_main_t pointer, varies by thread
node	current node vlib_node_runtime_t pointer
next_index	speculated next index used for both packets
to_next	speculated vector pointer used for both packets
n_left_to_next	number of slots left in speculated vector
bi0	first buffer index
bi1	second buffer index
next0	actual next index to be used for the first packet
next1	actual next index to be used for the second packet

Returns

next_index – speculative next index to be used for future packets

to_next – speculative frame to be used for future packets

n_left_to_next – number of slots left in speculative frame

Definition at line 70 of file buffer_node.h.

#define vlib_validate_buffer_enqueue_x4	(		vm,
			node,
			next_index,
			to_next,
			n_left_to_next,
			bi0,
			bi1,
			bi2,
			bi3,
			next0,
			next1,
			next2,
			next3
	)

Finish enqueueing four buffers forward in the graph.

Standard quad loop boilerplate element. This is a MACRO, with MULTIPLE SIDE EFFECTS. In the ideal case, next_index == next0 == next1 == next2 == next3, which means that the speculative enqueue at the top of the quad loop has correctly dealt with all four packets. In that case, the macro does nothing at all.

Parameters

vm	vlib_main_t pointer, varies by thread
node	current node vlib_node_runtime_t pointer
next_index	speculated next index used for both packets
to_next	speculated vector pointer used for both packets
n_left_to_next	number of slots left in speculated vector
bi0	first buffer index
bi1	second buffer index
bi2	third buffer index
bi3	fourth buffer index
next0	actual next index to be used for the first packet
next1	actual next index to be used for the second packet
next2	actual next index to be used for the third packet
next3	actual next index to be used for the fourth packet

Returns

next_index – speculative next index to be used for future packets

to_next – speculative frame to be used for future packets

n_left_to_next – number of slots left in speculative frame

Definition at line 138 of file buffer_node.h.

Function Documentation

static uword generic_buffer_node_inline ( vlib_main_t *  vm, vlib_node_runtime_t *  node, vlib_frame_t *  frame, uword  sizeof_trace, void *  opaque1, uword  opaque2, void(*)(vlib_main_t *vm, void *opaque1, uword opaque2, vlib_buffer_t *b0, vlib_buffer_t *b1, u32 *next0, u32 *next1)  two_buffers, void(*)(vlib_main_t *vm, void *opaque1, uword opaque2, vlib_buffer_t *b0, u32 *next0)  one_buffer  )

inlinestatic

Definition at line 233 of file buffer_node.h.

Here is the call graph for this function: