crypto: add performace test to unittest plugin

Change-Id: I49c710c5ace24a4c1f083120fd4c2972566a1695
Signed-off-by: Damjan Marion <damarion@cisco.com>
Signed-off-by: Filip Tehlar <ftehlar@cisco.com>

2 files changed, 197 insertions, 1 deletions

diff --git a/src/plugins/unittest/crypto/crypto.h b/src/plugins/unittest/crypto/crypto.h
index 587d7b76a2f..ab9f706c081 100644
--- a/src/plugins/unittest/crypto/crypto.h
+++ b/src/plugins/unittest/crypto/crypto.h
@@ -38,6 +38,15 @@ typedef struct unittest_crypto_test_registration
 typedef struct
 {
   int verbose;
+
+  /* perf */
+  vnet_crypto_alg_t alg;
+  u32 warmup_rounds;
+  u32 rounds;
+  u32 buffer_size;
+  u32 n_buffers;
+  u8 one_key;
+
   unittest_crypto_test_registration_t *test_registrations;
 } crypto_test_main_t;
 
diff --git a/src/plugins/unittest/crypto_test.c b/src/plugins/unittest/crypto_test.c
index eb73e91e186..fba1e0696aa 100644
--- a/src/plugins/unittest/crypto_test.c
+++ b/src/plugins/unittest/crypto_test.c
@@ -258,10 +258,181 @@ test_crypto (vlib_main_t * vm, crypto_test_main_t * tm)
 }
 
 static clib_error_t *
