#undef _
};
+
+static_always_inline void
+ibv_set_recv_wr_and_sge (struct ibv_recv_wr *w, struct ibv_sge *s, u64 va,
+ u32 data_size, u32 lkey)
+{
+ s[0].addr = va;
+ s[0].length = data_size;
+ s[0].lkey = lkey;
+ w[0].next = w + 1;
+ w[0].sg_list = s;
+ w[0].num_sge = 1;
+}
+
static_always_inline void
rdma_device_input_refill (vlib_main_t * vm, rdma_device_t * rd,
rdma_rxq_t * rxq)
{
u32 n_alloc, n;
- u32 buffers[VLIB_FRAME_SIZE], *bi = buffers;
- vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b = bufs;
struct ibv_recv_wr wr[VLIB_FRAME_SIZE], *w = wr;
struct ibv_sge sge[VLIB_FRAME_SIZE], *s = sge;
+ u32 mask = rxq->size - 1;
+ u32 slot = rxq->tail & mask;
+ u32 *bufs = rxq->bufs + slot;
+ u32 data_size = vlib_buffer_get_default_data_size (vm);
+ u32 lkey = rd->lkey;
+
+ /* do not enqueue more packet than ring space */
+ n_alloc = clib_min (VLIB_FRAME_SIZE, rxq->size - (rxq->tail - rxq->head));
- if (PREDICT_FALSE (rxq->n_enq >= rxq->size))
+ /* do not bother to allocate if too small */
+ if (n_alloc < 16)
return;
- n_alloc = clib_min (VLIB_FRAME_SIZE, rxq->size - rxq->n_enq);
- n_alloc = n = vlib_buffer_alloc (vm, buffers, n_alloc);
- vlib_get_buffers (vm, buffers, bufs, n_alloc);
+ /* avoid wrap-around logic in core loop */
+ n_alloc = clib_min (n_alloc, rxq->size - slot);
- while (n >= 4)
+ n_alloc &= ~7; /* round to 8 */
+
+ n = vlib_buffer_alloc_to_ring_from_pool (vm, rxq->bufs, slot, rxq->size,
+ n_alloc, rd->pool);
+
+ if (PREDICT_FALSE (n != n_alloc))
{
- if (PREDICT_TRUE (n >= 8))
+ u32 n_free;
+ if (n < 8)
{
- CLIB_PREFETCH (&s[4 + 0], 4 * sizeof (s[0]), STORE);
- CLIB_PREFETCH (&w[4 + 0], 4 * sizeof (w[0]), STORE);
+ if (n)
+ vlib_buffer_free_from_ring (vm, rxq->bufs, slot, rxq->size, n);
+ return;
}
- s[0].addr = vlib_buffer_get_va (b[0]);
- s[0].length = vlib_buffer_get_default_data_size (vm);
- s[0].lkey = rd->mr->lkey;
-
- s[1].addr = vlib_buffer_get_va (b[1]);
- s[1].length = vlib_buffer_get_default_data_size (vm);
- s[1].lkey = rd->mr->lkey;
-
- s[2].addr = vlib_buffer_get_va (b[2]);
- s[2].length = vlib_buffer_get_default_data_size (vm);
- s[2].lkey = rd->mr->lkey;
-
- s[3].addr = vlib_buffer_get_va (b[3]);
- s[3].length = vlib_buffer_get_default_data_size (vm);
- s[3].lkey = rd->mr->lkey;
-
- w[0].wr_id = bi[0];
- w[0].next = &w[0] + 1;
- w[0].sg_list = &s[0];
- w[0].num_sge = 1;
-
- w[1].wr_id = bi[1];
- w[1].next = &w[1] + 1;
- w[1].sg_list = &s[1];
- w[1].num_sge = 1;
-
- w[2].wr_id = bi[2];
- w[2].next = &w[2] + 1;
- w[2].sg_list = &s[2];
- w[2].num_sge = 1;
-
- w[3].wr_id = bi[3];
- w[3].next = &w[3] + 1;
- w[3].sg_list = &s[3];
- w[3].num_sge = 1;
-
- s += 4;
- bi += 4;
- w += 4;
- b += 4;
- n -= 4;
+ /* partial allocation, round and return rest */
+ n_free = n - (n & 7);
+ n -= n_free;
+ if (n_free)
+ vlib_buffer_free_from_ring (vm, rxq->bufs, (slot + n) & mask,
+ rxq->size, n_free);
}
- while (n >= 1)
+ n_alloc = n;
+
+ while (n >= 8)
{
- s[0].addr = vlib_buffer_get_va (b[0]);
- s[0].length = vlib_buffer_get_default_data_size (vm);
- s[0].lkey = rd->mr->lkey;
-
- w[0].wr_id = bi[0];
- w[0].next = &w[0] + 1;
- w[0].sg_list = &s[0];
- w[0].num_sge = 1;
-
- s += 1;
- bi += 1;
- w += 1;
- b += 1;
- n -= 1;
+ u64 va[8];
+ if (PREDICT_TRUE (n >= 16))
+ {
+ clib_prefetch_store (s + 16);
+ clib_prefetch_store (w + 16);
+ }
+
+ vlib_get_buffers_with_offset (vm, bufs, (void **) va, 8,
+ sizeof (vlib_buffer_t));
+
+ ibv_set_recv_wr_and_sge (w++, s++, va[0], data_size, lkey);
+ ibv_set_recv_wr_and_sge (w++, s++, va[1], data_size, lkey);
+ ibv_set_recv_wr_and_sge (w++, s++, va[2], data_size, lkey);
+ ibv_set_recv_wr_and_sge (w++, s++, va[3], data_size, lkey);
+ ibv_set_recv_wr_and_sge (w++, s++, va[4], data_size, lkey);
+ ibv_set_recv_wr_and_sge (w++, s++, va[5], data_size, lkey);
+ ibv_set_recv_wr_and_sge (w++, s++, va[6], data_size, lkey);
+ ibv_set_recv_wr_and_sge (w++, s++, va[7], data_size, lkey);
+
+ bufs += 8;
+ n -= 8;
}
w[-1].next = 0; /* fix next pointer in WR linked-list last item */
if (ibv_post_wq_recv (rxq->wq, wr, &w) != 0)
{
n = w - wr;
- vlib_buffer_free (vm, buffers + n, n_alloc - n);
+ vlib_buffer_free_from_ring (vm, rxq->bufs, slot + n, rxq->size,
+ n_alloc - n);
}
- rxq->n_enq += n;
+ rxq->tail += n;
}
static_always_inline void
rdma_device_input_trace (vlib_main_t * vm, vlib_node_runtime_t * node,
- const rdma_device_t * rd, u32 n_left, const u32 * bi)
+ const rdma_device_t * rd, u32 n_left, const u32 * bi,
+ u32 next_index)
{
u32 n_trace, i;
vlib_buffer_t *b;
rdma_input_trace_t *tr;
b = vlib_get_buffer (vm, bi[0]);
- vlib_trace_buffer (vm, node, rd->per_interface_next_index, b,
+ vlib_trace_buffer (vm, node, next_index, b,
/* follow_chain */ 0);
tr = vlib_add_trace (vm, node, b, sizeof (*tr));
- tr->next_index = rd->per_interface_next_index;
+ tr->next_index = next_index;
tr->hw_if_index = rd->hw_if_index;
/* next */
static_always_inline void
rdma_device_input_ethernet (vlib_main_t * vm, vlib_node_runtime_t * node,
- const rdma_device_t * rd)
+ const rdma_device_t * rd, u32 next_index)
{
vlib_next_frame_t *nf;
vlib_frame_t *f;
ethernet_input_frame_t *ef;
- if (PREDICT_FALSE
- (VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT != rd->per_interface_next_index))
+ if (PREDICT_FALSE (VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT != next_index))
return;
nf =
- vlib_node_runtime_get_next_frame (vm, node, rd->per_interface_next_index);
+ vlib_node_runtime_get_next_frame (vm, node,
+ VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT);
f = vlib_get_frame (vm, nf->frame);
f->flags = ETH_INPUT_FRAME_F_SINGLE_SW_IF_IDX;
/* FIXME: f->flags |= ETH_INPUT_FRAME_F_IP4_CKSUM_OK; */
}
static_always_inline u32
-rdma_device_input_load_wc (u32 n_left_from, struct ibv_wc * wc, u32 * to_next,
- u32 * bufsz)
+rdma_device_input_bufs (vlib_main_t * vm, const rdma_device_t * rd, u32 * bi,
+ struct ibv_wc * wc, u32 n_left_from,
+ vlib_buffer_t * bt)
{
- u32 n_rx_bytes[4] = { 0 };
+ vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b = bufs;
+ u32 n_rx_bytes = 0;
+
+ vlib_get_buffers (vm, bi, bufs, n_left_from);
+ ASSERT (bt->buffer_pool_index == bufs[0]->buffer_pool_index);
while (n_left_from >= 4)
{
CLIB_PREFETCH (&wc[4 + 1], CLIB_CACHE_LINE_BYTES, LOAD);
CLIB_PREFETCH (&wc[4 + 2], CLIB_CACHE_LINE_BYTES, LOAD);
CLIB_PREFETCH (&wc[4 + 3], CLIB_CACHE_LINE_BYTES, LOAD);
- CLIB_PREFETCH (&bufsz[4 + 0], 4 * sizeof (bufsz[0]), STORE);
- CLIB_PREFETCH (&to_next[4 + 0], 4 * sizeof (to_next[0]), STORE);
+ vlib_prefetch_buffer_header (b[4 + 0], STORE);
+ vlib_prefetch_buffer_header (b[4 + 1], STORE);
+ vlib_prefetch_buffer_header (b[4 + 2], STORE);
+ vlib_prefetch_buffer_header (b[4 + 3], STORE);
}
- to_next[0] = wc[0].wr_id;
- to_next[1] = wc[1].wr_id;
- to_next[2] = wc[2].wr_id;
- to_next[3] = wc[3].wr_id;
-
- bufsz[0] = wc[0].byte_len;
- bufsz[1] = wc[1].byte_len;
- bufsz[2] = wc[2].byte_len;
- bufsz[3] = wc[3].byte_len;
+ vlib_buffer_copy_template (b[0], bt);
+ vlib_buffer_copy_template (b[1], bt);
+ vlib_buffer_copy_template (b[2], bt);
+ vlib_buffer_copy_template (b[3], bt);
- n_rx_bytes[0] += wc[0].byte_len;
- n_rx_bytes[1] += wc[1].byte_len;
- n_rx_bytes[2] += wc[2].byte_len;
- n_rx_bytes[3] += wc[3].byte_len;
+ n_rx_bytes += b[0]->current_length = wc[0].byte_len;
+ n_rx_bytes += b[1]->current_length = wc[1].byte_len;
+ n_rx_bytes += b[2]->current_length = wc[2].byte_len;
+ n_rx_bytes += b[3]->current_length = wc[3].byte_len;
+ b += 4;
wc += 4;
- to_next += 4;
- bufsz += 4;
n_left_from -= 4;
}
while (n_left_from >= 1)
{
- to_next[0] = wc[0].wr_id;
- bufsz[0] = wc[0].byte_len;
- n_rx_bytes[0] += wc[0].byte_len;
+ vlib_buffer_copy_template (b[0], bt);
+ n_rx_bytes += b[0]->current_length = wc[0].byte_len;
+ b += 1;
wc += 1;
- to_next += 1;
- bufsz += 1;
n_left_from -= 1;
}
- return n_rx_bytes[0] + n_rx_bytes[1] + n_rx_bytes[2] + n_rx_bytes[3];
-}
-
-static_always_inline void
-rdma_device_input_bufs_init (u32 n_left_from, vlib_buffer_t ** bufs,
- u32 * bufsz, u32 sw_if_index)
-{
- while (n_left_from >= 4)
- {
- if (PREDICT_TRUE (n_left_from >= 8))
- {
- vlib_prefetch_buffer_header (bufs[4 + 0], STORE);
- vlib_prefetch_buffer_header (bufs[4 + 1], STORE);
- vlib_prefetch_buffer_header (bufs[4 + 2], STORE);
- vlib_prefetch_buffer_header (bufs[4 + 3], STORE);
- CLIB_PREFETCH (&bufsz[4 + 0], 4 * sizeof (bufsz[0]), LOAD);
- }
-
- bufs[0]->current_length = bufsz[0];
- bufs[1]->current_length = bufsz[1];
- bufs[2]->current_length = bufsz[2];
- bufs[3]->current_length = bufsz[3];
-
- vnet_buffer (bufs[0])->sw_if_index[VLIB_RX] = sw_if_index;
- vnet_buffer (bufs[1])->sw_if_index[VLIB_RX] = sw_if_index;
- vnet_buffer (bufs[2])->sw_if_index[VLIB_RX] = sw_if_index;
- vnet_buffer (bufs[3])->sw_if_index[VLIB_RX] = sw_if_index;
-
- vnet_buffer (bufs[0])->sw_if_index[VLIB_TX] = ~0;
- vnet_buffer (bufs[1])->sw_if_index[VLIB_TX] = ~0;
- vnet_buffer (bufs[2])->sw_if_index[VLIB_TX] = ~0;
- vnet_buffer (bufs[3])->sw_if_index[VLIB_TX] = ~0;
-
- bufs += 4;
- bufsz += 4;
- n_left_from -= 4;
- }
-
- while (n_left_from >= 1)
- {
- bufs[0]->current_length = bufsz[0];
- vnet_buffer (bufs[0])->sw_if_index[VLIB_RX] = sw_if_index;
- vnet_buffer (bufs[0])->sw_if_index[VLIB_TX] = ~0;
-
- bufs += 1;
- bufsz += 1;
- n_left_from -= 1;
- }
+ return n_rx_bytes;
}
static_always_inline uword
rdma_device_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
vlib_frame_t * frame, rdma_device_t * rd, u16 qid)
{
+ rdma_main_t *rm = &rdma_main;
vnet_main_t *vnm = vnet_get_main ();
+ rdma_per_thread_data_t *ptd = vec_elt_at_index (rm->per_thread_data,
+ vm->thread_index);
rdma_rxq_t *rxq = vec_elt_at_index (rd->rxqs, qid);
struct ibv_wc wc[VLIB_FRAME_SIZE];
- u32 bufsz[VLIB_FRAME_SIZE];
- vlib_buffer_t *bufs[VLIB_FRAME_SIZE];
- u32 *to_next, n_left_to_next;
+ vlib_buffer_t bt;
+ u32 next_index, *to_next, n_left_to_next;
u32 n_rx_packets, n_rx_bytes;
+ u32 mask = rxq->size - 1;
+
+ ASSERT (rxq->size >= VLIB_FRAME_SIZE && is_pow2 (rxq->size));
+ ASSERT (rxq->tail - rxq->head <= rxq->size);
n_rx_packets = ibv_poll_cq (rxq->cq, VLIB_FRAME_SIZE, wc);
+ ASSERT (n_rx_packets <= rxq->tail - rxq->head);
if (PREDICT_FALSE (n_rx_packets <= 0))
- {
- rdma_device_input_refill (vm, rd, rxq);
- return 0;
- }
+ goto refill;
+
+ /* init buffer template */
+ vlib_buffer_copy_template (&bt, &ptd->buffer_template);
+ vnet_buffer (&bt)->sw_if_index[VLIB_RX] = rd->sw_if_index;
+ bt.buffer_pool_index = rd->pool;
- vlib_get_new_next_frame (vm, node, rd->per_interface_next_index, to_next,
- n_left_to_next);
- n_rx_bytes = rdma_device_input_load_wc (n_rx_packets, wc, to_next, bufsz);
- vlib_get_buffers (vm, to_next, bufs, n_rx_packets);
- rdma_device_input_bufs_init (n_rx_packets, bufs, bufsz, rd->sw_if_index);
- rdma_device_input_trace (vm, node, rd, n_rx_packets, to_next);
- rdma_device_input_ethernet (vm, node, rd);
+ /* update buffer template for input feature arcs if any */
+ next_index = rd->per_interface_next_index;
+ if (PREDICT_FALSE (vnet_device_input_have_features (rd->sw_if_index)))
+ vnet_feature_start_device_input_x1 (rd->sw_if_index, &next_index, &bt);
- vlib_put_next_frame (vm, node, rd->per_interface_next_index,
- n_left_to_next - n_rx_packets);
+ vlib_get_new_next_frame (vm, node, next_index, to_next, n_left_to_next);
+ ASSERT (n_rx_packets <= n_left_to_next);
+
+ vlib_buffer_copy_indices_from_ring (to_next, rxq->bufs, rxq->head & mask,
+ rxq->size, n_rx_packets);
+ n_rx_bytes = rdma_device_input_bufs (vm, rd, to_next, wc, n_rx_packets,
+ &bt);
+
+ rdma_device_input_ethernet (vm, node, rd, next_index);
+
+ vlib_put_next_frame (vm, node, next_index, n_left_to_next - n_rx_packets);
+
+ rxq->head += n_rx_packets;
+
+ rdma_device_input_trace (vm, node, rd, n_rx_packets, to_next, next_index);
vlib_increment_combined_counter
(vnm->interface_main.combined_sw_if_counters +
VNET_INTERFACE_COUNTER_RX, vm->thread_index,
rd->hw_if_index, n_rx_packets, n_rx_bytes);
- rxq->n_enq -= n_rx_packets;
-
+refill:
rdma_device_input_refill (vm, rd, rxq);
return n_rx_packets;
/* *INDENT-OFF* */
VLIB_REGISTER_NODE (rdma_input_node) = {
.name = "rdma-input",
+ .flags = VLIB_NODE_FLAG_TRACE_SUPPORTED,
.sibling_of = "device-input",
.format_trace = format_rdma_input_trace,
.type = VLIB_NODE_TYPE_INPUT,
Code Review / vpp.git / blobdiff