src/vnet/gso/gro.h - fdio/vpp - Gitiles

 /*
  * Copyright (c) 2020 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #ifndef included_gro_h
 #define included_gro_h

 #include <vlib/vlib.h>
 #include <vppinfra/error.h>
 #include <vnet/ip/ip46_address.h>

 #define GRO_FLOW_TABLE_MAX_SIZE 16
 #define GRO_FLOW_TABLE_FLUSH 1e-5
 #define GRO_FLOW_N_BUFFERS 64
 #define GRO_FLOW_TIMEOUT 1e-5	/* 10 micro-seconds */
 #define GRO_TO_VECTOR_SIZE(X)   (X + GRO_FLOW_TABLE_MAX_SIZE)

 typedef union
 {
   struct
   {
     u32 sw_if_index[VLIB_N_RX_TX];
     ip46_address_t src_address;
     ip46_address_t dst_address;
     u16 src_port;
     u16 dst_port;
   };

   u64 flow_data[5];
   u32 flow_data_u32;
 } gro_flow_key_t;

 typedef struct
 {
   gro_flow_key_t flow_key;
   f64 next_timeout_ts;
   u32 last_ack_number;
   u32 buffer_index;
   u16 n_buffers;
 } gro_flow_t;

 typedef struct
 {
   f64 timeout_ts;
   u64 total_vectors;
   u32 n_vectors;
   u32 node_index;
   u8 is_enable;
   u8 is_l2;
   u8 flow_table_size;
   gro_flow_t gro_flow[GRO_FLOW_TABLE_MAX_SIZE];
 } gro_flow_table_t;

 static_always_inline void
 gro_flow_set_flow_key (gro_flow_t * to, gro_flow_key_t * from)
 {
   to->flow_key.flow_data[0] = from->flow_data[0];
   to->flow_key.flow_data[1] = from->flow_data[1];
   to->flow_key.flow_data[2] = from->flow_data[2];
   to->flow_key.flow_data[3] = from->flow_data[3];
   to->flow_key.flow_data[4] = from->flow_data[4];
   to->flow_key.flow_data_u32 = from->flow_data_u32;
 }

 static_always_inline u8
 gro_flow_is_equal (gro_flow_key_t * first, gro_flow_key_t * second)
 {
   if (first->flow_data[0] == second->flow_data[0] &&
       first->flow_data[1] == second->flow_data[1] &&
       first->flow_data[2] == second->flow_data[2] &&
       first->flow_data[3] == second->flow_data[3] &&
       first->flow_data[4] == second->flow_data[4] &&
       first->flow_data_u32 == second->flow_data_u32)
     return 1;

   return 0;
 }

 /**
  * timeout_expire is in between 3 to 10 microseconds
  * 3e-6 1e-5
  */
 static_always_inline void
 gro_flow_set_timeout (vlib_main_t * vm, gro_flow_t * gro_flow,
 		      f64 timeout_expire)
 {
   gro_flow->next_timeout_ts = vlib_time_now (vm) + timeout_expire;
 }

 static_always_inline u8
 gro_flow_is_timeout (vlib_main_t * vm, gro_flow_t * gro_flow)
 {
   if (gro_flow->next_timeout_ts < vlib_time_now (vm))
     return 1;
   return 0;
 }

 static_always_inline void
 gro_flow_store_packet (gro_flow_t * gro_flow, u32 bi0)
 {
   if (gro_flow->n_buffers == 0)
     {
       gro_flow->buffer_index = bi0;
     }
   gro_flow->n_buffers++;
 }

 static_always_inline u32
 gro_flow_table_init (gro_flow_table_t ** flow_table, u8 is_l2, u32 node_index)
 {
   if (*flow_table)
     return 0;

   gro_flow_table_t *flow_table_temp = 0;
   flow_table_temp =
     (gro_flow_table_t *) clib_mem_alloc (sizeof (gro_flow_table_t));
   if (!flow_table_temp)
     return 0;
   clib_memset (flow_table_temp, 0, sizeof (gro_flow_table_t));
   flow_table_temp->node_index = node_index;
   flow_table_temp->is_enable = 1;
   flow_table_temp->is_l2 = is_l2;
   *flow_table = flow_table_temp;
   return 1;
 }

 static_always_inline void
 gro_flow_table_set_timeout (vlib_main_t * vm, gro_flow_table_t * flow_table,
 			    f64 timeout_expire)
 {
   if (flow_table)
     flow_table->timeout_ts = vlib_time_now (vm) + timeout_expire;
 }

 static_always_inline u8
 gro_flow_table_is_timeout (vlib_main_t * vm, gro_flow_table_t * flow_table)
 {
   if (flow_table && (flow_table->timeout_ts < vlib_time_now (vm)))
     return 1;
   return 0;
 }

 static_always_inline u8
 gro_flow_table_is_enable (gro_flow_table_t * flow_table)
 {
   if (flow_table)
     return flow_table->is_enable;

   return 0;
 }

 static_always_inline void
 gro_flow_table_set_is_enable (gro_flow_table_t * flow_table, u8 is_enable)
 {
   if (flow_table)
     flow_table->is_enable = is_enable;
 }

 static_always_inline void
 gro_flow_table_free (gro_flow_table_t * flow_table)
 {
   if (flow_table)
     clib_mem_free (flow_table);
 }

 static_always_inline void
 gro_flow_table_set_node_index (gro_flow_table_t * flow_table, u32 node_index)
 {
   if (flow_table)
     flow_table->node_index = node_index;
 }

 static_always_inline gro_flow_t *
 gro_flow_table_new_flow (gro_flow_table_t * flow_table)
 {
   if (PREDICT_TRUE (flow_table->flow_table_size < GRO_FLOW_TABLE_MAX_SIZE))
     {
       gro_flow_t *gro_flow;
       u32 i = 0;
       while (i < GRO_FLOW_TABLE_MAX_SIZE)
 	{
 	  gro_flow = &flow_table->gro_flow[i];
 	  if (gro_flow->n_buffers == 0)
 	    {
 	      flow_table->flow_table_size++;
 	      return gro_flow;
 	    }
 	  i++;
 	}
     }

   return (0);
 }

 static_always_inline gro_flow_t *
 gro_flow_table_get_flow (gro_flow_table_t * flow_table,
 			 gro_flow_key_t * flow_key)
 {
   gro_flow_t *gro_flow = 0;
   u32 i = 0;
   while (i < GRO_FLOW_TABLE_MAX_SIZE)
     {
       gro_flow = &flow_table->gro_flow[i];
       if (gro_flow_is_equal (flow_key, &gro_flow->flow_key))
 	return gro_flow;
       i++;
     }
   return (0);
 }

 static_always_inline gro_flow_t *
 gro_flow_table_find_or_add_flow (gro_flow_table_t * flow_table,
 				 gro_flow_key_t * flow_key)
 {
   gro_flow_t *gro_flow = 0;

   gro_flow = gro_flow_table_get_flow (flow_table, flow_key);
   if (gro_flow)
     return gro_flow;

   gro_flow = gro_flow_table_new_flow (flow_table);

   if (gro_flow)
     {
       gro_flow_set_flow_key (gro_flow, flow_key);
       return gro_flow;
     }

   return (0);
 }

 static_always_inline void
 gro_flow_table_reset_flow (gro_flow_table_t * flow_table,
 			   gro_flow_t * gro_flow)
 {
   if (PREDICT_TRUE (flow_table->flow_table_size > 0))
     {
       clib_memset (gro_flow, 0, sizeof (gro_flow_t));
       flow_table->flow_table_size--;
     }
 }

 static_always_inline u8 *
 gro_flow_table_format (u8 * s, va_list * args)
 {
   gro_flow_table_t *flow_table = va_arg (*args, gro_flow_table_t *);
   u32 indent;

   if (!flow_table)
     return s;

   indent = format_get_indent (s);
   if (flow_table->is_enable)
     s = format (s, "packet-coalesce: enable\n");
   else
     s = format (s, "packet-coalesce: disable\n");

   indent += 2;

   s =
     format (s,
 	    "%Uflow-table: size %u gro-total-vectors %lu gro-n-vectors %u",
 	    format_white_space, indent, flow_table->flow_table_size,
 	    flow_table->total_vectors, flow_table->n_vectors);
   if (flow_table->n_vectors)
     {
       double average_rate =
 	(double) flow_table->total_vectors / (double) flow_table->n_vectors;
       s = format (s, " gro-average-rate %.2f", average_rate);
     }
   else
     s = format (s, " gro-average-rate 0.00");

   return s;
 }
 #endif /* included_gro_h */

 /*
  * fd.io coding-style-patch-verification: ON
  *
  * Local Variables:
  * eval: (c-set-style "gnu")
  * End:
  */
	/*
	* Copyright (c) 2020 Cisco and/or its affiliates.
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at:
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#ifndef included_gro_h
	#define included_gro_h

	#include <vlib/vlib.h>
	#include <vppinfra/error.h>
	#include <vnet/ip/ip46_address.h>

	#define GRO_FLOW_TABLE_MAX_SIZE 16
	#define GRO_FLOW_TABLE_FLUSH 1e-5
	#define GRO_FLOW_N_BUFFERS 64
	#define GRO_FLOW_TIMEOUT 1e-5 /* 10 micro-seconds */
	#define GRO_TO_VECTOR_SIZE(X) (X + GRO_FLOW_TABLE_MAX_SIZE)

	typedef union
	{
	struct
	{
	u32 sw_if_index[VLIB_N_RX_TX];
	ip46_address_t src_address;
	ip46_address_t dst_address;
	u16 src_port;
	u16 dst_port;
	};

	u64 flow_data[5];
	u32 flow_data_u32;
	} gro_flow_key_t;

	typedef struct
	{
	gro_flow_key_t flow_key;
	f64 next_timeout_ts;
	u32 last_ack_number;
	u32 buffer_index;
	u16 n_buffers;
	} gro_flow_t;

	typedef struct
	{
	f64 timeout_ts;
	u64 total_vectors;
	u32 n_vectors;
	u32 node_index;
	u8 is_enable;
	u8 is_l2;
	u8 flow_table_size;
	gro_flow_t gro_flow[GRO_FLOW_TABLE_MAX_SIZE];
	} gro_flow_table_t;

	static_always_inline void
	gro_flow_set_flow_key (gro_flow_t * to, gro_flow_key_t * from)
	{
	to->flow_key.flow_data[0] = from->flow_data[0];
	to->flow_key.flow_data[1] = from->flow_data[1];
	to->flow_key.flow_data[2] = from->flow_data[2];
	to->flow_key.flow_data[3] = from->flow_data[3];
	to->flow_key.flow_data[4] = from->flow_data[4];
	to->flow_key.flow_data_u32 = from->flow_data_u32;
	}

	static_always_inline u8
	gro_flow_is_equal (gro_flow_key_t * first, gro_flow_key_t * second)
	{
	if (first->flow_data[0] == second->flow_data[0] &&
	first->flow_data[1] == second->flow_data[1] &&
	first->flow_data[2] == second->flow_data[2] &&
	first->flow_data[3] == second->flow_data[3] &&
	first->flow_data[4] == second->flow_data[4] &&
	first->flow_data_u32 == second->flow_data_u32)
	return 1;

	return 0;
	}

	/**
	* timeout_expire is in between 3 to 10 microseconds
	* 3e-6 1e-5
	*/
	static_always_inline void
	gro_flow_set_timeout (vlib_main_t * vm, gro_flow_t * gro_flow,
	f64 timeout_expire)
	{
	gro_flow->next_timeout_ts = vlib_time_now (vm) + timeout_expire;
	}

	static_always_inline u8
	gro_flow_is_timeout (vlib_main_t * vm, gro_flow_t * gro_flow)
	{
	if (gro_flow->next_timeout_ts < vlib_time_now (vm))
	return 1;
	return 0;
	}

	static_always_inline void
	gro_flow_store_packet (gro_flow_t * gro_flow, u32 bi0)
	{
	if (gro_flow->n_buffers == 0)
	{
	gro_flow->buffer_index = bi0;
	}
	gro_flow->n_buffers++;
	}

	static_always_inline u32
	gro_flow_table_init (gro_flow_table_t ** flow_table, u8 is_l2, u32 node_index)
	{
	if (*flow_table)
	return 0;

	gro_flow_table_t *flow_table_temp = 0;
	flow_table_temp =
	(gro_flow_table_t *) clib_mem_alloc (sizeof (gro_flow_table_t));
	if (!flow_table_temp)
	return 0;
	clib_memset (flow_table_temp, 0, sizeof (gro_flow_table_t));
	flow_table_temp->node_index = node_index;
	flow_table_temp->is_enable = 1;
	flow_table_temp->is_l2 = is_l2;
	*flow_table = flow_table_temp;
	return 1;
	}

	static_always_inline void
	gro_flow_table_set_timeout (vlib_main_t * vm, gro_flow_table_t * flow_table,
	f64 timeout_expire)
	{
	if (flow_table)
	flow_table->timeout_ts = vlib_time_now (vm) + timeout_expire;
	}

	static_always_inline u8
	gro_flow_table_is_timeout (vlib_main_t * vm, gro_flow_table_t * flow_table)
	{
	if (flow_table && (flow_table->timeout_ts < vlib_time_now (vm)))
	return 1;
	return 0;
	}

	static_always_inline u8
	gro_flow_table_is_enable (gro_flow_table_t * flow_table)
	{
	if (flow_table)
	return flow_table->is_enable;

	return 0;
	}

	static_always_inline void
	gro_flow_table_set_is_enable (gro_flow_table_t * flow_table, u8 is_enable)
	{
	if (flow_table)
	flow_table->is_enable = is_enable;
	}

	static_always_inline void
	gro_flow_table_free (gro_flow_table_t * flow_table)
	{
	if (flow_table)
	clib_mem_free (flow_table);
	}

	static_always_inline void
	gro_flow_table_set_node_index (gro_flow_table_t * flow_table, u32 node_index)
	{
	if (flow_table)
	flow_table->node_index = node_index;
	}

	static_always_inline gro_flow_t *
	gro_flow_table_new_flow (gro_flow_table_t * flow_table)
	{
	if (PREDICT_TRUE (flow_table->flow_table_size < GRO_FLOW_TABLE_MAX_SIZE))
	{
	gro_flow_t *gro_flow;
	u32 i = 0;
	while (i < GRO_FLOW_TABLE_MAX_SIZE)
	{
	gro_flow = &flow_table->gro_flow[i];
	if (gro_flow->n_buffers == 0)
	{
	flow_table->flow_table_size++;
	return gro_flow;
	}
	i++;
	}
	}

	return (0);
	}

	static_always_inline gro_flow_t *
	gro_flow_table_get_flow (gro_flow_table_t * flow_table,
	gro_flow_key_t * flow_key)
	{
	gro_flow_t *gro_flow = 0;
	u32 i = 0;
	while (i < GRO_FLOW_TABLE_MAX_SIZE)
	{
	gro_flow = &flow_table->gro_flow[i];
	if (gro_flow_is_equal (flow_key, &gro_flow->flow_key))
	return gro_flow;
	i++;
	}
	return (0);
	}

	static_always_inline gro_flow_t *
	gro_flow_table_find_or_add_flow (gro_flow_table_t * flow_table,
	gro_flow_key_t * flow_key)
	{
	gro_flow_t *gro_flow = 0;

	gro_flow = gro_flow_table_get_flow (flow_table, flow_key);
	if (gro_flow)
	return gro_flow;

	gro_flow = gro_flow_table_new_flow (flow_table);

	if (gro_flow)
	{
	gro_flow_set_flow_key (gro_flow, flow_key);
	return gro_flow;
	}

	return (0);
	}

	static_always_inline void
	gro_flow_table_reset_flow (gro_flow_table_t * flow_table,
	gro_flow_t * gro_flow)
	{
	if (PREDICT_TRUE (flow_table->flow_table_size > 0))
	{
	clib_memset (gro_flow, 0, sizeof (gro_flow_t));
	flow_table->flow_table_size--;
	}
	}

	static_always_inline u8 *
	gro_flow_table_format (u8 * s, va_list * args)
	{
	gro_flow_table_t flow_table = va_arg (args, gro_flow_table_t *);
	u32 indent;

	if (!flow_table)
	return s;

	indent = format_get_indent (s);
	if (flow_table->is_enable)
	s = format (s, "packet-coalesce: enable\n");
	else
	s = format (s, "packet-coalesce: disable\n");

	indent += 2;

	s =
	format (s,
	"%Uflow-table: size %u gro-total-vectors %lu gro-n-vectors %u",
	format_white_space, indent, flow_table->flow_table_size,
	flow_table->total_vectors, flow_table->n_vectors);
	if (flow_table->n_vectors)
	{
	double average_rate =
	(double) flow_table->total_vectors / (double) flow_table->n_vectors;
	s = format (s, " gro-average-rate %.2f", average_rate);
	}
	else
	s = format (s, " gro-average-rate 0.00");

	return s;
	}
	#endif /* included_gro_h */

	/*
	* fd.io coding-style-patch-verification: ON
	*
	* Local Variables:
	* eval: (c-set-style "gnu")
	* End:
	*/