From patchwork Tue Jul 24 15:05:35 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Shally Verma X-Patchwork-Id: 43316 X-Patchwork-Delegate: pablo.de.lara.guarch@intel.com Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 0C31F47CD; Tue, 24 Jul 2018 17:06:19 +0200 (CEST) Received: from NAM01-BN3-obe.outbound.protection.outlook.com (mail-bn3nam01on0046.outbound.protection.outlook.com [104.47.33.46]) by dpdk.org (Postfix) with ESMTP id 338EE31FC for ; Tue, 24 Jul 2018 17:06:16 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=CAVIUMNETWORKS.onmicrosoft.com; s=selector1-cavium-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=fChFwaWvPVPh68CnMul7oi1MKkAGbG2UlFVhkafvkvQ=; b=cgfHRzA7+4FpQzHGR48arJ1/w2T6/l0pRSIBVDvEIHRFvmAODBSIV3BopVQOkUgktaV0AbkxICYjSUAMyw/FZYbSV8KSB+1PDCUgYgyDenWCjLNv5LjJi46xhzq4xlb1z9zeA8W5COiCD12XzpcmgaRrMwTBKoctfwF5LZJgp4I= Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=Shally.Verma@cavium.com; Received: from hyd1sverma-dt.caveonetworks.com (115.113.156.2) by SN4PR0701MB3646.namprd07.prod.outlook.com (2603:10b6:803:4d::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.973.21; Tue, 24 Jul 2018 15:06:12 +0000 From: Shally Verma To: pablo.de.lara.guarch@intel.com Cc: dev@dpdk.org, pathreya@caviumnetworks.com, mchalla@caviumnetworks.com, Sunila Sahu , Sunila Sahu , Ashish Gupta Date: Tue, 24 Jul 2018 20:35:35 +0530 Message-Id: <1532444736-26801-5-git-send-email-shally.verma@caviumnetworks.com> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1532444736-26801-1-git-send-email-shally.verma@caviumnetworks.com> References: <1532444736-26801-1-git-send-email-shally.verma@caviumnetworks.com> MIME-Version: 1.0 X-Originating-IP: [115.113.156.2] X-ClientProxiedBy: BM1PR0101CA0014.INDPRD01.PROD.OUTLOOK.COM (2603:1096:b00:18::24) To SN4PR0701MB3646.namprd07.prod.outlook.com (2603:10b6:803:4d::12) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 40005e21-f111-452e-4963-08d5f177001f X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989117)(4534165)(7168020)(4627221)(201703031133081)(201702281549075)(8990107)(5600073)(711020)(2017052603328)(7153060)(7193020); SRVR:SN4PR0701MB3646; X-Microsoft-Exchange-Diagnostics: 1; SN4PR0701MB3646; 3:3+PApzqIP1iSu1azq5y8aDXTRPuslnfJR4ZocDAiOanB+3ADoyTvEVS6uBO2mUTpa23ugp3StAFy/DF0WwTbNbw8OHCHPzlxYp4gtn8d6vamIhWqkqT/KfYfr9e80cp3ou8kZzcNf4GbKjZtbH9KZPpmbTQPPT5UTZdhqwcoXM4rA8faKS4oIQYdI61kIBJMLOl9tTIMRi9j995sPVSkxp/n5QmB0xb4hBkURG9B8scK4WPuHrao70z+umRXX4x2; 25:RprxhRwsP7lRxnSxlqBp+MO7vHmkcsW1cRrXz7Wgt3U877/i9yggVxxkx1cuiSK/sxyZs6US4A0iNv6Ft78Wti5ikNc4S7f+hIWFm2mOZIefag7kmcc2HxLkuUfEox04ouFr3eeyZOPUyRIpu/ycu1TrgwKGp1PGJDBWy0KdxOFcHOQlcidNongPwNw+Xxqbd89/m2NIHKN7Rc09c2I5MqpuinOUXgfBJMSun0y+iXLyviSuv/OLPcpTtUnzTJApPw71ZF+z3111wL+nj8hE1mvNhjPXrErJLtinVLhuJZOEZYbbzJ1dH2KMpvJpa4ffnF2wK1fol4qsjWaG575PIA==; 31:EbQcZbJXpp5j4dpZO3p+Ln5z59KEzgJ57EPEyz6NDuoWD7DutoeIOkxzTrqP5eJRXRP7sGDu9MWEbx6x9r128nbWdHMyf9Pm3lsjGBj9FEGBY6y+lg6YHXTo9kfYj1zL7EhAe3nUMFDWZUZnHgELRUXIL5+G6ArwVeT1I9j9Q2SLFYkP7r3TEEqMY6jO2VGuyxLbb3k1Z/3RmtU6TIwKDmmhEimQBt2YN/MQE7E67QE= X-MS-TrafficTypeDiagnostic: SN4PR0701MB3646: X-Microsoft-Exchange-Diagnostics: 1; SN4PR0701MB3646; 20:iikl79e7+Mm1UwwETjRMmp1CFvExDrYuZpS/7ezvherWGu7Xc1JXCIiQg8+MuYhNfQTply2xfLqtI6wNSalcPaluZMEsBt/gMyJCH+pxE6mdPjw2kHR4U//H5cCBrqzZGaUO/Z6iyVY2C1MpYa8/U918SMLCj0Du9/Rr3MXrnAldLKjRVKqJq0BeoZRiP6/yKmUEt4u7AQaGTwNI5WyCu287XevDi3wHYr7T7YMLNdkbH5t8BQoFFOeJ13rh5bDqqrj9+0tCwz3Tg88lyPKgyTAt/IkzB3X5yDBPR4UrLtro2N2hgOPSXOTmCz0O/bQmfXafNGl7/Z4MeXKBhtkNf2cCiaERjKt2GpGNAAH6STbTsw4wvn3iFyrucf0oNHT+xDCUQmd6ZD+P5Cs+huVBazMlDX5No8ov/F90NXex86V8qS7N/eU5os/EddrkQD8EYW23SDQ0WgOc2sTK41ObiKYuPrZyn7N/rl82VGFAlp8ncd678MKeVVjB0CHQQ/vKQ5PQ3W+RMrX/PsFooI4U2SJZ6MXdIObsWsA2ds/ieNhQ1P+bPpR5+ze4S+cFISeL4MlxGslwSnDI/BOdHNJmjnkhb7vHqI5znjNPPwriCrg=; 4:Achdz02gAGtIXBs0PXU3/EFvDSXhZbq1YuLsrdVUJqqQKUCpyiU8TPHHeqOyqLIviDvahlbbuMAusPiMomtNUIs0MoD/03t+PwOZauAlKcU2jRBrxpEHzDHn4wKv5jwnILoStsSxtwLTxbMe15Q7vLn3FRw/BcLKFkd43UpwYtJ/mAuEVkKY2saLVQghc24SsGq/tyPUphNe2gToKc3FCo+zCLBnL6Tb1pJ/U+WXZEw7XZIdvfCqHyX8OaXziAYdtEKIRWZ8pi852/H/KRInMQ== X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:; X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(5005006)(8121501046)(10201501046)(3231311)(944501410)(52105095)(93006095)(3002001)(149027)(150027)(6041310)(20161123562045)(20161123558120)(20161123564045)(20161123560045)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(6072148)(201708071742011)(7699016); SRVR:SN4PR0701MB3646; BCL:0; PCL:0; RULEID:; SRVR:SN4PR0701MB3646; X-Forefront-PRVS: 0743E8D0A6 X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(396003)(39860400002)(366004)(346002)(136003)(376002)(199004)(189003)(14444005)(26005)(2361001)(6506007)(55236004)(386003)(486006)(2616005)(2906002)(3846002)(36756003)(16526019)(956004)(6116002)(186003)(50226002)(68736007)(5660300001)(11346002)(4326008)(107886003)(478600001)(53936002)(476003)(52116002)(76176011)(51416003)(446003)(72206003)(48376002)(6666003)(97736004)(25786009)(42882007)(305945005)(2351001)(69596002)(54906003)(105586002)(106356001)(44832011)(6486002)(53416004)(66066001)(6512007)(316002)(7736002)(47776003)(8676002)(8936002)(81166006)(50466002)(16586007)(6916009)(81156014); DIR:OUT; SFP:1101; SCL:1; SRVR:SN4PR0701MB3646; H:hyd1sverma-dt.caveonetworks.com; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; A:1; MX:1; Received-SPF: None (protection.outlook.com: cavium.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; SN4PR0701MB3646; 23:FCW4t0PYEelTxqPD3oqVonE9zQRVPH1fUcmIFbT?= kOvJMEZEepvi+Y/Uuvp+rUGj/3zlhj5YSj/z2qeics8gwZA/I+/HCpEhX3olaGpthZSjQxhNUCPNzn5/PFvRVU/xkdB7wbrVPE9jyrtOg8aASGBkjmI1KL5DSB5qJlCbKItyjbDhIWtIOKjIQrjXOuVlxRocYwJ/CMaxoCTLNEAMVAmqdnyPWPRyN93Yp7LwP8/GEHPsg6nQqhtJNBWK7xK+2PPBxrCbKPYB3DfjJa5O5P6Ziyt0xsKtZ/RYCuOmVdFHFcxTBIBt0mveWyVro1onGKivC1faY32S4FKlHIzSgBphADt4hZFEvIT07SqPBE5ApuHwNGAERp/PwOLEnabj7IMPkIchOa2BIN7pigl3lUTwNsIhHELkjulpEQHY1y6fPX+V3jKw9a8AYmuPO490e/gDRZO0ytdReoJyt3TSh40ca02wX/e6BFD9oVK/ZtT+iPFVDbYMg3nFHaG4BDcuTOjTUwN+I8oCoMhZJJSLtY8wVMW8j2+auRsc+DJuerQH3ZSqqcbJHi4BqggW83XP+CqYtYLykc4Siqc4pfNDH/14zCOnsJRX/zhr4OS75iXYlxa/k/d/+2eeByoDB2G+jpdrTmJfe9bxL+3sH90/2XBZqlamR4tgfmMIDYKytjp+3hPaZ8ry/Zl9XI4MFuzK/KGZbeASQUUgj8+KRzLPG3DjaZxHGdSvVmTrFcvmOOQSzGvfsWly/Yi/dxbbqsqGG9VfuY6uIZb/VfdwWtnESAlyDm7tbyhpkgg0Wc5+nP0cFn14C6jrvGT1xd9w959MSr3W0R9XV0u4FhZCx8yAfLy7vs27BRTRbPjdjgY8tfTkuvnoWAl770pCPuV5dkMtvss+QcBauajKWafhD3gIZkPNX/818w6iTHpz1ni1Dnrsjukw8O9JsJv9gHfIlSe/BGWY0nsZLR1qGWsshI7wUqf2HypHzPbgT9KZFSHpCuTN+gQL5CfZGMu/9twwfORGaTg5Gew1JIZqYHhTBwG2c4p98hYPLjwGr0KAqhW/ut5TVCVNy++zEeKu1tRaC3WctVrAgR57737L3IKHSa7JztZKAlawHKKeEhjlgnB4NkCAVIpMwx0NOYZHDEVIBWHschAoBsHnCkuxusIB/aQKL/BHu5870WTKfpo8JEtAGEoth7Y6/g+tNjRVsHch01B4LKS62nCxl9p/zYvQJ25ZBh+vxZ5qIVAkj2wv43c0w8a9pcOyIziERoYRyvIFJ+8nOhzNKrwupHaLK890JXGlvNsk/ZCQkyEkppr6NYgRXL5ggmKX+dr4J93VmuYmflvd++lQoqQH6sjLux3QsBA0Jqj0za39rMKGB+6l3HMtjGb8= X-Microsoft-Antispam-Message-Info: Ykp4hTa/b1FvO4aEEbNrDQ+nom8acxdJa3pDBB81aj5pAxCgMzbKC5dKUlOHHWU3XVqhcNe7UaohZ0bAZ6IzlXgrHqlfwMbsFMoo2Ye17i/um9hAM3D0pNJi1vI8YL+zRNVa5OYPvar0o64oKbyrGHrqcjdg1FN+WBxntqpjb16Hjf7lDnN4uvVXzpq6Kb/+zbr0zDLSAENzAHyaNogsSgyiQybn7JDnhjgrBEkM2Fdw7OLx/jF+4MB55ZDMyzs8pLzfPojlvdc1oW+ygf9wd/eG/butgwWJiETfpFZEoInZEw/OOBWkNqe1lEPRFDr54+6YUnaWvzBHHAd7VTDoXyPp6PiZbQsEv9b/ijQm+yE= X-Microsoft-Exchange-Diagnostics: 1; SN4PR0701MB3646; 6:ijZ3aPJEwTr+B1Ps/TAh9b4n/gDUodgB+DmfQTrQS4hdQRyN602+mSvOL7siHaORLL8Uax9p28gElAng2ZGcVbUSipC18SupyLqLm2HL6IubE5gDF8NTiTdyq6BxjKgww9iOQ8S90qQ/2E80E4snk7rHNMhHnqaLVU/vg5Ch3sdtAjUHd+UWWnHCB2ixQi1u66hgdoocdEVlUKRHyodbtKufsCzQ23ho1ck7/J8SSOik4Ihbu0xM5L1A3J+LX0+gH3Q9pw3Km16jFgSNIkgY1m6JFRD9hjfgQ6YHcj3OoEIQeIhip0fdCMZHhhrM8C4FYgsHMARnxDRTc6Li1a675dSbMk96QpfFu/QXO+4bQO0ucqH4GMbSchS0Un3a1j8JoE7a3V8MkY9Wv+oIt2TlAb/MAh1tfPzGeV+8S8MjUuUqMl7Pw5yKUy+3H6ETq19RkE1vBICjFCfn1bMe0xMgeA==; 5:E/dFvEPKj4mZVRklAJFO6iicj/MlKxnR63FbQDP4/8M6YKy+aTIBXMWdMBwM0DUa5LQAIcD+1ZvIiut5u6vHb42fgm5oO2BRerWQY1lzmT7jxdpRHRH7yE7PLziSpjLnniy2J6KSC6bJt+VegvO3tID0X0FJFE7vZ9G63LbPI9M=; 7:fBs9rl6ImiM+AmUmn85FYypk+DuvoPY8NVmj0lcF8AT5Q+LlYOPECyJODWIhEnls6b9qdqs/xLvuIdnkFyigPo1JAKWiuxkXzXJmgS4krHSLp54bQZedVrwe5a9RCc3xXE6/4PmH9qKALQm1lOFWYUzsCgwbjwN4le7RVbPBLWL4p49HjJ5yP50Yyi1aug2ibrmlqv4vIlbWdPVdBHDZWdLLdyQivvWYZsfzsz9xW/sfwGT/I/2X8CqiSMi3tR3a SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-OriginatorOrg: caviumnetworks.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 24 Jul 2018 15:06:12.3228 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 40005e21-f111-452e-4963-08d5f177001f X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 711e4ccf-2e9b-4bcf-a551-4094005b6194 X-MS-Exchange-Transport-CrossTenantHeadersStamped: SN4PR0701MB3646 Subject: [dpdk-dev] [PATCH v5 4/5] compress/zlib: support burst enqueue/dequeue 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" From: Sunila Sahu Signed-off-by: Sunila Sahu Signed-off-by: Shally Verma Signed-off-by: Ashish Gupta --- drivers/compress/zlib/zlib_pmd.c | 255 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 254 insertions(+), 1 deletion(-) diff --git a/drivers/compress/zlib/zlib_pmd.c b/drivers/compress/zlib/zlib_pmd.c index 0d09c54..bee9602 100644 --- a/drivers/compress/zlib/zlib_pmd.c +++ b/drivers/compress/zlib/zlib_pmd.c @@ -7,7 +7,214 @@ #include "zlib_pmd_private.h" -/** Parse comp xform and set private xform/stream parameters */ +/** Compute next mbuf in the list, assign data buffer and length, + * returns 0 if mbuf is NULL + */ +#define COMPUTE_BUF(mbuf, data, len) \ + ((mbuf = mbuf->next) ? \ + (data = rte_pktmbuf_mtod(mbuf, uint8_t *)), \ + (len = rte_pktmbuf_data_len(mbuf)) : 0) + +static void +process_zlib_deflate(struct rte_comp_op *op, z_stream *strm) +{ + int ret, flush, fin_flush; + struct rte_mbuf *mbuf_src = op->m_src; + struct rte_mbuf *mbuf_dst = op->m_dst; + + switch (op->flush_flag) { + case RTE_COMP_FLUSH_FULL: + case RTE_COMP_FLUSH_FINAL: + fin_flush = Z_FINISH; + break; + default: + op->status = RTE_COMP_OP_STATUS_INVALID_ARGS; + ZLIB_PMD_ERR("Invalid flush value\n"); + } + + if (unlikely(!strm)) { + op->status = RTE_COMP_OP_STATUS_INVALID_ARGS; + ZLIB_PMD_ERR("Invalid z_stream\n"); + return; + } + /* Update z_stream with the inputs provided by application */ + strm->next_in = rte_pktmbuf_mtod_offset(mbuf_src, uint8_t *, + op->src.offset); + + strm->avail_in = rte_pktmbuf_data_len(mbuf_src) - op->src.offset; + + strm->next_out = rte_pktmbuf_mtod_offset(mbuf_dst, uint8_t *, + op->dst.offset); + + strm->avail_out = rte_pktmbuf_data_len(mbuf_dst) - op->dst.offset; + + /* Set flush value to NO_FLUSH unless it is last mbuf */ + flush = Z_NO_FLUSH; + /* Initialize status to SUCCESS */ + op->status = RTE_COMP_OP_STATUS_SUCCESS; + + do { + /* Set flush value to Z_FINISH for last block */ + if ((op->src.length - strm->total_in) <= strm->avail_in) { + strm->avail_in = (op->src.length - strm->total_in); + flush = fin_flush; + } + do { + ret = deflate(strm, flush); + if (unlikely(ret == Z_STREAM_ERROR)) { + /* error return, do not process further */ + op->status = RTE_COMP_OP_STATUS_ERROR; + goto def_end; + } + /* Break if Z_STREAM_END is encountered */ + if (ret == Z_STREAM_END) + goto def_end; + + /* Keep looping until input mbuf is consumed. + * Exit if destination mbuf gets exhausted. + */ + } while ((strm->avail_out == 0) && + COMPUTE_BUF(mbuf_dst, strm->next_out, strm->avail_out)); + + if (!strm->avail_out) { + /* there is no space for compressed output */ + op->status = RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED; + break; + } + + /* Update source buffer to next mbuf + * Exit if input buffers are fully consumed + */ + } while (COMPUTE_BUF(mbuf_src, strm->next_in, strm->avail_in)); + +def_end: + /* Update op stats */ + switch (op->status) { + case RTE_COMP_OP_STATUS_SUCCESS: + op->consumed += strm->total_in; + /* Fall-through */ + case RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED: + op->produced += strm->total_out; + break; + default: + ZLIB_PMD_ERR("stats not updated for status:%d\n", + op->status); + } + + deflateReset(strm); +} + +static void +process_zlib_inflate(struct rte_comp_op *op, z_stream *strm) +{ + int ret, flush; + struct rte_mbuf *mbuf_src = op->m_src; + struct rte_mbuf *mbuf_dst = op->m_dst; + + if (unlikely(!strm)) { + op->status = RTE_COMP_OP_STATUS_INVALID_ARGS; + ZLIB_PMD_ERR("Invalid z_stream\n"); + return; + } + strm->next_in = rte_pktmbuf_mtod_offset(mbuf_src, uint8_t *, + op->src.offset); + + strm->avail_in = rte_pktmbuf_data_len(mbuf_src) - op->src.offset; + + strm->next_out = rte_pktmbuf_mtod_offset(mbuf_dst, uint8_t *, + op->dst.offset); + + strm->avail_out = rte_pktmbuf_data_len(mbuf_dst) - op->dst.offset; + + /** Ignoring flush value provided from application for decompression */ + flush = Z_NO_FLUSH; + /* initialize status to SUCCESS */ + op->status = RTE_COMP_OP_STATUS_SUCCESS; + + do { + do { + ret = inflate(strm, flush); + + switch (ret) { + /* Fall-through */ + case Z_NEED_DICT: + ret = Z_DATA_ERROR; + /* Fall-through */ + case Z_DATA_ERROR: + /* Fall-through */ + case Z_MEM_ERROR: + /* Fall-through */ + case Z_STREAM_ERROR: + op->status = RTE_COMP_OP_STATUS_ERROR; + /* Fall-through */ + case Z_STREAM_END: + /* no further computation needed if + * Z_STREAM_END is encountered + */ + goto inf_end; + default: + /* success */ + break; + + } + /* Keep looping until input mbuf is consumed. + * Exit if destination mbuf gets exhausted. + */ + } while ((strm->avail_out == 0) && + COMPUTE_BUF(mbuf_dst, strm->next_out, strm->avail_out)); + + if (!strm->avail_out) { + /* there is no more space for decompressed output */ + op->status = RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED; + break; + } + /* Read next input buffer to be processed, exit if compressed + * blocks are fully read + */ + } while (COMPUTE_BUF(mbuf_src, strm->next_in, strm->avail_in)); + +inf_end: + /* Update op stats */ + switch (op->status) { + case RTE_COMP_OP_STATUS_SUCCESS: + op->consumed += strm->total_in; + /* Fall-through */ + case RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED: + op->produced += strm->total_out; + break; + default: + ZLIB_PMD_ERR("stats not produced for status:%d\n", + op->status); + } + + inflateReset(strm); +} + +/** Process comp operation for mbuf */ +static inline int +process_zlib_op(struct zlib_qp *qp, struct rte_comp_op *op) +{ + struct zlib_stream *stream; + struct zlib_priv_xform *private_xform; + + if ((op->op_type == RTE_COMP_OP_STATEFUL) || + (op->src.offset > rte_pktmbuf_data_len(op->m_src)) || + (op->dst.offset > rte_pktmbuf_data_len(op->m_dst))) { + op->status = RTE_COMP_OP_STATUS_INVALID_ARGS; + ZLIB_PMD_ERR("Invalid source or destination buffers or " + "invalid Operation requested\n"); + } else { + private_xform = (struct zlib_priv_xform *)op->private_xform; + stream = &private_xform->stream; + stream->comp(op, &stream->strm); + } + /* whatever is out of op, put it into completion queue with + * its status + */ + return rte_ring_enqueue(qp->processed_pkts, (void *)op); +} + +/** Parse comp xform and set private xform/Stream parameters */ int zlib_set_stream_parameters(const struct rte_comp_xform *xform, struct zlib_stream *stream) @@ -22,6 +229,8 @@ zlib_set_stream_parameters(const struct rte_comp_xform *xform, switch (xform->type) { case RTE_COMP_COMPRESS: + stream->comp = process_zlib_deflate; + stream->free = deflateEnd; /** Compression window bits */ switch (xform->compress.algo) { case RTE_COMP_ALGO_DEFLATE: @@ -80,6 +289,8 @@ zlib_set_stream_parameters(const struct rte_comp_xform *xform, break; case RTE_COMP_DECOMPRESS: + stream->comp = process_zlib_inflate; + stream->free = inflateEnd; /** window bits */ switch (xform->decompress.algo) { case RTE_COMP_ALGO_DEFLATE: @@ -101,6 +312,44 @@ zlib_set_stream_parameters(const struct rte_comp_xform *xform, return 0; } +static uint16_t +zlib_pmd_enqueue_burst(void *queue_pair, + struct rte_comp_op **ops, uint16_t nb_ops) +{ + struct zlib_qp *qp = queue_pair; + int ret; + uint16_t i; + uint16_t enqd = 0; + for (i = 0; i < nb_ops; i++) { + ret = process_zlib_op(qp, ops[i]); + if (unlikely(ret < 0)) { + /* increment count if failed to push to completion + * queue + */ + qp->qp_stats.enqueue_err_count++; + } else { + qp->qp_stats.enqueued_count++; + enqd++; + } + } + return enqd; +} + +static uint16_t +zlib_pmd_dequeue_burst(void *queue_pair, + struct rte_comp_op **ops, uint16_t nb_ops) +{ + struct zlib_qp *qp = queue_pair; + + unsigned int nb_dequeued = 0; + + nb_dequeued = rte_ring_dequeue_burst(qp->processed_pkts, + (void **)ops, nb_ops, NULL); + qp->qp_stats.dequeued_count += nb_dequeued; + + return nb_dequeued; +} + static int zlib_create(const char *name, struct rte_vdev_device *vdev, @@ -117,6 +366,10 @@ zlib_create(const char *name, dev->dev_ops = rte_zlib_pmd_ops; + /* register rx/tx burst functions for data path */ + dev->dequeue_burst = zlib_pmd_dequeue_burst; + dev->enqueue_burst = zlib_pmd_enqueue_burst; + return 0; }