uint64_t nb_req;
uint64_t nb_alloc;
uint64_t nb_cycle;
+ uint64_t max_cycle;
+ uint64_t min_cycle;
} alloc;
struct {
uint64_t nb_call;
uint64_t nb_free;
uint64_t nb_cycle;
+ uint64_t max_cycle;
+ uint64_t min_cycle;
} free;
struct {
uint64_t nb_call;
uint64_t nb_chunk;
uint64_t nb_cycle;
+ uint64_t max_cycle;
+ uint64_t min_cycle;
} grow;
struct {
uint64_t nb_call;
uint64_t nb_chunk;
uint64_t nb_cycle;
+ uint64_t max_cycle;
+ uint64_t min_cycle;
} shrink;
};
uint32_t obj_size;
uint32_t alloc_flags;
uint32_t free_flags;
+ struct rte_ring *rng;
};
struct memtank_arg {
struct worker_args worker;
};
struct memtank_stat stats;
-};
+} __rte_cache_aligned;
#define BULK_NUM 32
-#define MAX_OBJ 0x100000
#define OBJ_SZ_MIN 1
#define OBJ_SZ_MAX 0x100000
#define OBJ_SZ_DEF (4 * RTE_CACHE_LINE_SIZE + 1)
#define TEST_TIME 10
+#define CLEANUP_TIME 3
#define FREE_THRSH_MIN 0
#define FREE_THRSH_MAX 100
static struct tle_memtank_prm mtnk_prm = {
.min_free = 4 * BULK_NUM,
.max_free = 32 * BULK_NUM,
- .max_obj = MAX_OBJ,
.obj_size = OBJ_SZ_DEF,
.obj_align = RTE_CACHE_LINE_SIZE,
.nb_obj_chunk = BULK_NUM,
}
+static void
+memtank_stat_reset(struct memtank_stat *ms)
+{
+ static const struct memtank_stat init_stat = {
+ .alloc.min_cycle = UINT64_MAX,
+ .free.min_cycle = UINT64_MAX,
+ .grow.min_cycle = UINT64_MAX,
+ .shrink.min_cycle = UINT64_MAX,
+ };
+
+ *ms = init_stat;
+}
+
+static void
+memtank_stat_aggr(struct memtank_stat *as, const struct memtank_stat *ms)
+{
+ if (ms->alloc.nb_call != 0) {
+ as->alloc.nb_call += ms->alloc.nb_call;
+ as->alloc.nb_req += ms->alloc.nb_req;
+ as->alloc.nb_alloc += ms->alloc.nb_alloc;
+ as->alloc.nb_cycle += ms->alloc.nb_cycle;
+ as->alloc.max_cycle = RTE_MAX(as->alloc.max_cycle,
+ ms->alloc.max_cycle);
+ as->alloc.min_cycle = RTE_MIN(as->alloc.min_cycle,
+ ms->alloc.min_cycle);
+ }
+ if (ms->free.nb_call != 0) {
+ as->free.nb_call += ms->free.nb_call;
+ as->free.nb_free += ms->free.nb_free;
+ as->free.nb_cycle += ms->free.nb_cycle;
+ as->free.max_cycle = RTE_MAX(as->free.max_cycle,
+ ms->free.max_cycle);
+ as->free.min_cycle = RTE_MIN(as->free.min_cycle,
+ ms->free.min_cycle);
+ }
+ if (ms->grow.nb_call != 0) {
+ as->grow.nb_call += ms->grow.nb_call;
+ as->grow.nb_chunk += ms->grow.nb_chunk;
+ as->grow.nb_cycle += ms->grow.nb_cycle;
+ as->grow.max_cycle = RTE_MAX(as->grow.max_cycle,
+ ms->grow.max_cycle);
+ as->grow.min_cycle = RTE_MIN(as->grow.min_cycle,
+ ms->grow.min_cycle);
+ }
+ if (ms->shrink.nb_call != 0) {
+ as->shrink.nb_call += ms->shrink.nb_call;
+ as->shrink.nb_chunk += ms->shrink.nb_chunk;
+ as->shrink.nb_cycle += ms->shrink.nb_cycle;
+ as->shrink.max_cycle = RTE_MAX(as->shrink.max_cycle,
+ ms->shrink.max_cycle);
+ as->shrink.min_cycle = RTE_MIN(as->shrink.min_cycle,
+ ms->shrink.min_cycle);
+ }
+}
+
static void
memtank_stat_dump(FILE *f, uint32_t lc, const struct memtank_stat *ms)
{
uint64_t t;
+ long double st;
+
+ st = (long double)rte_get_timer_hz() / US_PER_S;
+
+ if (lc == UINT32_MAX)
+ fprintf(f, "%s(AGGREGATE)={\n", __func__);
+ else
+ fprintf(f, "%s(lc=%u)={\n", __func__, lc);
- fprintf(f, "%s(lc=%u)={\n", __func__, lc);
fprintf(f, "\tnb_cycle=%" PRIu64 ",\n", ms->nb_cycle);
if (ms->alloc.nb_call != 0) {
fprintf(f, "\talloc={\n");
fprintf(f, "\t\tobj/call(avg): %.2Lf\n",
(long double)ms->alloc.nb_alloc / ms->alloc.nb_call);
+ fprintf(f, "\t\tmax cycles/call=%" PRIu64 "(%.2Lf usec),\n",
+ ms->alloc.max_cycle,
+ (long double)ms->alloc.max_cycle / st);
+ fprintf(f, "\t\tmin cycles/call=%" PRIu64 "(%.2Lf usec),\n",
+ ms->alloc.min_cycle,
+ (long double)ms->alloc.min_cycle / st);
+
fprintf(f, "\t},\n");
}
if (ms->free.nb_call != 0) {
fprintf(f, "\t\tobj/call(avg): %.2Lf\n",
(long double)ms->free.nb_free / ms->free.nb_call);
+ fprintf(f, "\t\tmax cycles/call=%" PRIu64 "(%.2Lf usec),\n",
+ ms->free.max_cycle,
+ (long double)ms->free.max_cycle / st);
+ fprintf(f, "\t\tmin cycles/call=%" PRIu64 "(%.2Lf usec),\n",
+ ms->free.min_cycle,
+ (long double)ms->free.min_cycle / st);
+
fprintf(f, "\t},\n");
}
if (ms->grow.nb_call != 0) {
fprintf(f, "\t\tobj/call(avg): %.2Lf\n",
(long double)ms->grow.nb_chunk / ms->grow.nb_call);
+ fprintf(f, "\t\tmax cycles/call=%" PRIu64 "(%.2Lf usec),\n",
+ ms->grow.max_cycle,
+ (long double)ms->grow.max_cycle / st);
+ fprintf(f, "\t\tmin cycles/call=%" PRIu64 "(%.2Lf usec),\n",
+ ms->grow.min_cycle,
+ (long double)ms->grow.min_cycle / st);
+
fprintf(f, "\t},\n");
}
if (ms->shrink.nb_call != 0) {
fprintf(f, "\t\tobj/call(avg): %.2Lf\n",
(long double)ms->shrink.nb_chunk / ms->shrink.nb_call);
+ fprintf(f, "\t\tmax cycles/call=%" PRIu64 "(%.2Lf usec),\n",
+ ms->shrink.max_cycle,
+ (long double)ms->shrink.max_cycle / st);
+ fprintf(f, "\t\tmin cycles/call=%" PRIu64 "(%.2Lf usec),\n",
+ ms->shrink.min_cycle,
+ (long double)ms->shrink.min_cycle / st);
+
fprintf(f, "\t},\n");
}
fprintf(f, "};\n");
}
static int
-test_memtank_worker(void *arg)
+create_worker_ring(struct worker_args *wa, uint32_t lc)
{
int32_t rc;
size_t sz;
- uint32_t ft, lc, n, num;
- uint64_t cl, tm0, tm1;
- struct memtank_arg *ma;
struct rte_ring *ring;
- void *obj[BULK_NUM];
-
- ma = arg;
- lc = rte_lcore_id();
- sz = rte_ring_get_memsize(ma->worker.max_obj);
- ring = alloca(sz);
+ sz = rte_ring_get_memsize(wa->max_obj);
+ ring = malloc(sz);
if (ring == NULL) {
printf("%s(%u): alloca(%zu) for FIFO with %u elems failed",
- __func__, lc, sz, ma->worker.max_obj);
+ __func__, lc, sz, wa->max_obj);
return -ENOMEM;
}
- rc = rte_ring_init(ring, "", ma->worker.max_obj,
+ rc = rte_ring_init(ring, "", wa->max_obj,
RING_F_SP_ENQ | RING_F_SC_DEQ);
if (rc != 0) {
printf("%s(%u): rte_ring_init(%p, %u) failed, error: %d(%s)\n",
- __func__, lc, ring, ma->worker.max_obj,
+ __func__, lc, ring, wa->max_obj,
rc, strerror(-rc));
+ free(ring);
return rc;
}
+ wa->rng = ring;
+ return rc;
+}
+
+static int
+test_worker_cleanup(void *arg)
+{
+ void *obj[BULK_NUM];
+ int32_t rc;
+ uint32_t lc, n, num;
+ struct memtank_arg *ma;
+ struct rte_ring *ring;
+
+ ma = arg;
+ ring = ma->worker.rng;
+ lc = rte_lcore_id();
+
+ rc = 0;
+ for (n = rte_ring_count(ring); rc == 0 && n != 0; n -= num) {
+
+ num = rte_rand() % RTE_DIM(obj);
+ num = RTE_MIN(num, n);
+
+ if (num != 0) {
+ /* retrieve objects to free */
+ rte_ring_dequeue_bulk(ring, obj, num, NULL);
+
+ /* check and fill contents of freeing objects */
+ rc = check_fill_objs(obj, ma->worker.obj_size, num,
+ lc, 0);
+ if (rc == 0) {
+ tle_memtank_free(ma->mt, obj, num,
+ ma->worker.free_flags);
+ ma->stats.free.nb_free += num;
+ }
+ }
+ }
+
+ return rc;
+}
+
+static int
+test_memtank_worker(void *arg)
+{
+ int32_t rc;
+ uint32_t ft, lc, n, num;
+ uint64_t cl, tm0, tm1;
+ struct memtank_arg *ma;
+ struct rte_ring *ring;
+ void *obj[BULK_NUM];
+
+ ma = arg;
+ lc = rte_lcore_id();
+
/* calculate free threshold */
ft = ma->worker.max_obj * global_cfg.wrk_free_thrsh / FREE_THRSH_MAX;
+ ring = ma->worker.rng;
while (wrk_cmd != WRK_CMD_RUN) {
rte_smp_rmb();
if (rc != 0)
break;
+ tm1 = tm1 - tm0;
+
/* collect alloc stat */
ma->stats.alloc.nb_call++;
ma->stats.alloc.nb_req += num;
ma->stats.alloc.nb_alloc += n;
- ma->stats.alloc.nb_cycle += tm1 - tm0;
+ ma->stats.alloc.nb_cycle += tm1;
+ ma->stats.alloc.max_cycle =
+ RTE_MAX(ma->stats.alloc.max_cycle, tm1);
+ ma->stats.alloc.min_cycle =
+ RTE_MIN(ma->stats.alloc.min_cycle, tm1);
/* store allocated objects */
rte_ring_enqueue_bulk(ring, obj, n, NULL);
ma->worker.free_flags);
tm1 = rte_rdtsc_precise();
+ tm1 = tm1 - tm0;
+
/* collect free stat */
ma->stats.free.nb_call++;
ma->stats.free.nb_free += num;
- ma->stats.free.nb_cycle += tm1 - tm0;
+ ma->stats.free.nb_cycle += tm1;
+ ma->stats.free.max_cycle =
+ RTE_MAX(ma->stats.free.max_cycle, tm1);
+ ma->stats.free.min_cycle =
+ RTE_MIN(ma->stats.free.min_cycle, tm1);
}
rte_smp_mb();
tm1 = rte_rdtsc_precise();
ma->stats.shrink.nb_call++;
ma->stats.shrink.nb_chunk += n;
- if (n != 0)
- ma->stats.shrink.nb_cycle += tm1 - tm0;
+ tm1 = tm1 - tm0;
+
+ if (n != 0) {
+ ma->stats.shrink.nb_cycle += tm1;
+ ma->stats.shrink.max_cycle =
+ RTE_MAX(ma->stats.shrink.max_cycle,
+ tm1);
+ ma->stats.shrink.min_cycle =
+ RTE_MIN(ma->stats.shrink.min_cycle,
+ tm1);
+ }
}
if (ma->master.flags & MASTER_FLAG_GROW) {
tm2 = rte_rdtsc_precise();
ma->stats.grow.nb_call++;
ma->stats.grow.nb_chunk += n;
- if (n != 0)
- ma->stats.grow.nb_cycle += tm2 - tm1;
+ tm2 = tm2 - tm1;
+
+ if (n != 0) {
+ ma->stats.grow.nb_cycle += tm2;
+ ma->stats.grow.max_cycle =
+ RTE_MAX(ma->stats.grow.max_cycle,
+ tm2);
+ ma->stats.grow.min_cycle =
+ RTE_MIN(ma->stats.grow.min_cycle,
+ tm2);
+ }
}
wrk_cmd = WRK_CMD_RUN;
return 0;
}
-static void
+static int
fill_worker_args(struct worker_args *wa, uint32_t alloc_flags,
- uint32_t free_flags)
+ uint32_t free_flags, uint32_t lc)
{
wa->max_obj = global_cfg.wrk_max_obj;
wa->obj_size = mtnk_prm.obj_size;
wa->alloc_flags = alloc_flags;
wa->free_flags = free_flags;
+
+ return create_worker_ring(wa, lc);
}
static void
ma->flags = flags;
}
-/*
- * alloc/free by workers threads.
- * grow/shrink by master
- */
static int
-test_memtank_mt1(void)
+test_memtank_cleanup(struct tle_memtank *mt, struct memstat *ms,
+ struct memtank_arg arg[], const char *tname)
{
int32_t rc;
uint32_t lc;
- struct tle_memtank *mt;
- struct tle_memtank_prm prm;
- struct memstat ms;
- struct memtank_arg arg[RTE_MAX_LCORE];
-
- printf("%s start\n", __func__);
-
- memset(&prm, 0, sizeof(prm));
- memset(&ms, 0, sizeof(ms));
-
- prm = mtnk_prm;
- prm.alloc = test_alloc1;
- prm.free = test_free1;
- prm.udata = &ms;
- mt = tle_memtank_create(&prm);
- if (mt == NULL) {
- printf("%s: memtank_create() failed\n", __func__);
- return -ENOMEM;
- }
+ printf("%s(%s)\n", __func__, tname);
- memset(arg, 0, sizeof(arg));
-
- /* launch on all slaves */
- RTE_LCORE_FOREACH_SLAVE(lc) {
- arg[lc].mt = mt;
- fill_worker_args(&arg[lc].worker, 0, 0);
- rte_eal_remote_launch(test_memtank_worker, &arg[lc], lc);
- }
+ RTE_LCORE_FOREACH_SLAVE(lc)
+ rte_eal_remote_launch(test_worker_cleanup, &arg[lc], lc);
/* launch on master */
lc = rte_lcore_id();
- arg[lc].mt = mt;
- fill_master_args(&arg[lc].master,
- MASTER_FLAG_GROW | MASTER_FLAG_SHRINK);
+ arg[lc].master.run_cycles = CLEANUP_TIME * rte_get_timer_hz();
test_memtank_master(&arg[lc]);
- /* wait for slaves and collect stats. */
- rc = 0;
+ ms->nb_alloc_obj = 0;
RTE_LCORE_FOREACH_SLAVE(lc) {
rc |= rte_eal_wait_lcore(lc);
- memtank_stat_dump(stdout, lc, &arg[lc].stats);
- ms.nb_alloc_obj += arg[lc].stats.alloc.nb_alloc -
+ ms->nb_alloc_obj += arg[lc].stats.alloc.nb_alloc -
arg[lc].stats.free.nb_free;
}
- lc = rte_lcore_id();
- memtank_stat_dump(stdout, lc, &arg[lc].stats);
tle_memtank_dump(stdout, mt, TLE_MTANK_DUMP_STAT);
- memstat_dump(stdout, &ms);
+ memstat_dump(stdout, ms);
+ rc = tle_memtank_sanity_check(mt, 0);
- rc |= tle_memtank_sanity_check(mt, 0);
- tle_memtank_destroy(mt);
return rc;
}
/*
- * alloc/free with grow/shrink by worker threads.
- * master does nothing
+ * alloc/free by workers threads.
+ * grow/shrink by master
*/
static int
-test_memtank_mt2(void)
+test_memtank_mt(const char *tname, uint32_t alloc_flags, uint32_t free_flags)
{
int32_t rc;
uint32_t lc;
struct tle_memtank *mt;
struct tle_memtank_prm prm;
struct memstat ms;
+ struct memtank_stat wrk_stats;
struct memtank_arg arg[RTE_MAX_LCORE];
- const uint32_t alloc_flags = TLE_MTANK_ALLOC_CHUNK |
- TLE_MTANK_ALLOC_GROW;
- const uint32_t free_flags = TLE_MTANK_FREE_SHRINK;
-
- printf("%s start\n", __func__);
+ printf("%s(%s) start\n", __func__, tname);
memset(&prm, 0, sizeof(prm));
memset(&ms, 0, sizeof(ms));
mt = tle_memtank_create(&prm);
if (mt == NULL) {
- printf("%s: memtank_create() failed\n", __func__);
+ printf("%s(%s): memtank_create() failed\n", __func__, tname);
return -ENOMEM;
}
+ /* dump initial memory stats */
+ memstat_dump(stdout, &ms);
+
+ rc = 0;
memset(arg, 0, sizeof(arg));
- /* launch on all slaves */
+ /* prepare args on all slaves */
RTE_LCORE_FOREACH_SLAVE(lc) {
arg[lc].mt = mt;
- fill_worker_args(&arg[lc].worker, alloc_flags, free_flags);
- rte_eal_remote_launch(test_memtank_worker, &arg[lc], lc);
+ rc = fill_worker_args(&arg[lc].worker, alloc_flags,
+ free_flags, lc);
+ if (rc != 0)
+ break;
+ memtank_stat_reset(&arg[lc].stats);
+ }
+
+ if (rc != 0) {
+ tle_memtank_destroy(mt);
+ return rc;
}
+ /* launch on all slaves */
+ RTE_LCORE_FOREACH_SLAVE(lc)
+ rte_eal_remote_launch(test_memtank_worker, &arg[lc], lc);
+
/* launch on master */
lc = rte_lcore_id();
arg[lc].mt = mt;
- fill_master_args(&arg[lc].master, 0);
+ fill_master_args(&arg[lc].master,
+ MASTER_FLAG_GROW | MASTER_FLAG_SHRINK);
test_memtank_master(&arg[lc]);
/* wait for slaves and collect stats. */
+
+ memtank_stat_reset(&wrk_stats);
+
rc = 0;
RTE_LCORE_FOREACH_SLAVE(lc) {
rc |= rte_eal_wait_lcore(lc);
memtank_stat_dump(stdout, lc, &arg[lc].stats);
+ memtank_stat_aggr(&wrk_stats, &arg[lc].stats);
ms.nb_alloc_obj += arg[lc].stats.alloc.nb_alloc -
arg[lc].stats.free.nb_free;
}
+ memtank_stat_dump(stdout, UINT32_MAX, &wrk_stats);
+
lc = rte_lcore_id();
memtank_stat_dump(stdout, lc, &arg[lc].stats);
tle_memtank_dump(stdout, mt, TLE_MTANK_DUMP_STAT);
memstat_dump(stdout, &ms);
-
rc |= tle_memtank_sanity_check(mt, 0);
+
+ /* run cleanup on all slave cores */
+ if (rc == 0)
+ rc = test_memtank_cleanup(mt, &ms, arg, tname);
+
tle_memtank_destroy(mt);
return rc;
}
+/*
+ * alloc/free by workers threads.
+ * grow/shrink by master
+ */
+static int
+test_memtank_mt1(const char *tname)
+{
+ return test_memtank_mt(tname, 0, 0);
+}
+
+/*
+ * alloc/free with grow/shrink by worker threads.
+ * master does nothing
+ */
+static int
+test_memtank_mt2(const char *tname)
+{
+ const uint32_t alloc_flags = TLE_MTANK_ALLOC_CHUNK |
+ TLE_MTANK_ALLOC_GROW;
+ const uint32_t free_flags = TLE_MTANK_FREE_SHRINK;
+
+ return test_memtank_mt(tname, alloc_flags, free_flags);
+}
+
static int
parse_uint_val(const char *str, uint32_t *val, uint32_t min, uint32_t max)
{
const struct {
const char *name;
- int (*func)(void);
+ int (*func)(const char *);
} tests[] = {
{
.name = "MT1-WRK_ALLOC_FREE-MST_GROW_SHRINK",
"%s: parse_op failed with error code: %d\n",
__func__, rc);
+ /* update global values based on provided user input */
+ mtnk_prm.max_obj = global_cfg.wrk_max_obj * rte_lcore_count();
+
for (i = 0, k = 0; i != RTE_DIM(tests); i++) {
printf("TEST %s START\n", tests[i].name);
- rc = tests[i].func();
+ rc = tests[i].func(tests[i].name);
k += (rc == 0);
if (rc != 0)
Code Review / tldk.git / commitdiff