From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 9AAEFA04BC; Sat, 10 Oct 2020 00:07:14 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 3A7D41D6AF; Sat, 10 Oct 2020 00:03:21 +0200 (CEST) Received: from mailout2.w1.samsung.com (mailout2.w1.samsung.com [210.118.77.12]) by dpdk.org (Postfix) with ESMTP id 72F001D66A for ; Sat, 10 Oct 2020 00:03:10 +0200 (CEST) Received: from eucas1p1.samsung.com (unknown [182.198.249.206]) by mailout2.w1.samsung.com (KnoxPortal) with ESMTP id 20201009220300euoutp020c1642af047a1bde88bd6d3ebbae504d~8cg-2V29X1684516845euoutp02y for ; Fri, 9 Oct 2020 22:03:00 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 mailout2.w1.samsung.com 20201009220300euoutp020c1642af047a1bde88bd6d3ebbae504d~8cg-2V29X1684516845euoutp02y DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=samsung.com; s=mail20170921; t=1602280980; bh=H0SESRE59ofq6tEaPxg1A+VKjAU63AAfipdXXlkRUGc=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=ApxczXocZd1G/d6Ebr3BCY655eYg/r6UsUdf+IIv/s9rboh0v35LQMNyMdQDvfNX7 /jCk9p/tazuKdbEtQITiyRrW4d22xTsBLVB73aiX6Eg1G3vGKzJWpzUpQVmptEKSlD m/qSaJnk5I7zWPGil+VgeLR/HY3+3wmezVJG/EPM= Received: from eusmges1new.samsung.com (unknown [203.254.199.242]) by eucas1p1.samsung.com (KnoxPortal) with ESMTP id 20201009220254eucas1p1a85ddeb69360f58f057dcf40791e31c8~8cg6oLy1j1071010710eucas1p1f; Fri, 9 Oct 2020 22:02:54 +0000 (GMT) Received: from eucas1p2.samsung.com ( [182.198.249.207]) by eusmges1new.samsung.com (EUCPMTA) with SMTP id 00.87.06456.E0ED08F5; Fri, 9 Oct 2020 23:02:54 +0100 (BST) Received: from eusmtrp2.samsung.com (unknown [182.198.249.139]) by eucas1p2.samsung.com (KnoxPortal) with ESMTPA id 20201009220253eucas1p2c0e27c3a495cb9603102b2cbf8a8f706~8cg5vnIMl1920419204eucas1p2W; Fri, 9 Oct 2020 22:02:53 +0000 (GMT) Received: from eusmgms1.samsung.com (unknown [182.198.249.179]) by eusmtrp2.samsung.com (KnoxPortal) with ESMTP id 20201009220253eusmtrp2d2846ef4ae5c5a300f850b59de7b2fb0~8cg5vCM7F2402824028eusmtrp2B; Fri, 9 Oct 2020 22:02:53 +0000 (GMT) X-AuditID: cbfec7f2-7efff70000001938-1b-5f80de0eb5fd Received: from eusmtip1.samsung.com ( [203.254.199.221]) by eusmgms1.samsung.com (EUCPMTA) with SMTP id A4.E2.06314.D0ED08F5; Fri, 9 Oct 2020 23:02:53 +0100 (BST) Received: from Padamandas.fritz.box (unknown [106.210.88.70]) by eusmtip1.samsung.com (KnoxPortal) with ESMTPA id 20201009220253eusmtip14fbeb38d36f65331065bdf48c4a0bc98~8cg5PbH0R1334813348eusmtip10; Fri, 9 Oct 2020 22:02:53 +0000 (GMT) From: Lukasz Wojciechowski To: David Hunt Cc: dev@dpdk.org, l.wojciechow@partner.samsung.com Date: Sat, 10 Oct 2020 00:02:00 +0200 Message-Id: <20201009220202.20834-14-l.wojciechow@partner.samsung.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20201009220202.20834-1-l.wojciechow@partner.samsung.com> X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFrrHIsWRmVeSWpSXmKPExsWy7djP87p89xriDZY907Tom/SRyeLdp+1M Fs961jE6MHv8WrCU1WPxnpdMHgff7WEKYI7isklJzcksSy3St0vgynj34hBbwWGtilVbTrM1 MG5V7GLk5JAQMJH42HeDpYuRi0NIYAWjxJn9F6CcL4wSP66+ZoVwPjNKNK+byATTMvlkLyNE YjmjxOF/L9hBEkICnxgl3jezgdhsArYSR2Z+ZQWxRQRUJf7t/wTWzCxgJPGyeyJzFyMHh7CA p8SPX2BnsACVNPzeDFbCK+Am8ez4L3aIXfISqzccYAaxOYHirbuWgV0nIXCETWJeSyvUQS4S Zx+chmoQlnh1fAuULSPxf+d8JoiGbYwSV3//ZIRw9jNKXO9dAVVlDfTBbzaQi5gFNCXW79KH CDtKnFm7A+xQCQE+iRtvBSHu55OYtG06VJhXoqNNCKJaT+Jpz1RGmLV/1j5hgbA9JPonvYaG 6FVGiWWvp7BOYJSfhbBsASPjKkbx1NLi3PTUYsO81HK94sTc4tK8dL3k/NxNjMBYP/3v+Kcd jF8vJR1iFOBgVOLhbUhuiBdiTSwrrsw9xCjBwawkwut09nScEG9KYmVValF+fFFpTmrxIUZp DhYlcV7jRS9jhQTSE0tSs1NTC1KLYLJMHJxSDYzVW0LPHS35PN/jvczq2/syu/+KLPr4P1pI fllSw66C62tb75neDDm2pNbxZIHh16cP9n693PopzcRaborF62ebf89borv6bdmbf7a1K7Xu Hzrl03Jixnz9JMc53wUYei88U3b4Iziz6r3GAoMjf4J8J25duMo69WDMnPvTNmzZz3Tyh9vf u2GCq5RYijMSDbWYi4oTAeSwmW/xAgAA X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFtrPLMWRmVeSWpSXmKPExsVy+t/xu7q89xriDQ51qVv0TfrIZPHu03Ym i2c96xgdmD1+LVjK6rF4z0smj4Pv9jAFMEfp2RTll5akKmTkF5fYKkUbWhjpGVpa6BmZWOoZ GpvHWhmZKunb2aSk5mSWpRbp2yXoZbx7cYit4LBWxaotp9kaGLcqdjFyckgImEhMPtnL2MXI xSEksJRRYsGZVcxdjBxACRmJD5cEIGqEJf5c62KDqPnAKPHn1msWkASbgK3EkZlfWUFsEQFV iX/7PzGB2MxAQ2/Pa2IDmSMs4Cnx4xfYLhagkobfm8FKeAXcJJ4d/8UOMV9eYvWGA8wgNidQ vHXXMhaIXY2MElsOvGSewMi3gJFhFaNIamlxbnpusaFecWJucWleul5yfu4mRmDgbTv2c/MO xksbgw8xCnAwKvHwaiQ2xAuxJpYVV+YeYpTgYFYS4XU6ezpOiDclsbIqtSg/vqg0J7X4EKMp 0FUTmaVEk/OBUZFXEm9oamhuYWlobmxubGahJM7bIXAwRkggPbEkNTs1tSC1CKaPiYNTqoFx Vlfmuuufj9srV8R4LbyVu4x965HLeu4vIyQ9bkz6c3zrf8MLSwN1L7nu4mk/vOjoTZ7/l9mO lm15/+n0/JdBC9t1t3aLfA74ftrKrVhuVZ3IoptFMZerv8VlxD46Z9jouf/yCvaKyE+xVcpa 818Y2e9c4nKFvSbZTGeWa5vGf8toyUfvgln9lFiKMxINtZiLihMBVXDKhVICAAA= X-CMS-MailID: 20201009220253eucas1p2c0e27c3a495cb9603102b2cbf8a8f706 X-Msg-Generator: CA Content-Type: text/plain; charset="utf-8" X-RootMTR: 20201009220253eucas1p2c0e27c3a495cb9603102b2cbf8a8f706 X-EPHeader: CA CMS-TYPE: 201P X-CMS-RootMailID: 20201009220253eucas1p2c0e27c3a495cb9603102b2cbf8a8f706 References: <20201008052323.11547-1-l.wojciechow@partner.samsung.com> <20201009220202.20834-1-l.wojciechow@partner.samsung.com> Subject: [dpdk-dev] [PATCH v6 13/15] 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 e8dd75078..4fc10b3cc 100644 --- a/app/test/test_distributor.c +++ b/app/test/test_distributor.c @@ -542,6 +542,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) { @@ -726,6 +861,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"); } -- 2.17.1