Adding PROX(Packet pROcessing eXecution engine) VNF to sampleVNF

JIRA: SAMPLEVNF-55

PROX is a DPDK-based application implementing Telco use-cases such as
a simplified BRAS/BNG, light-weight AFTR... It also allows configuring
finer grained network functions like QoS, Routing, load-balancing...

(We are moving PROX version v039 to sampleVNF
https://01.org/intel-data-plane-performance-demonstrators/prox-overview)

Change-Id: Ia3cb02cf0e49ac5596e922c197ff7e010293d033
Signed-off-by: Deepak S <deepak.s@linux.intel.com>

1 files changed, 165 insertions, 0 deletions

diff --git a/VNFs/DPPD-PROX/token_time.h b/VNFs/DPPD-PROX/token_time.h
new file mode 100644
index 00000000..e59647ad
--- /dev/null
+++ b/VNFs/DPPD-PROX/token_time.h
@@ -0,0 +1,165 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// 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 _TOKEN_TIME_H_
+#define _TOKEN_TIME_H_
+
+#include <rte_cycles.h>
+#include <math.h>
+
+#include "prox_assert.h"
+
+struct token_time_cfg {
+	uint64_t bpp;
+	uint64_t period;
+	uint64_t bytes_max;
+};
+
+struct token_time {
+	uint64_t tsc_last;
+	uint64_t tsc_last_bytes;
+	uint64_t bytes_now;
+	struct token_time_cfg cfg;
+};
+
+/* Convert a given fractional bytes per period into bpp with as
+   minimal loss of accuracy. */
+static struct token_time_cfg token_time_cfg_create(double frac, uint64_t period, uint64_t bytes_max)
+{
+	struct token_time_cfg ret;
+
+	/* Since period is expressed in units of cycles and it is in
+	   most cases set to 1 second (which means its value is <=
+	   3*10^9) and 2^64/10^9 > 6148914691 > 2^32). This means that
+	   at most, period and frac will be doubled 32 times by the
+	   following algorithm. Hence, the total error introduced by
+	   the chosen values for bpp and period will be between 0 and
+	   1/2^33. Note that since there are more operations that
+	   can't overflow, the actual accuracy will probably be
+	   lower. */
+
+	/* The reason to limit period by UINT64_MAX/(uint64_t)frac is
+	   that at run-time, the token_time_update function will
+	   multiply a number that is <= period with bpp. In addition,
+	   the token_time_tsc_until function will multiply at most
+	   bytes_max with period so make sure that can't overflow. */
+
+	while (period < UINT64_MAX/2 && frac != floor(frac) &&
+	       (frac < 2.0f || period < UINT64_MAX/4/(uint64_t)frac) &&
+	       (bytes_max == UINT64_MAX || period < UINT64_MAX/2/bytes_max)) {
+		period *= 2;
+		frac *= 2;
+	}
+
+	ret.bpp = floor(frac + 0.5);
+	ret.period = period;
+	ret.bytes_max = bytes_max;
+
+	return ret;
+}
+
+static void token_time_update(struct token_time *tt, uint64_t tsc)
+{
+	uint64_t new_bytes;
+	uint64_t t_diff = tsc - tt->tsc_last;
+
+	/* Since the rate is expressed in tt->bpp, i.e. bytes per
+	   period, counters can only be incremented/decremented
+	   accurately every period cycles. */
+
+	/* If the last update was more than a period ago, the update
+	   can be performed accurately. */
+	if (t_diff > tt->cfg.period) {
+		/* First add remaining tokens in the last period that
+		   was added partially. */
+		new_bytes = tt->cfg.bpp - tt->tsc_last_bytes;
+		tt->tsc_last_bytes = 0;
+		tt->bytes_now += new_bytes;
+		t_diff -= tt->cfg.period;
+		tt->tsc_last += tt->cfg.period;
+
+		/* If now it turns out that more periods have elapsed,
+		   add the bytes for those periods directly. */
+		if (t_diff > tt->cfg.period) {
+			uint64_t periods = t_diff/tt->cfg.period;
+
+			tt->bytes_now += periods * tt->cfg.bpp;
+			t_diff -= tt->cfg.period * periods;
+			tt->tsc_last += tt->cfg.period * periods;
+		}
+	}
+
+	/* At this point, t_diff will be guaranteed to be less
+	   than tt->cfg.period. */
+	new_bytes = t_diff * tt->cfg.bpp/tt->cfg.period - tt->tsc_last_bytes;
+	tt->tsc_last_bytes += new_bytes;
+	tt->bytes_now += new_bytes;
+	if (tt->bytes_now > tt->cfg.bytes_max)
+		tt->bytes_now = tt->cfg.bytes_max;
+}
+
+static void token_time_set_bpp(struct token_time *tt, uint64_t bpp)
+{
+	tt->cfg.bpp = bpp;
+}
+
+static void token_time_init(struct token_time *tt, const struct token_time_cfg *cfg)
+{
+	tt->cfg = *cfg;
+}
+
+static void token_time_reset(struct token_time *tt, uint64_t tsc, uint64_t bytes_now)
+{
+	tt->tsc_last = tsc;
+	tt->bytes_now = bytes_now;
+	tt->tsc_last_bytes = 0;
+}
+
+static void token_time_reset_full(struct token_time *tt, uint64_t tsc)
+{
+	token_time_reset(tt, tsc, tt->cfg.bytes_max);
+}
+
+static int token_time_take(struct token_time *tt, uint64_t bytes)
+{
+	if (bytes > tt->bytes_now)
+		return -1;
+	tt->bytes_now -= bytes;
+	return 0;
+}
+
+static void token_time_take_clamp(struct token_time *tt, uint64_t bytes)
+{
+	if (bytes > tt->bytes_now)
+		tt->bytes_now = 0;
+	else
+		tt->bytes_now -= bytes;
+}
+
+static uint64_t token_time_tsc_until(const struct token_time *tt, uint64_t bytes)
+{
+	if (tt->bytes_now >= bytes)
+		return 0;
+
+	return (bytes - tt->bytes_now) * tt->cfg.period / tt->cfg.bpp;
+}
+
+static uint64_t token_time_tsc_until_full(const struct token_time *tt)
+{
+	return token_time_tsc_until(tt, tt->cfg.bytes_max);
+}
+
+#endif /* _TOKEN_TIME_H_ */