From patchwork Sat Oct 17 03:06:57 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Lukasz Wojciechowski X-Patchwork-Id: 81181 X-Patchwork-Delegate: david.marchand@redhat.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 7FEC9A04DB; Sat, 17 Oct 2020 05:13:58 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 06459FC34; Sat, 17 Oct 2020 05:08:24 +0200 (CEST) Received: from mailout1.w1.samsung.com (mailout1.w1.samsung.com [210.118.77.11]) by dpdk.org (Postfix) with ESMTP id 0CA59E2BF for ; Sat, 17 Oct 2020 05:07:50 +0200 (CEST) Received: from eucas1p2.samsung.com (unknown [182.198.249.207]) by mailout1.w1.samsung.com (KnoxPortal) with ESMTP id 20201017030727euoutp0110bd4fbfdc2b1a9f60c36fe9a191fc1f~_qL0RG3xe1627116271euoutp01b for ; Sat, 17 Oct 2020 03:07:27 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 mailout1.w1.samsung.com 20201017030727euoutp0110bd4fbfdc2b1a9f60c36fe9a191fc1f~_qL0RG3xe1627116271euoutp01b DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=samsung.com; s=mail20170921; t=1602904047; bh=KYVc1+6CtSGD0DPYSHvyk1Sa6nIsG/kBvkm4YykYcng=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=fsRsNI8qYMnSbejE4xij77fUrloqajHkTZMG5Jv7dOEIRMwcDvfD57Fdi3ZUaee9a Ngd3E+5xHPmTL7Kw+oP6xtTgSrqx8qSRF0riZ8dKZCnz0lRnY95fNds9qw/pW7j+Yq CREiYW2960IrXM0ViZ5IUUkfq+8TAe56aq+YeT/o= Received: from eusmges3new.samsung.com (unknown [203.254.199.245]) by eucas1p1.samsung.com (KnoxPortal) with ESMTP id 20201017030721eucas1p12ead66bc746e018d3e4d19b8b0465edf~_qLugm-oa0898308983eucas1p17; Sat, 17 Oct 2020 03:07:21 +0000 (GMT) Received: from eucas1p1.samsung.com ( [182.198.249.206]) by eusmges3new.samsung.com (EUCPMTA) with SMTP id 09.D5.06318.9EF5A8F5; Sat, 17 Oct 2020 04:07:21 +0100 (BST) Received: from eusmtrp2.samsung.com (unknown [182.198.249.139]) by eucas1p1.samsung.com (KnoxPortal) with ESMTPA id 20201017030720eucas1p1359382fafa661abb1ba82fa65e19562c~_qLt_RcA72252822528eucas1p12; Sat, 17 Oct 2020 03:07:20 +0000 (GMT) Received: from eusmgms1.samsung.com (unknown [182.198.249.179]) by eusmtrp2.samsung.com (KnoxPortal) with ESMTP id 20201017030720eusmtrp28fbece19743db7098239e41d575e3f3a~_qLt9zbMy2572125721eusmtrp2k; Sat, 17 Oct 2020 03:07:20 +0000 (GMT) X-AuditID: cbfec7f5-38bff700000018ae-9c-5f8a5fe9f400 Received: from eusmtip1.samsung.com ( [203.254.199.221]) by eusmgms1.samsung.com (EUCPMTA) with SMTP id 4C.99.06314.8EF5A8F5; Sat, 17 Oct 2020 04:07:20 +0100 (BST) Received: from localhost.localdomain (unknown [106.210.88.70]) by eusmtip1.samsung.com (KnoxPortal) with ESMTPA id 20201017030720eusmtip192a41e4b2a463ec92c45998780623990~_qLthzjng0424404244eusmtip1R; Sat, 17 Oct 2020 03:07:20 +0000 (GMT) From: Lukasz Wojciechowski To: David Hunt Cc: dev@dpdk.org, l.wojciechow@partner.samsung.com Date: Sat, 17 Oct 2020 05:06:57 +0200 Message-Id: <20201017030701.16134-14-l.wojciechow@partner.samsung.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20201017030701.16134-1-l.wojciechow@partner.samsung.com> X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFrrPIsWRmVeSWpSXmKPExsWy7djPc7ov47viDQ6fZLXom/SRyeLdp+1M Fs961jE6MHv8WrCU1WPxnpdMHgff7WEKYI7isklJzcksSy3St0vgyvi86jpjwWGtitd3JrA2 MG5V7GLk5JAQMJHYtu06WxcjF4eQwApGiYdHDzBBOF8YJW7Nf8kM4XxmlHh8pY0NpuXrx59Q ieWMEgcm9SNUnbn6FKyKTcBW4sjMr6wgtoiAqsS//Z+YQGxmASOJl90TmUFsYQFPiT1HWxhB bBagmiv3/oPFeQXcJLbMPsEIsU1eYvWGA0BxDg5OoHjjcVeQXRICR9gkrjY8YIaocZG4e3wj O4QtLPHq+BYoW0bi/875TBAN2xglrv7+yQjh7GeUuN67AqrKWuLwv99sIBuYBTQl1u/Shwg7 SlzpvcAEEpYQ4JO48VYQ4n4+iUnbpjNDhHklOtqEIKr1JJ72TGWEWftn7RMWCNtD4vjtr9Dw ucoo8abhFfMERvlZCMsWMDKuYhRPLS3OTU8tNs5LLdcrTswtLs1L10vOz93ECIz20/+Of93B uO9P0iFGAQ5GJR5ejqWd8UKsiWXFlbmHGCU4mJVEeJ3Ono4T4k1JrKxKLcqPLyrNSS0+xCjN waIkzmu86GWskEB6YklqdmpqQWoRTJaJg1OqgVHGuOVToIryFtHzS1b+qtBgD17Rf7fAodG0 Pe73patnjwZ2ZbKcb719u/PL9CaBH/wRETf+Te447D3n0n8vIeGd93Zl5p6fOGnxBoElB1Kt 99vMsTC8NmthUOlOg8JfnSu+qGso1kbd0nWaEzt7S6yZtLXB/TNLo8/Ef3M58P/WM678ur/h lruUWIozEg21mIuKEwET9lVU8gIAAA== X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFtrPLMWRmVeSWpSXmKPExsVy+t/xu7ov4rviDbbuU7Lom/SRyeLdp+1M Fs961jE6MHv8WrCU1WPxnpdMHgff7WEKYI7SsynKLy1JVcjILy6xVYo2tDDSM7S00DMysdQz NDaPtTIyVdK3s0lJzcksSy3St0vQy/i86jpjwWGtitd3JrA2MG5V7GLk5JAQMJH4+vEncxcj F4eQwFJGiZ1P9gA5HEAJGYkPlwQgaoQl/lzrYoOo+cgo0X59OztIgk3AVuLIzK+sILaIgKrE v/2fmEBsZqCht+c1sYHYwgKeEnuOtjCC2CxANVfu/WcGsXkF3CS2zD7BCLFAXmL1hgNgezmB 4o3HXSF2NTJKnJ21jmUCI98CRoZVjCKppcW56bnFhnrFibnFpXnpesn5uZsYgYG37djPzTsY L20MPsQowMGoxMO7YVFnvBBrYllxZe4hRgkOZiURXqezp+OEeFMSK6tSi/Lji0pzUosPMZoC HTWRWUo0OR8YFXkl8YamhuYWlobmxubGZhZK4rwdAgdjhATSE0tSs1NTC1KLYPqYODilGhjD lRy8U+eeifmybHbN95vvb5f3cgCj6rFeflqXyCo2aZ5Jjw/n7XA1TL72coGJCtNlTav8wiOr d9u/nb3o+pFvh/lUZ9+YbHDyZUrZzgD5etn9uxT2BZ39/37Wd+nk8ylb8mb+Pth5fnvRqsaN z2xX8Oxfeb1tdey5PzMNXWZkH9j0sF2gbPclJZbijERDLeai4kQAJ0OBJlICAAA= X-CMS-MailID: 20201017030720eucas1p1359382fafa661abb1ba82fa65e19562c X-Msg-Generator: CA X-RootMTR: 20201017030720eucas1p1359382fafa661abb1ba82fa65e19562c X-EPHeader: CA CMS-TYPE: 201P X-CMS-RootMailID: 20201017030720eucas1p1359382fafa661abb1ba82fa65e19562c References: <20201010160508.19709-1-l.wojciechow@partner.samsung.com> <20201017030701.16134-1-l.wojciechow@partner.samsung.com> Subject: [dpdk-dev] [PATCH v8 13/17] test/distributor: add test with packets marking X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" All of the former tests analyzed only statistics of packets processed by all workers. The new test verifies also if packets are processed on workers as expected. Every packets processed by the worker is marked and analyzed after it is returned to distributor. This test allows finding issues in matching algorithms. Signed-off-by: Lukasz Wojciechowski Acked-by: David Hunt --- app/test/test_distributor.c | 141 ++++++++++++++++++++++++++++++++++++ 1 file changed, 141 insertions(+) diff --git a/app/test/test_distributor.c b/app/test/test_distributor.c index fdb6ea9ce..cfae5a1ac 100644 --- a/app/test/test_distributor.c +++ b/app/test/test_distributor.c @@ -543,6 +543,141 @@ test_flush_with_worker_shutdown(struct worker_params *wp, return 0; } +static int +handle_and_mark_work(void *arg) +{ + struct rte_mbuf *buf[8] __rte_cache_aligned; + struct worker_params *wp = arg; + struct rte_distributor *db = wp->dist; + unsigned int num, i; + unsigned int id = __atomic_fetch_add(&worker_idx, 1, __ATOMIC_RELAXED); + num = rte_distributor_get_pkt(db, id, buf, NULL, 0); + while (!quit) { + __atomic_fetch_add(&worker_stats[id].handled_packets, num, + __ATOMIC_RELAXED); + for (i = 0; i < num; i++) + buf[i]->udata64 += id + 1; + num = rte_distributor_get_pkt(db, id, + buf, buf, num); + } + __atomic_fetch_add(&worker_stats[id].handled_packets, num, + __ATOMIC_RELAXED); + rte_distributor_return_pkt(db, id, buf, num); + return 0; +} + +/* sanity_mark_test sends packets to workers which mark them. + * Every packet has also encoded sequence number. + * The returned packets are sorted and verified if they were handled + * by proper workers. + */ +static int +sanity_mark_test(struct worker_params *wp, struct rte_mempool *p) +{ + const unsigned int buf_count = 24; + const unsigned int burst = 8; + const unsigned int shift = 12; + const unsigned int seq_shift = 10; + + struct rte_distributor *db = wp->dist; + struct rte_mbuf *bufs[buf_count]; + struct rte_mbuf *returns[buf_count]; + unsigned int i, count, id; + unsigned int sorted[buf_count], seq; + unsigned int failed = 0; + + printf("=== Marked packets test ===\n"); + clear_packet_count(); + if (rte_mempool_get_bulk(p, (void *)bufs, buf_count) != 0) { + printf("line %d: Error getting mbufs from pool\n", __LINE__); + return -1; + } + + /* bufs' hashes will be like these below, but shifted left. + * The shifting is for avoiding collisions with backlogs + * and in-flight tags left by previous tests. + * [1, 1, 1, 1, 1, 1, 1, 1 + * 1, 1, 1, 1, 2, 2, 2, 2 + * 2, 2, 2, 2, 1, 1, 1, 1] + */ + for (i = 0; i < burst; i++) { + bufs[0 * burst + i]->hash.usr = 1 << shift; + bufs[1 * burst + i]->hash.usr = ((i < burst / 2) ? 1 : 2) + << shift; + bufs[2 * burst + i]->hash.usr = ((i < burst / 2) ? 2 : 1) + << shift; + } + /* Assign a sequence number to each packet. The sequence is shifted, + * so that lower bits of the udate64 will hold mark from worker. + */ + for (i = 0; i < buf_count; i++) + bufs[i]->udata64 = i << seq_shift; + + count = 0; + for (i = 0; i < buf_count/burst; i++) { + rte_distributor_process(db, &bufs[i * burst], burst); + count += rte_distributor_returned_pkts(db, &returns[count], + buf_count - count); + } + + do { + rte_distributor_flush(db); + count += rte_distributor_returned_pkts(db, &returns[count], + buf_count - count); + } while (count < buf_count); + + for (i = 0; i < rte_lcore_count() - 1; i++) + printf("Worker %u handled %u packets\n", i, + __atomic_load_n(&worker_stats[i].handled_packets, + __ATOMIC_RELAXED)); + + /* Sort returned packets by sent order (sequence numbers). */ + for (i = 0; i < buf_count; i++) { + seq = returns[i]->udata64 >> seq_shift; + id = returns[i]->udata64 - (seq << seq_shift); + sorted[seq] = id; + } + + /* Verify that packets [0-11] and [20-23] were processed + * by the same worker + */ + for (i = 1; i < 12; i++) { + if (sorted[i] != sorted[0]) { + printf("Packet number %u processed by worker %u," + " but should be processes by worker %u\n", + i, sorted[i], sorted[0]); + failed = 1; + } + } + for (i = 20; i < 24; i++) { + if (sorted[i] != sorted[0]) { + printf("Packet number %u processed by worker %u," + " but should be processes by worker %u\n", + i, sorted[i], sorted[0]); + failed = 1; + } + } + /* And verify that packets [12-19] were processed + * by the another worker + */ + for (i = 13; i < 20; i++) { + if (sorted[i] != sorted[12]) { + printf("Packet number %u processed by worker %u," + " but should be processes by worker %u\n", + i, sorted[i], sorted[12]); + failed = 1; + } + } + + rte_mempool_put_bulk(p, (void *)bufs, buf_count); + + if (failed) + return -1; + + printf("Marked packets test passed\n"); + return 0; +} + static int test_error_distributor_create_name(void) { @@ -727,6 +862,12 @@ test_distributor(void) goto err; quit_workers(&worker_params, p); + rte_eal_mp_remote_launch(handle_and_mark_work, + &worker_params, SKIP_MASTER); + if (sanity_mark_test(&worker_params, p) < 0) + goto err; + quit_workers(&worker_params, p); + } else { printf("Too few cores to run worker shutdown test\n"); }