+test_crypto_perf (vlib_main_t * vm, crypto_test_main_t * tm)
+{
+  vnet_crypto_main_t *cm = &crypto_main;
+  clib_error_t *err = 0;
+  u32 n_buffers, n_alloc = 0, warmup_rounds, rounds;
+  u32 *buffer_indices = 0;
+  vnet_crypto_op_t *ops1 = 0, *ops2 = 0, *op1, *op2;
+  vnet_crypto_alg_data_t *ad = vec_elt_at_index (cm->algs, tm->alg);
+  int buffer_size = vlib_buffer_get_default_data_size (vm);
+  u64 seed = clib_cpu_time_now ();
+  u64 t0[5], t1[5], t2[5], n_bytes = 0;
+  int i, j;
+  u8 *key;
+
+  if (tm->buffer_size > buffer_size)
+    return clib_error_return (0, "buffer size must be <= %u", buffer_size);
+
+  rounds = tm->rounds ? tm->rounds : 100;
+  n_buffers = tm->n_buffers ? tm->n_buffers : 256;
+  buffer_size = tm->buffer_size ? tm->buffer_size : 2048;
+  warmup_rounds = tm->warmup_rounds ? tm->warmup_rounds : 100;
+
+  if (buffer_size > vlib_buffer_get_default_data_size (vm))
+    return clib_error_return (0, "buffer size too big");
+
+  vec_validate_aligned (buffer_indices, n_buffers - 1, CLIB_CACHE_LINE_BYTES);
+  vec_validate_aligned (ops1, n_buffers - 1, CLIB_CACHE_LINE_BYTES);
+  vec_validate_aligned (ops2, n_buffers - 1, CLIB_CACHE_LINE_BYTES);
+
+  n_alloc = vlib_buffer_alloc (vm, buffer_indices, n_buffers);
+  if (n_alloc != n_buffers)
+    {
+      if (n_alloc)
+	vlib_buffer_free (vm, buffer_indices, n_alloc);
+      err = clib_error_return (0, "buffer alloc failure");
+      goto done;
+    }
+
+  vlib_cli_output (vm, "%U: n_buffers %u buffer-size %u rounds %u "
+		   "warmup-rounds %u one-key %s",
+		   format_vnet_crypto_alg, tm->alg, n_buffers, buffer_size,
+		   rounds, warmup_rounds, tm->one_key ? "yes" : "no");
+  vlib_cli_output (vm, "   cpu-freq %.2f GHz",
+		   (f64) vm->clib_time.clocks_per_second * 1e-9);
+
+  vnet_crypto_op_type_t ot = 0;
+
+  for (i = 0; i < VNET_CRYPTO_OP_N_TYPES; i++)
+    {
+      vnet_crypto_op_id_t id = ad->op_by_type[i];
+      if (id == 0)
+	continue;
+      ot = i;
+      break;
+    }
+
+  for (i = 0; i < n_buffers; i++)
+    {
+      vlib_buffer_t *b = vlib_get_buffer (vm, buffer_indices[i]);
+      op1 = ops1 + i;
+      op2 = ops2 + i;
+      if (i == 0)
+	key = b->data - 32;
+
+      switch (ot)
+	{
+	case VNET_CRYPTO_OP_TYPE_ENCRYPT:
+	case VNET_CRYPTO_OP_TYPE_DECRYPT:
+	  vnet_crypto_op_init (op1,
+			       ad->op_by_type[VNET_CRYPTO_OP_TYPE_ENCRYPT]);
+	  vnet_crypto_op_init (op2,
+			       ad->op_by_type[VNET_CRYPTO_OP_TYPE_DECRYPT]);
+	  op1->flags = VNET_CRYPTO_OP_FLAG_INIT_IV;
+	  op1->src = op2->src = op1->dst = op2->dst = b->data;
+	  op1->key = op2->key = tm->one_key ? key : b->data - 32;
+	  op1->iv = op2->iv = b->data - 64;
+	  n_bytes += op1->len = op2->len = buffer_size;
+	  break;
+	case VNET_CRYPTO_OP_TYPE_AEAD_ENCRYPT:
+	case VNET_CRYPTO_OP_TYPE_AEAD_DECRYPT:
+	  vnet_crypto_op_init (op1,
+			       ad->op_by_type
+			       [VNET_CRYPTO_OP_TYPE_AEAD_ENCRYPT]);
+	  vnet_crypto_op_init (op2,
+			       ad->op_by_type
+			       [VNET_CRYPTO_OP_TYPE_AEAD_DECRYPT]);
+	  op1->flags = VNET_CRYPTO_OP_FLAG_INIT_IV;
+	  op1->src = op2->src = op1->dst = op2->dst = b->data;
+	  op1->key = op2->key = tm->one_key ? key : b->data - 32;
+	  op1->iv = op2->iv = b->data - 64;
+	  op1->aad = op2->aad = b->data - VLIB_BUFFER_PRE_DATA_SIZE;
+	  op1->aad_len = op2->aad_len = 0;
+	  n_bytes += op1->len = op2->len = buffer_size;
+	  break;
+	case VNET_CRYPTO_OP_TYPE_HMAC:
+	  vnet_crypto_op_init (op1, ad->op_by_type[VNET_CRYPTO_OP_TYPE_HMAC]);
+	  op1->src = b->data;
+	  op1->key = tm->one_key ? key : b->data - 32;
+	  op1->iv = 0;
+	  op1->digest = b->data - VLIB_BUFFER_PRE_DATA_SIZE;
+	  op1->digest_len = 0;
+	  n_bytes += op1->len = buffer_size;
+	  break;
+	default:
+	  return 0;
+	}
+
+      for (j = -VLIB_BUFFER_PRE_DATA_SIZE; j < buffer_size; j += 8)
+	*(u64 *) (b->data + j) = 1 + random_u64 (&seed);
+    }
+
+  for (i = 0; i < 5; i++)
+    {
+      for (j = 0; j < warmup_rounds; j++)
+	{
+	  vnet_crypto_process_ops (vm, ops1, n_buffers);
+	  if (ot != VNET_CRYPTO_OP_TYPE_HMAC)
+	    vnet_crypto_process_ops (vm, ops2, n_buffers);
+	}
+
+      t0[i] = clib_cpu_time_now ();
+      for (j = 0; j < rounds; j++)
+	vnet_crypto_process_ops (vm, ops1, n_buffers);
+      t1[i] = clib_cpu_time_now ();
+
+      if (ot != VNET_CRYPTO_OP_TYPE_HMAC)
+	{
+	  for (j = 0; j < rounds; j++)
+	    vnet_crypto_process_ops (vm, ops2, n_buffers);
+	  t2[i] = clib_cpu_time_now ();
+	}
+    }
+
+  for (i = 0; i < 5; i++)
+    {
+      f64 tpb1 = (f64) (t1[i] - t0[i]) / (n_bytes * rounds);
+      f64 gbps1 = vm->clib_time.clocks_per_second * 1e-9 * 8 / tpb1;
+      f64 tpb2, gbps2;
+
+      if (ot != VNET_CRYPTO_OP_TYPE_HMAC)
+	{
+	  tpb2 = (f64) (t2[i] - t1[i]) / (n_bytes * rounds);
+	  gbps2 = vm->clib_time.clocks_per_second * 1e-9 * 8 / tpb2;
+	  vlib_cli_output (vm, "%-2u: encrypt %.03f ticks/byte, %.02f Gbps; "
+			   "decrypt %.03f ticks/byte, %.02f Gbps",
+			   i + 1, tpb1, gbps1, tpb2, gbps2);
+	}
+      else
+	{
+	  vlib_cli_output (vm, "%-2u: hash %.03f ticks/byte, %.02f Gbps\n",
+			   i + 1, tpb1, gbps1);
+	}
+    }
+
+done:
+  if (n_alloc)
+    vlib_buffer_free (vm, buffer_indices, n_alloc);
+  vec_free (buffer_indices);
+  vec_free (ops1);
+  vec_free (ops2);
+  return err;
+}
+
+static clib_error_t *
 test_crypto_command_fn (vlib_main_t * vm,
 			unformat_input_t * input, vlib_cli_command_t * cmd)
 {
   crypto_test_main_t *tm = &crypto_test_main;
+  unittest_crypto_test_registration_t *tr;
+  int is_perf = 0;
+
+  tr = tm->test_registrations;
+  memset (tm, 0, sizeof (crypto_test_main_t));
+  tm->test_registrations = tr;
+  tm->alg = ~0;
 
   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
     {
@@ -270,11 +441,27 @@ test_crypto_command_fn (vlib_main_t * vm,
       else if (unformat (input, "detail"))
 	tm->verbose = 2;
       else
+	if (unformat (input, "perf %U", unformat_vnet_crypto_alg, &tm->alg))
+	is_perf = 1;
+      else if (unformat (input, "buffers %u", &tm->n_buffers))
+	;
+      else if (unformat (input, "rounds %u", &tm->rounds))
+	;
+      else if (unformat (input, "warmup-rounds %u", &tm->warmup_rounds))
+	;
+      else if (unformat (input, "buffer-size %u", &tm->buffer_size))
+	;
+      else if (unformat (input, "one-key"))
+	tm->one_key = 1;
+      else
 	return clib_error_return (0, "unknown input '%U'",
 				  format_unformat_error, input);
     }
 
-  return test_crypto (vm, tm);
+  if (is_perf)
+    return test_crypto_perf (vm, tm);
+  else
+    return test_crypto (vm, tm);
 }
 
 /* *INDENT-OFF* */