From mboxrd@z Thu Jan 1 00:00:00 1970
Return-Path: <dev-bounces@dpdk.org>
Received: from dpdk.org (dpdk.org [92.243.14.124])
by inbox.dpdk.org (Postfix) with ESMTP id 2C9C3A3160
for <public@inbox.dpdk.org>; Fri, 11 Oct 2019 21:22:16 +0200 (CEST)
Received: from [92.243.14.124] (localhost [127.0.0.1])
by dpdk.org (Postfix) with ESMTP id 93F401EB61;
Fri, 11 Oct 2019 21:22:15 +0200 (CEST)
Received: from EUR03-VE1-obe.outbound.protection.outlook.com
(mail-eopbgr50043.outbound.protection.outlook.com [40.107.5.43])
by dpdk.org (Postfix) with ESMTP id C9D841EB5C
for <dev@dpdk.org>; Fri, 11 Oct 2019 21:22:13 +0200 (CEST)
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=armh.onmicrosoft.com;
s=selector2-armh-onmicrosoft-com;
h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck;
bh=KpCplXwzYq32/5YSMgOQPKDBcs9gcl6/8MTV5vog4Zw=;
b=5+s0osW1+Mp/5lQ/01jsOvCtYwpo+bEK1jmMT57NgGLrw7rGK2QgvEKBJRObY3g22mLUobeABW1oDwpiR0fSQtCJErSRwyVO+mG95/gPDs6vi5xXLrRCgDijeu+9k8QHnKdYkfrUsF/Fwkyrfhg9+XnpUrIkvMslaEbmQmyn/Ug=
Received: from VI1PR08CA0170.eurprd08.prod.outlook.com (2603:10a6:800:d1::24)
by HE1PR08MB2905.eurprd08.prod.outlook.com (2603:10a6:7:31::24) with
Microsoft SMTP Server (version=TLS1_2,
cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.2347.21; Fri, 11 Oct
2019 19:22:08 +0000
Received: from DB5EUR03FT045.eop-EUR03.prod.protection.outlook.com
(2a01:111:f400:7e0a::208) by VI1PR08CA0170.outlook.office365.com
(2603:10a6:800:d1::24) with Microsoft SMTP Server (version=TLS1_2,
cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384) id 15.20.2347.16 via Frontend
Transport; Fri, 11 Oct 2019 19:22:08 +0000
Authentication-Results: spf=temperror (sender IP is 63.35.35.123)
smtp.mailfrom=arm.com; dpdk.org; dkim=pass (signature was verified)
header.d=armh.onmicrosoft.com;dpdk.org; dmarc=none action=none
header.from=arm.com;
Received-SPF: TempError (protection.outlook.com: error in processing during
lookup of arm.com: DNS Timeout)
Received: from 64aa7808-outbound-1.mta.getcheckrecipient.com (63.35.35.123) by
DB5EUR03FT045.mail.protection.outlook.com (10.152.21.164) with
Microsoft SMTP
Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384) id
15.20.2305.15 via Frontend Transport; Fri, 11 Oct 2019 19:22:07 +0000
Received: ("Tessian outbound 0cf06bf5c60e:v33");
Fri, 11 Oct 2019 19:22:01 +0000
X-CR-MTA-TID: 64aa7808
Received: from aa37aa81041c.3 (ip-172-16-0-2.eu-west-1.compute.internal
[104.47.8.59]) by 64aa7808-outbound-1.mta.getcheckrecipient.com id
7690B25F-3896-4845-99A8-CB6E58EAC961.1;
Fri, 11 Oct 2019 19:21:56 +0000
Received: from EUR03-AM5-obe.outbound.protection.outlook.com
(mail-am5eur03lp2059.outbound.protection.outlook.com [104.47.8.59])
by 64aa7808-outbound-1.mta.getcheckrecipient.com with ESMTPS id aa37aa81041c.3
(version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384);
Fri, 11 Oct 2019 19:21:56 +0000
ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none;
b=gfEx9Y+JWwqos5GcOFbPY0+Bu9M5y+6Ad+OQFqw086Ffe4Kx7I1/4zcxB+TT28CFQ/sHuAasMz3TgPs+SJ6SCPcaGWDBho22bplPD/UK7V9+BdvuA0pcZi0DTT8Kou2ldnuIunFNP9vKiCJmok/NTX+0LA9XqVAen3k5xyPPJhfUOGOtDxRSHPGlOoe+aXipNefGn6ET9UU90YgEtp0a6q2TKJ50Ar3XTvm+V9ZjMT+ASX9FbIDSKuYWgaHZ2uQoSpWpTyZNTWCtOZd70Z9ePFLZ/9kdK6rqaLor3yNXegEt1v/GYZ4UQGBEknpLEPwSS4BcaF1ynHbRwQ2rR3KZOQ==
ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com;
s=arcselector9901;
h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck;
bh=KpCplXwzYq32/5YSMgOQPKDBcs9gcl6/8MTV5vog4Zw=;
b=hWY+ZhS82poXOs1t1PiTrMW9pTHFQz2DvF+dEFava14mqgxogYw8yRdubL7hrVaiPn4E9irE53aYkuXRCHPYEtpj6nYpLFC3dkiVB/GyMb/x1dL8Ffh6IG1kWKAKWwNSclczVAhzaLVDQuGcO2ZcHJwJZCoZ9wyXnJifqKV/wI13tSf2svn95ZvQ9zIg5vyMuVhFJ7CP14pXI827HRrQxpE+r6+FAXtlo5jckny5mS2mVx9g0MIGOgnxO5TbsIzewADb+S0aT8VMdw8blXV6/16Blo/dMQu5jxDRlqeCdiqnoxmHs8Hmy1TVBtLS0ALTIiUHpeX/d8UPwIIvtiUBTw==
ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass
smtp.mailfrom=arm.com; dmarc=pass action=none header.from=arm.com; dkim=pass
header.d=arm.com; arc=none
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=armh.onmicrosoft.com;
s=selector2-armh-onmicrosoft-com;
h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck;
bh=KpCplXwzYq32/5YSMgOQPKDBcs9gcl6/8MTV5vog4Zw=;
b=5+s0osW1+Mp/5lQ/01jsOvCtYwpo+bEK1jmMT57NgGLrw7rGK2QgvEKBJRObY3g22mLUobeABW1oDwpiR0fSQtCJErSRwyVO+mG95/gPDs6vi5xXLrRCgDijeu+9k8QHnKdYkfrUsF/Fwkyrfhg9+XnpUrIkvMslaEbmQmyn/Ug=
Received: from VE1PR08MB5149.eurprd08.prod.outlook.com (20.179.30.27) by
VE1PR08MB4863.eurprd08.prod.outlook.com (10.255.114.202) with Microsoft SMTP
Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id
15.20.2347.19; Fri, 11 Oct 2019 19:21:54 +0000
Received: from VE1PR08MB5149.eurprd08.prod.outlook.com
([fe80::8c82:8d9c:c78d:22a6]) by VE1PR08MB5149.eurprd08.prod.outlook.com
([fe80::8c82:8d9c:c78d:22a6%7]) with mapi id 15.20.2347.016; Fri, 11 Oct 2019
19:21:54 +0000
From: Honnappa Nagarahalli <Honnappa.Nagarahalli@arm.com>
To: Honnappa Nagarahalli <Honnappa.Nagarahalli@arm.com>,
"olivier.matz@6wind.com" <olivier.matz@6wind.com>, "sthemmin@microsoft.com"
<sthemmin@microsoft.com>, "jerinj@marvell.com" <jerinj@marvell.com>,
"bruce.richardson@intel.com" <bruce.richardson@intel.com>,
"david.marchand@redhat.com" <david.marchand@redhat.com>,
"pbhagavatula@marvell.com" <pbhagavatula@marvell.com>,
"konstantin.ananyev@intel.com" <konstantin.ananyev@intel.com>
CC: "dev@dpdk.org" <dev@dpdk.org>, Dharmik Thakkar <Dharmik.Thakkar@arm.com>,
"Ruifeng Wang (Arm Technology China)" <Ruifeng.Wang@arm.com>,
"Gavin Hu (Arm
Technology China)" <Gavin.Hu@arm.com>, "stephen@networkplumber.org"
<stephen@networkplumber.org>, Honnappa Nagarahalli
<Honnappa.Nagarahalli@arm.com>, nd <nd@arm.com>, nd <nd@arm.com>
Thread-Topic: [PATCH v4 1/2] lib/ring: apis to support configurable element
size
Thread-Index: AQHVgGkjycLlQ66roUqbf1hqE7rJkw==
Date: Fri, 11 Oct 2019 19:21:53 +0000
Message-ID: <VE1PR08MB5149D57CAA77B51392E5423898970@VE1PR08MB5149.eurprd08.prod.outlook.com>
References: <20190906190510.11146-1-honnappa.nagarahalli@arm.com>
<20191009024709.38144-1-honnappa.nagarahalli@arm.com>
<20191009024709.38144-2-honnappa.nagarahalli@arm.com>
In-Reply-To: <20191009024709.38144-2-honnappa.nagarahalli@arm.com>
Accept-Language: en-US
Content-Language: en-US
X-MS-Has-Attach:
X-MS-TNEF-Correlator:
x-ts-tracking-id: e517624d-30b1-4753-85b1-863678abd9f8.0
x-checkrecipientchecked: true
Authentication-Results-Original: spf=none (sender IP is )
smtp.mailfrom=Honnappa.Nagarahalli@arm.com;
x-originating-ip: [217.140.111.135]
x-ms-publictraffictype: Email
X-MS-Office365-Filtering-Correlation-Id: b6172466-3129-4045-1ff1-08d74e804e3e
X-MS-Office365-Filtering-HT: Tenant
X-MS-TrafficTypeDiagnostic: VE1PR08MB4863:|VE1PR08MB4863:|HE1PR08MB2905:
x-ld-processed: f34e5979-57d9-4aaa-ad4d-b122a662184d,ExtAddr
x-ms-exchange-transport-forked: True
X-Microsoft-Antispam-PRVS: <HE1PR08MB29055542CC35E45A4CA42FCB98970@HE1PR08MB2905.eurprd08.prod.outlook.com>
x-checkrecipientrouted: true
x-ms-oob-tlc-oobclassifiers: OLM:9508;OLM:9508;
x-forefront-prvs: 0187F3EA14
X-Forefront-Antispam-Report-Untrusted: SFV:NSPM;
SFS:(10009020)(4636009)(39860400002)(136003)(376002)(366004)(346002)(396003)(199004)(13464003)(189003)(476003)(8676002)(99286004)(186003)(110136005)(486006)(54906003)(11346002)(446003)(6436002)(45080400002)(66946007)(66556008)(66446008)(55016002)(14454004)(478600001)(64756008)(9686003)(6506007)(53546011)(76176011)(25786009)(66476007)(102836004)(26005)(316002)(7696005)(76116006)(2201001)(33656002)(7736002)(6116002)(3846002)(2501003)(305945005)(14444005)(66066001)(52536014)(71190400001)(256004)(2906002)(86362001)(30864003)(8936002)(6246003)(81166006)(81156014)(229853002)(1511001)(74316002)(5660300002)(4326008)(71200400001)(569006);
DIR:OUT; SFP:1101; SCL:1; SRVR:VE1PR08MB4863;
H:VE1PR08MB5149.eurprd08.prod.outlook.com; FPR:; SPF:None; LANG:en;
PTR:InfoNoRecords; A:1; MX:1;
received-spf: None (protection.outlook.com: arm.com does not designate
permitted sender hosts)
X-MS-Exchange-SenderADCheck: 1
X-Microsoft-Antispam-Untrusted: BCL:0;
X-Microsoft-Antispam-Message-Info-Original: kgbxiCOWRTIqy5NsjEnWg65o5fAdy5UYx2OEvQhcv9cauLoDKvTrcXsLhEd9yPFWjTWL7U1/Gi4b7npGSsmH3E1SVtjYBQ0ZJCt6TMu3p0DOABQ6kkdqO45LUSt1rRwiB6toE2P5j5IH8j4gwPqM4zpTWqT2NIpT/4ysXVkkDn4g1q58LB/mlnHLpHl+n81NTQ6WEWlDUX1ZYzDgxBQ0vUtqUrA3hLNtc9Virev4D4i06IXjhKDcOChUvDgF4QwlkLNQulCnGEy9vF+uNYKcuyQuiyMxBlMg0Kj9ejQSJeVg7cXWYqBH8IT62DZqOLwWocGyjtD4aUqqigquex/VfGbOq29qu3M26GTW725POvH9A/GkVmXw4a8RWDb7oLMbeqE9JxBb1FCMxZSnWle44zC+dJ4bkzSyvoLr5VIENQw=
Content-Type: text/plain; charset="us-ascii"
Content-Transfer-Encoding: quoted-printable
MIME-Version: 1.0
X-MS-Exchange-Transport-CrossTenantHeadersStamped: VE1PR08MB4863
Original-Authentication-Results: spf=none (sender IP is )
smtp.mailfrom=Honnappa.Nagarahalli@arm.com;
X-EOPAttributedMessage: 0
X-MS-Exchange-Transport-CrossTenantHeadersStripped: DB5EUR03FT045.eop-EUR03.prod.protection.outlook.com
X-Forefront-Antispam-Report: CIP:63.35.35.123; IPV:CAL; SCL:-1; CTRY:IE;
EFV:NLI; SFV:NSPM;
SFS:(10009020)(4636009)(396003)(346002)(136003)(376002)(39860400002)(13464003)(199004)(189003)(55016002)(45080400002)(30864003)(46406003)(26826003)(478600001)(110136005)(54906003)(316002)(5660300002)(4326008)(50466002)(6246003)(14454004)(476003)(229853002)(25786009)(70206006)(70586007)(23726003)(52536014)(6116002)(3846002)(76130400001)(9686003)(2906002)(2501003)(11346002)(446003)(486006)(74316002)(126002)(63350400001)(1511001)(47776003)(7696005)(66066001)(99286004)(22756006)(2201001)(14444005)(81166006)(81156014)(7736002)(86362001)(8746002)(8936002)(26005)(305945005)(186003)(356004)(336012)(102836004)(8676002)(33656002)(97756001)(53546011)(6506007)(76176011)(579004);
DIR:OUT; SFP:1101; SCL:1; SRVR:HE1PR08MB2905;
H:64aa7808-outbound-1.mta.getcheckrecipient.com; FPR:; SPF:TempError; LANG:en;
PTR:ec2-63-35-35-123.eu-west-1.compute.amazonaws.com; A:1; MX:1;
X-MS-Office365-Filtering-Correlation-Id-Prvs: 5771b660-6cd6-4d7a-9f7b-08d74e804669
NoDisclaimer: True
X-Forefront-PRVS: 0187F3EA14
X-Microsoft-Antispam: BCL:0;
X-Microsoft-Antispam-Message-Info: qxHixX/KoYnw25pE+P1VmRYy/Be6lVmQzZBWblnwUJHclRnht3girEK5c6cEfUyLL0T1gaYl2SP+AN4//De8NJ8Ol2UHxhDLBxcgBUfnVeNYSc1IRqmsUpCv/1wRYqhR9qkSF7/Opf+PBxr1szsze1WyxX4aVjoPNH69FWNp1S/tazUQf4mw4skqgX2BNN/baqW2Aopue6UE4vLi6TKIksIhI6ZlkdAgJo6wuMLhsIqcSQD52XEH+NTDE07XUIKFpeWN1FZGqWdcAi8UNouM2hqfgSOGGVqg1B82d7TN2tgmi1YeBAiuC4DRSRplnOtNSXq1ARxzgPeiopWPmZ1kBaHSQxA6aZ0xVv3noqq18v3531k/jIK1LihDTyaTXkyEVtev9lfuNyZ2A3/Vr6slyiGjqri0TbkNWQ61MLlpmHM=
X-OriginatorOrg: arm.com
X-MS-Exchange-CrossTenant-OriginalArrivalTime: 11 Oct 2019 19:22:07.0658 (UTC)
X-MS-Exchange-CrossTenant-Network-Message-Id: b6172466-3129-4045-1ff1-08d74e804e3e
X-MS-Exchange-CrossTenant-Id: f34e5979-57d9-4aaa-ad4d-b122a662184d
X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=f34e5979-57d9-4aaa-ad4d-b122a662184d; Ip=[63.35.35.123];
Helo=[64aa7808-outbound-1.mta.getcheckrecipient.com]
X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem
X-MS-Exchange-Transport-CrossTenantHeadersStamped: HE1PR08MB2905
Subject: Re: [dpdk-dev] [PATCH v4 1/2] lib/ring: apis to support
configurable element size
X-BeenThere: dev@dpdk.org
X-Mailman-Version: 2.1.15
Precedence: list
List-Id: DPDK patches and discussions <dev.dpdk.org>
List-Unsubscribe: <https://mails.dpdk.org/options/dev>,
<mailto:dev-request@dpdk.org?subject=unsubscribe>
List-Archive: <http://mails.dpdk.org/archives/dev/>
List-Post: <mailto:dev@dpdk.org>
List-Help: <mailto:dev-request@dpdk.org?subject=help>
List-Subscribe: <https://mails.dpdk.org/listinfo/dev>,
<mailto:dev-request@dpdk.org?subject=subscribe>
Errors-To: dev-bounces@dpdk.org
Sender: "dev" <dev-bounces@dpdk.org>
Hi Bruce, Konstantin, Stephen,
Appreciate if you could provide feedback on this.
Thanks,
Honnappa
> -----Original Message-----
> From: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com>
> Sent: Tuesday, October 8, 2019 9:47 PM
> To: olivier.matz@6wind.com; sthemmin@microsoft.com; jerinj@marvell.com;
> bruce.richardson@intel.com; david.marchand@redhat.com;
> pbhagavatula@marvell.com; konstantin.ananyev@intel.com; Honnappa
> Nagarahalli <Honnappa.Nagarahalli@arm.com>
> Cc: dev@dpdk.org; Dharmik Thakkar <Dharmik.Thakkar@arm.com>; Ruifeng
> Wang (Arm Technology China) <Ruifeng.Wang@arm.com>; Gavin Hu (Arm
> Technology China) <Gavin.Hu@arm.com>
> Subject: [PATCH v4 1/2] lib/ring: apis to support configurable element si=
ze
>=20
> Current APIs assume ring elements to be pointers. However, in many use ca=
ses,
> the size can be different. Add new APIs to support configurable ring elem=
ent
> sizes.
>=20
> Signed-off-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com>
> Reviewed-by: Dharmik Thakkar <dharmik.thakkar@arm.com>
> Reviewed-by: Gavin Hu <gavin.hu@arm.com>
> Reviewed-by: Ruifeng Wang <ruifeng.wang@arm.com>
> ---
> lib/librte_ring/Makefile | 3 +-
> lib/librte_ring/meson.build | 3 +
> lib/librte_ring/rte_ring.c | 45 +-
> lib/librte_ring/rte_ring.h | 1 +
> lib/librte_ring/rte_ring_elem.h | 946 +++++++++++++++++++++++++++
> lib/librte_ring/rte_ring_version.map | 2 +
> 6 files changed, 991 insertions(+), 9 deletions(-) create mode 100644
> lib/librte_ring/rte_ring_elem.h
>=20
> diff --git a/lib/librte_ring/Makefile b/lib/librte_ring/Makefile index
> 21a36770d..515a967bb 100644
> --- a/lib/librte_ring/Makefile
> +++ b/lib/librte_ring/Makefile
> @@ -6,7 +6,7 @@ include $(RTE_SDK)/mk/rte.vars.mk # library name LIB =
=3D
> librte_ring.a
>=20
> -CFLAGS +=3D $(WERROR_FLAGS) -I$(SRCDIR) -O3
> +CFLAGS +=3D $(WERROR_FLAGS) -I$(SRCDIR) -O3 -
> DALLOW_EXPERIMENTAL_API
> LDLIBS +=3D -lrte_eal
>=20
> EXPORT_MAP :=3D rte_ring_version.map
> @@ -18,6 +18,7 @@ SRCS-$(CONFIG_RTE_LIBRTE_RING) :=3D rte_ring.c
>=20
> # install includes
> SYMLINK-$(CONFIG_RTE_LIBRTE_RING)-include :=3D rte_ring.h \
> + rte_ring_elem.h \
> rte_ring_generic.h \
> rte_ring_c11_mem.h
>=20
> diff --git a/lib/librte_ring/meson.build b/lib/librte_ring/meson.build in=
dex
> ab8b0b469..74219840a 100644
> --- a/lib/librte_ring/meson.build
> +++ b/lib/librte_ring/meson.build
> @@ -6,3 +6,6 @@ sources =3D files('rte_ring.c') headers =3D files('rte_r=
ing.h',
> 'rte_ring_c11_mem.h',
> 'rte_ring_generic.h')
> +
> +# rte_ring_create_elem and rte_ring_get_memsize_elem are experimental
> +allow_experimental_apis =3D true
> diff --git a/lib/librte_ring/rte_ring.c b/lib/librte_ring/rte_ring.c inde=
x
> d9b308036..6fed3648b 100644
> --- a/lib/librte_ring/rte_ring.c
> +++ b/lib/librte_ring/rte_ring.c
> @@ -33,6 +33,7 @@
> #include <rte_tailq.h>
>=20
> #include "rte_ring.h"
> +#include "rte_ring_elem.h"
>=20
> TAILQ_HEAD(rte_ring_list, rte_tailq_entry);
>=20
> @@ -46,23 +47,42 @@ EAL_REGISTER_TAILQ(rte_ring_tailq)
>=20
> /* return the size of memory occupied by a ring */ ssize_t -
> rte_ring_get_memsize(unsigned count)
> +rte_ring_get_memsize_elem(unsigned count, unsigned esize)
> {
> ssize_t sz;
>=20
> + /* Supported esize values are 4/8/16.
> + * Others can be added on need basis.
> + */
> + if ((esize !=3D 4) && (esize !=3D 8) && (esize !=3D 16)) {
> + RTE_LOG(ERR, RING,
> + "Unsupported esize value. Supported values are 4, 8
> and 16\n");
> +
> + return -EINVAL;
> + }
> +
> /* count must be a power of 2 */
> if ((!POWEROF2(count)) || (count > RTE_RING_SZ_MASK )) {
> RTE_LOG(ERR, RING,
> - "Requested size is invalid, must be power of 2, and "
> - "do not exceed the size limit %u\n",
> RTE_RING_SZ_MASK);
> + "Requested number of elements is invalid, must be "
> + "power of 2, and do not exceed the limit %u\n",
> + RTE_RING_SZ_MASK);
> +
> return -EINVAL;
> }
>=20
> - sz =3D sizeof(struct rte_ring) + count * sizeof(void *);
> + sz =3D sizeof(struct rte_ring) + count * esize;
> sz =3D RTE_ALIGN(sz, RTE_CACHE_LINE_SIZE);
> return sz;
> }
>=20
> +/* return the size of memory occupied by a ring */ ssize_t
> +rte_ring_get_memsize(unsigned count) {
> + return rte_ring_get_memsize_elem(count, sizeof(void *)); }
> +
> void
> rte_ring_reset(struct rte_ring *r)
> {
> @@ -114,10 +134,10 @@ rte_ring_init(struct rte_ring *r, const char *name,
> unsigned count,
> return 0;
> }
>=20
> -/* create the ring */
> +/* create the ring for a given element size */
> struct rte_ring *
> -rte_ring_create(const char *name, unsigned count, int socket_id,
> - unsigned flags)
> +rte_ring_create_elem(const char *name, unsigned count, unsigned esize,
> + int socket_id, unsigned flags)
> {
> char mz_name[RTE_MEMZONE_NAMESIZE];
> struct rte_ring *r;
> @@ -135,7 +155,7 @@ rte_ring_create(const char *name, unsigned count,
> int socket_id,
> if (flags & RING_F_EXACT_SZ)
> count =3D rte_align32pow2(count + 1);
>=20
> - ring_size =3D rte_ring_get_memsize(count);
> + ring_size =3D rte_ring_get_memsize_elem(count, esize);
> if (ring_size < 0) {
> rte_errno =3D ring_size;
> return NULL;
> @@ -182,6 +202,15 @@ rte_ring_create(const char *name, unsigned count,
> int socket_id,
> return r;
> }
>=20
> +/* create the ring */
> +struct rte_ring *
> +rte_ring_create(const char *name, unsigned count, int socket_id,
> + unsigned flags)
> +{
> + return rte_ring_create_elem(name, count, sizeof(void *), socket_id,
> + flags);
> +}
> +
> /* free the ring */
> void
> rte_ring_free(struct rte_ring *r)
> diff --git a/lib/librte_ring/rte_ring.h b/lib/librte_ring/rte_ring.h inde=
x
> 2a9f768a1..18fc5d845 100644
> --- a/lib/librte_ring/rte_ring.h
> +++ b/lib/librte_ring/rte_ring.h
> @@ -216,6 +216,7 @@ int rte_ring_init(struct rte_ring *r, const char *nam=
e,
> unsigned count,
> */
> struct rte_ring *rte_ring_create(const char *name, unsigned count,
> int socket_id, unsigned flags);
> +
> /**
> * De-allocate all memory used by the ring.
> *
> diff --git a/lib/librte_ring/rte_ring_elem.h b/lib/librte_ring/rte_ring_e=
lem.h
> new file mode 100644 index 000000000..860f059ad
> --- /dev/null
> +++ b/lib/librte_ring/rte_ring_elem.h
> @@ -0,0 +1,946 @@
> +/* SPDX-License-Identifier: BSD-3-Clause
> + *
> + * Copyright (c) 2019 Arm Limited
> + * Copyright (c) 2010-2017 Intel Corporation
> + * Copyright (c) 2007-2009 Kip Macy kmacy@freebsd.org
> + * All rights reserved.
> + * Derived from FreeBSD's bufring.h
> + * Used as BSD-3 Licensed with permission from Kip Macy.
> + */
> +
> +#ifndef _RTE_RING_ELEM_H_
> +#define _RTE_RING_ELEM_H_
> +
> +/**
> + * @file
> + * RTE Ring with flexible element size
> + */
> +
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> +
> +#include <stdio.h>
> +#include <stdint.h>
> +#include <sys/queue.h>
> +#include <errno.h>
> +#include <rte_common.h>
> +#include <rte_config.h>
> +#include <rte_memory.h>
> +#include <rte_lcore.h>
> +#include <rte_atomic.h>
> +#include <rte_branch_prediction.h>
> +#include <rte_memzone.h>
> +#include <rte_pause.h>
> +
> +#include "rte_ring.h"
> +
> +/**
> + * @warning
> + * @b EXPERIMENTAL: this API may change without prior notice
> + *
> + * Calculate the memory size needed for a ring with given element size
> + *
> + * This function returns the number of bytes needed for a ring, given
> + * the number of elements in it and the size of the element. This value
> + * is the sum of the size of the structure rte_ring and the size of the
> + * memory needed for storing the elements. The value is aligned to a
> +cache
> + * line size.
> + *
> + * @param count
> + * The number of elements in the ring (must be a power of 2).
> + * @param esize
> + * The size of ring element, in bytes. It must be a multiple of 4.
> + * Currently, sizes 4, 8 and 16 are supported.
> + * @return
> + * - The memory size needed for the ring on success.
> + * - -EINVAL if count is not a power of 2.
> + */
> +__rte_experimental
> +ssize_t rte_ring_get_memsize_elem(unsigned count, unsigned esize);
> +
> +/**
> + * @warning
> + * @b EXPERIMENTAL: this API may change without prior notice
> + *
> + * Create a new ring named *name* that stores elements with given size.
> + *
> + * This function uses ``memzone_reserve()`` to allocate memory. Then it
> + * calls rte_ring_init() to initialize an empty ring.
> + *
> + * The new ring size is set to *count*, which must be a power of
> + * two. Water marking is disabled by default. The real usable ring size
> + * is *count-1* instead of *count* to differentiate a free ring from an
> + * empty ring.
> + *
> + * The ring is added in RTE_TAILQ_RING list.
> + *
> + * @param name
> + * The name of the ring.
> + * @param count
> + * The number of elements in the ring (must be a power of 2).
> + * @param esize
> + * The size of ring element, in bytes. It must be a multiple of 4.
> + * Currently, sizes 4, 8 and 16 are supported.
> + * @param socket_id
> + * The *socket_id* argument is the socket identifier in case of
> + * NUMA. The value can be *SOCKET_ID_ANY* if there is no NUMA
> + * constraint for the reserved zone.
> + * @param flags
> + * An OR of the following:
> + * - RING_F_SP_ENQ: If this flag is set, the default behavior when
> + * using ``rte_ring_enqueue()`` or ``rte_ring_enqueue_bulk()``
> + * is "single-producer". Otherwise, it is "multi-producers".
> + * - RING_F_SC_DEQ: If this flag is set, the default behavior when
> + * using ``rte_ring_dequeue()`` or ``rte_ring_dequeue_bulk()``
> + * is "single-consumer". Otherwise, it is "multi-consumers".
> + * @return
> + * On success, the pointer to the new allocated ring. NULL on error wi=
th
> + * rte_errno set appropriately. Possible errno values include:
> + * - E_RTE_NO_CONFIG - function could not get pointer to rte_config
> structure
> + * - E_RTE_SECONDARY - function was called from a secondary process
> instance
> + * - EINVAL - count provided is not a power of 2
> + * - ENOSPC - the maximum number of memzones has already been
> allocated
> + * - EEXIST - a memzone with the same name already exists
> + * - ENOMEM - no appropriate memory area found in which to create
> memzone
> + */
> +__rte_experimental
> +struct rte_ring *rte_ring_create_elem(const char *name, unsigned count,
> + unsigned esize, int socket_id, unsigned flags);
> +
> +/* the actual enqueue of pointers on the ring.
> + * Placed here since identical code needed in both
> + * single and multi producer enqueue functions.
> + */
> +#define ENQUEUE_PTRS_ELEM(r, ring_start, prod_head, obj_table, esize, n)
> do { \
> + if (esize =3D=3D 4) \
> + ENQUEUE_PTRS_32(r, ring_start, prod_head, obj_table, n); \
> + else if (esize =3D=3D 8) \
> + ENQUEUE_PTRS_64(r, ring_start, prod_head, obj_table, n); \
> + else if (esize =3D=3D 16) \
> + ENQUEUE_PTRS_128(r, ring_start, prod_head, obj_table, n); \ }
> while
> +(0)
> +
> +#define ENQUEUE_PTRS_32(r, ring_start, prod_head, obj_table, n) do { \
> + unsigned int i; \
> + const uint32_t size =3D (r)->size; \
> + uint32_t idx =3D prod_head & (r)->mask; \
> + uint32_t *ring =3D (uint32_t *)ring_start; \
> + uint32_t *obj =3D (uint32_t *)obj_table; \
> + if (likely(idx + n < size)) { \
> + for (i =3D 0; i < (n & ((~(unsigned)0x7))); i +=3D 8, idx +=3D 8) { \
> + ring[idx] =3D obj[i]; \
> + ring[idx + 1] =3D obj[i + 1]; \
> + ring[idx + 2] =3D obj[i + 2]; \
> + ring[idx + 3] =3D obj[i + 3]; \
> + ring[idx + 4] =3D obj[i + 4]; \
> + ring[idx + 5] =3D obj[i + 5]; \
> + ring[idx + 6] =3D obj[i + 6]; \
> + ring[idx + 7] =3D obj[i + 7]; \
> + } \
> + switch (n & 0x7) { \
> + case 7: \
> + ring[idx++] =3D obj[i++]; /* fallthrough */ \
> + case 6: \
> + ring[idx++] =3D obj[i++]; /* fallthrough */ \
> + case 5: \
> + ring[idx++] =3D obj[i++]; /* fallthrough */ \
> + case 4: \
> + ring[idx++] =3D obj[i++]; /* fallthrough */ \
> + case 3: \
> + ring[idx++] =3D obj[i++]; /* fallthrough */ \
> + case 2: \
> + ring[idx++] =3D obj[i++]; /* fallthrough */ \
> + case 1: \
> + ring[idx++] =3D obj[i++]; /* fallthrough */ \
> + } \
> + } else { \
> + for (i =3D 0; idx < size; i++, idx++)\
> + ring[idx] =3D obj[i]; \
> + for (idx =3D 0; i < n; i++, idx++) \
> + ring[idx] =3D obj[i]; \
> + } \
> +} while (0)
> +
> +#define ENQUEUE_PTRS_64(r, ring_start, prod_head, obj_table, n) do { \
> + unsigned int i; \
> + const uint32_t size =3D (r)->size; \
> + uint32_t idx =3D prod_head & (r)->mask; \
> + uint64_t *ring =3D (uint64_t *)ring_start; \
> + uint64_t *obj =3D (uint64_t *)obj_table; \
> + if (likely(idx + n < size)) { \
> + for (i =3D 0; i < (n & ((~(unsigned)0x3))); i +=3D 4, idx +=3D 4) { \
> + ring[idx] =3D obj[i]; \
> + ring[idx + 1] =3D obj[i + 1]; \
> + ring[idx + 2] =3D obj[i + 2]; \
> + ring[idx + 3] =3D obj[i + 3]; \
> + } \
> + switch (n & 0x3) { \
> + case 3: \
> + ring[idx++] =3D obj[i++]; /* fallthrough */ \
> + case 2: \
> + ring[idx++] =3D obj[i++]; /* fallthrough */ \
> + case 1: \
> + ring[idx++] =3D obj[i++]; \
> + } \
> + } else { \
> + for (i =3D 0; idx < size; i++, idx++)\
> + ring[idx] =3D obj[i]; \
> + for (idx =3D 0; i < n; i++, idx++) \
> + ring[idx] =3D obj[i]; \
> + } \
> +} while (0)
> +
> +#define ENQUEUE_PTRS_128(r, ring_start, prod_head, obj_table, n) do { \
> + unsigned int i; \
> + const uint32_t size =3D (r)->size; \
> + uint32_t idx =3D prod_head & (r)->mask; \
> + __uint128_t *ring =3D (__uint128_t *)ring_start; \
> + __uint128_t *obj =3D (__uint128_t *)obj_table; \
> + if (likely(idx + n < size)) { \
> + for (i =3D 0; i < (n >> 1); i +=3D 2, idx +=3D 2) { \
> + ring[idx] =3D obj[i]; \
> + ring[idx + 1] =3D obj[i + 1]; \
> + } \
> + switch (n & 0x1) { \
> + case 1: \
> + ring[idx++] =3D obj[i++]; \
> + } \
> + } else { \
> + for (i =3D 0; idx < size; i++, idx++)\
> + ring[idx] =3D obj[i]; \
> + for (idx =3D 0; i < n; i++, idx++) \
> + ring[idx] =3D obj[i]; \
> + } \
> +} while (0)
> +
> +/* the actual copy of pointers on the ring to obj_table.
> + * Placed here since identical code needed in both
> + * single and multi consumer dequeue functions.
> + */
> +#define DEQUEUE_PTRS_ELEM(r, ring_start, cons_head, obj_table, esize, n)
> do { \
> + if (esize =3D=3D 4) \
> + DEQUEUE_PTRS_32(r, ring_start, cons_head, obj_table, n); \
> + else if (esize =3D=3D 8) \
> + DEQUEUE_PTRS_64(r, ring_start, cons_head, obj_table, n); \
> + else if (esize =3D=3D 16) \
> + DEQUEUE_PTRS_128(r, ring_start, cons_head, obj_table, n); \ }
> while
> +(0)
> +
> +#define DEQUEUE_PTRS_32(r, ring_start, cons_head, obj_table, n) do { \
> + unsigned int i; \
> + uint32_t idx =3D cons_head & (r)->mask; \
> + const uint32_t size =3D (r)->size; \
> + uint32_t *ring =3D (uint32_t *)ring_start; \
> + uint32_t *obj =3D (uint32_t *)obj_table; \
> + if (likely(idx + n < size)) { \
> + for (i =3D 0; i < (n & (~(unsigned)0x7)); i +=3D 8, idx +=3D 8) {\
> + obj[i] =3D ring[idx]; \
> + obj[i + 1] =3D ring[idx + 1]; \
> + obj[i + 2] =3D ring[idx + 2]; \
> + obj[i + 3] =3D ring[idx + 3]; \
> + obj[i + 4] =3D ring[idx + 4]; \
> + obj[i + 5] =3D ring[idx + 5]; \
> + obj[i + 6] =3D ring[idx + 6]; \
> + obj[i + 7] =3D ring[idx + 7]; \
> + } \
> + switch (n & 0x7) { \
> + case 7: \
> + obj[i++] =3D ring[idx++]; /* fallthrough */ \
> + case 6: \
> + obj[i++] =3D ring[idx++]; /* fallthrough */ \
> + case 5: \
> + obj[i++] =3D ring[idx++]; /* fallthrough */ \
> + case 4: \
> + obj[i++] =3D ring[idx++]; /* fallthrough */ \
> + case 3: \
> + obj[i++] =3D ring[idx++]; /* fallthrough */ \
> + case 2: \
> + obj[i++] =3D ring[idx++]; /* fallthrough */ \
> + case 1: \
> + obj[i++] =3D ring[idx++]; /* fallthrough */ \
> + } \
> + } else { \
> + for (i =3D 0; idx < size; i++, idx++) \
> + obj[i] =3D ring[idx]; \
> + for (idx =3D 0; i < n; i++, idx++) \
> + obj[i] =3D ring[idx]; \
> + } \
> +} while (0)
> +
> +#define DEQUEUE_PTRS_64(r, ring_start, cons_head, obj_table, n) do { \
> + unsigned int i; \
> + uint32_t idx =3D cons_head & (r)->mask; \
> + const uint32_t size =3D (r)->size; \
> + uint64_t *ring =3D (uint64_t *)ring_start; \
> + uint64_t *obj =3D (uint64_t *)obj_table; \
> + if (likely(idx + n < size)) { \
> + for (i =3D 0; i < (n & (~(unsigned)0x3)); i +=3D 4, idx +=3D 4) {\
> + obj[i] =3D ring[idx]; \
> + obj[i + 1] =3D ring[idx + 1]; \
> + obj[i + 2] =3D ring[idx + 2]; \
> + obj[i + 3] =3D ring[idx + 3]; \
> + } \
> + switch (n & 0x3) { \
> + case 3: \
> + obj[i++] =3D ring[idx++]; /* fallthrough */ \
> + case 2: \
> + obj[i++] =3D ring[idx++]; /* fallthrough */ \
> + case 1: \
> + obj[i++] =3D ring[idx++]; \
> + } \
> + } else { \
> + for (i =3D 0; idx < size; i++, idx++) \
> + obj[i] =3D ring[idx]; \
> + for (idx =3D 0; i < n; i++, idx++) \
> + obj[i] =3D ring[idx]; \
> + } \
> +} while (0)
> +
> +#define DEQUEUE_PTRS_128(r, ring_start, cons_head, obj_table, n) do { \
> + unsigned int i; \
> + uint32_t idx =3D cons_head & (r)->mask; \
> + const uint32_t size =3D (r)->size; \
> + __uint128_t *ring =3D (__uint128_t *)ring_start; \
> + __uint128_t *obj =3D (__uint128_t *)obj_table; \
> + if (likely(idx + n < size)) { \
> + for (i =3D 0; i < (n >> 1); i +=3D 2, idx +=3D 2) { \
> + obj[i] =3D ring[idx]; \
> + obj[i + 1] =3D ring[idx + 1]; \
> + } \
> + switch (n & 0x1) { \
> + case 1: \
> + obj[i++] =3D ring[idx++]; /* fallthrough */ \
> + } \
> + } else { \
> + for (i =3D 0; idx < size; i++, idx++) \
> + obj[i] =3D ring[idx]; \
> + for (idx =3D 0; i < n; i++, idx++) \
> + obj[i] =3D ring[idx]; \
> + } \
> +} while (0)
> +
> +/* Between load and load. there might be cpu reorder in weak model
> + * (powerpc/arm).
> + * There are 2 choices for the users
> + * 1.use rmb() memory barrier
> + * 2.use one-direction load_acquire/store_release barrier,defined by
> + * CONFIG_RTE_USE_C11_MEM_MODEL=3Dy
> + * It depends on performance test results.
> + * By default, move common functions to rte_ring_generic.h */ #ifdef
> +RTE_USE_C11_MEM_MODEL #include "rte_ring_c11_mem.h"
> +#else
> +#include "rte_ring_generic.h"
> +#endif
> +
> +/**
> + * @internal Enqueue several objects on the ring
> + *
> + * @param r
> + * A pointer to the ring structure.
> + * @param obj_table
> + * A pointer to a table of void * pointers (objects).
> + * @param esize
> + * The size of ring element, in bytes. It must be a multiple of 4.
> + * Currently, sizes 4, 8 and 16 are supported. This should be the same
> + * as passed while creating the ring, otherwise the results are undefi=
ned.
> + * @param n
> + * The number of objects to add in the ring from the obj_table.
> + * @param behavior
> + * RTE_RING_QUEUE_FIXED: Enqueue a fixed number of items from a rin=
g
> + * RTE_RING_QUEUE_VARIABLE: Enqueue as many items as possible from
> ring
> + * @param is_sp
> + * Indicates whether to use single producer or multi-producer head upd=
ate
> + * @param free_space
> + * returns the amount of space after the enqueue operation has finishe=
d
> + * @return
> + * Actual number of objects enqueued.
> + * If behavior =3D=3D RTE_RING_QUEUE_FIXED, this will be 0 or n only.
> + */
> +static __rte_always_inline unsigned int
> +__rte_ring_do_enqueue_elem(struct rte_ring *r, void * const obj_table,
> + unsigned int esize, unsigned int n,
> + enum rte_ring_queue_behavior behavior, unsigned int is_sp,
> + unsigned int *free_space)
> +{
> + uint32_t prod_head, prod_next;
> + uint32_t free_entries;
> +
> + n =3D __rte_ring_move_prod_head(r, is_sp, n, behavior,
> + &prod_head, &prod_next, &free_entries);
> + if (n =3D=3D 0)
> + goto end;
> +
> + ENQUEUE_PTRS_ELEM(r, &r[1], prod_head, obj_table, esize, n);
> +
> + update_tail(&r->prod, prod_head, prod_next, is_sp, 1);
> +end:
> + if (free_space !=3D NULL)
> + *free_space =3D free_entries - n;
> + return n;
> +}
> +
> +/**
> + * @internal Dequeue several objects from the ring
> + *
> + * @param r
> + * A pointer to the ring structure.
> + * @param obj_table
> + * A pointer to a table of void * pointers (objects).
> + * @param esize
> + * The size of ring element, in bytes. It must be a multiple of 4.
> + * Currently, sizes 4, 8 and 16 are supported. This should be the same
> + * as passed while creating the ring, otherwise the results are undefi=
ned.
> + * @param n
> + * The number of objects to pull from the ring.
> + * @param behavior
> + * RTE_RING_QUEUE_FIXED: Dequeue a fixed number of items from a rin=
g
> + * RTE_RING_QUEUE_VARIABLE: Dequeue as many items as possible from
> ring
> + * @param is_sc
> + * Indicates whether to use single consumer or multi-consumer head upd=
ate
> + * @param available
> + * returns the number of remaining ring entries after the dequeue has
> finished
> + * @return
> + * - Actual number of objects dequeued.
> + * If behavior =3D=3D RTE_RING_QUEUE_FIXED, this will be 0 or n only=
.
> + */
> +static __rte_always_inline unsigned int
> +__rte_ring_do_dequeue_elem(struct rte_ring *r, void *obj_table,
> + unsigned int esize, unsigned int n,
> + enum rte_ring_queue_behavior behavior, unsigned int is_sc,
> + unsigned int *available)
> +{
> + uint32_t cons_head, cons_next;
> + uint32_t entries;
> +
> + n =3D __rte_ring_move_cons_head(r, (int)is_sc, n, behavior,
> + &cons_head, &cons_next, &entries);
> + if (n =3D=3D 0)
> + goto end;
> +
> + DEQUEUE_PTRS_ELEM(r, &r[1], cons_head, obj_table, esize, n);
> +
> + update_tail(&r->cons, cons_head, cons_next, is_sc, 0);
> +
> +end:
> + if (available !=3D NULL)
> + *available =3D entries - n;
> + return n;
> +}
> +
> +/**
> + * Enqueue several objects on the ring (multi-producers safe).
> + *
> + * This function uses a "compare and set" instruction to move the
> + * producer index atomically.
> + *
> + * @param r
> + * A pointer to the ring structure.
> + * @param obj_table
> + * A pointer to a table of void * pointers (objects).
> + * @param esize
> + * The size of ring element, in bytes. It must be a multiple of 4.
> + * Currently, sizes 4, 8 and 16 are supported. This should be the same
> + * as passed while creating the ring, otherwise the results are undefi=
ned.
> + * @param n
> + * The number of objects to add in the ring from the obj_table.
> + * @param free_space
> + * if non-NULL, returns the amount of space in the ring after the
> + * enqueue operation has finished.
> + * @return
> + * The number of objects enqueued, either 0 or n
> + */
> +static __rte_always_inline unsigned int
> +rte_ring_mp_enqueue_bulk_elem(struct rte_ring *r, void * const obj_table=
,
> + unsigned int esize, unsigned int n, unsigned int *free_space) {
> + return __rte_ring_do_enqueue_elem(r, obj_table, esize, n,
> + RTE_RING_QUEUE_FIXED, __IS_MP, free_space); }
> +
> +/**
> + * Enqueue several objects on a ring (NOT multi-producers safe).
> + *
> + * @param r
> + * A pointer to the ring structure.
> + * @param obj_table
> + * A pointer to a table of void * pointers (objects).
> + * @param esize
> + * The size of ring element, in bytes. It must be a multiple of 4.
> + * Currently, sizes 4, 8 and 16 are supported. This should be the same
> + * as passed while creating the ring, otherwise the results are undefi=
ned.
> + * @param n
> + * The number of objects to add in the ring from the obj_table.
> + * @param free_space
> + * if non-NULL, returns the amount of space in the ring after the
> + * enqueue operation has finished.
> + * @return
> + * The number of objects enqueued, either 0 or n
> + */
> +static __rte_always_inline unsigned int
> +rte_ring_sp_enqueue_bulk_elem(struct rte_ring *r, void * const obj_table=
,
> + unsigned int esize, unsigned int n, unsigned int *free_space) {
> + return __rte_ring_do_enqueue_elem(r, obj_table, esize, n,
> + RTE_RING_QUEUE_FIXED, __IS_SP, free_space); }
> +
> +/**
> + * Enqueue several objects on a ring.
> + *
> + * This function calls the multi-producer or the single-producer
> + * version depending on the default behavior that was specified at
> + * ring creation time (see flags).
> + *
> + * @param r
> + * A pointer to the ring structure.
> + * @param obj_table
> + * A pointer to a table of void * pointers (objects).
> + * @param esize
> + * The size of ring element, in bytes. It must be a multiple of 4.
> + * Currently, sizes 4, 8 and 16 are supported. This should be the same
> + * as passed while creating the ring, otherwise the results are undefi=
ned.
> + * @param n
> + * The number of objects to add in the ring from the obj_table.
> + * @param free_space
> + * if non-NULL, returns the amount of space in the ring after the
> + * enqueue operation has finished.
> + * @return
> + * The number of objects enqueued, either 0 or n
> + */
> +static __rte_always_inline unsigned int
> +rte_ring_enqueue_bulk_elem(struct rte_ring *r, void * const obj_table,
> + unsigned int esize, unsigned int n, unsigned int *free_space) {
> + return __rte_ring_do_enqueue_elem(r, obj_table, esize, n,
> + RTE_RING_QUEUE_FIXED, r->prod.single, free_space); }
> +
> +/**
> + * Enqueue one object on a ring (multi-producers safe).
> + *
> + * This function uses a "compare and set" instruction to move the
> + * producer index atomically.
> + *
> + * @param r
> + * A pointer to the ring structure.
> + * @param obj
> + * A pointer to the object to be added.
> + * @param esize
> + * The size of ring element, in bytes. It must be a multiple of 4.
> + * Currently, sizes 4, 8 and 16 are supported. This should be the same
> + * as passed while creating the ring, otherwise the results are undefi=
ned.
> + * @return
> + * - 0: Success; objects enqueued.
> + * - -ENOBUFS: Not enough room in the ring to enqueue; no object is
> enqueued.
> + */
> +static __rte_always_inline int
> +rte_ring_mp_enqueue_elem(struct rte_ring *r, void *obj, unsigned int
> +esize) {
> + return rte_ring_mp_enqueue_bulk_elem(r, obj, esize, 1, NULL) ? 0 :
> + -ENOBUFS;
> +}
> +
> +/**
> + * Enqueue one object on a ring (NOT multi-producers safe).
> + *
> + * @param r
> + * A pointer to the ring structure.
> + * @param obj
> + * A pointer to the object to be added.
> + * @param esize
> + * The size of ring element, in bytes. It must be a multiple of 4.
> + * Currently, sizes 4, 8 and 16 are supported. This should be the same
> + * as passed while creating the ring, otherwise the results are undefi=
ned.
> + * @return
> + * - 0: Success; objects enqueued.
> + * - -ENOBUFS: Not enough room in the ring to enqueue; no object is
> enqueued.
> + */
> +static __rte_always_inline int
> +rte_ring_sp_enqueue_elem(struct rte_ring *r, void *obj, unsigned int
> +esize) {
> + return rte_ring_sp_enqueue_bulk_elem(r, obj, esize, 1, NULL) ? 0 :
> + -ENOBUFS;
> +}
> +
> +/**
> + * Enqueue one object on a ring.
> + *
> + * This function calls the multi-producer or the single-producer
> + * version, depending on the default behaviour that was specified at
> + * ring creation time (see flags).
> + *
> + * @param r
> + * A pointer to the ring structure.
> + * @param obj
> + * A pointer to the object to be added.
> + * @param esize
> + * The size of ring element, in bytes. It must be a multiple of 4.
> + * Currently, sizes 4, 8 and 16 are supported. This should be the same
> + * as passed while creating the ring, otherwise the results are undefi=
ned.
> + * @return
> + * - 0: Success; objects enqueued.
> + * - -ENOBUFS: Not enough room in the ring to enqueue; no object is
> enqueued.
> + */
> +static __rte_always_inline int
> +rte_ring_enqueue_elem(struct rte_ring *r, void *obj, unsigned int
> +esize) {
> + return rte_ring_enqueue_bulk_elem(r, obj, esize, 1, NULL) ? 0 :
> + -ENOBUFS;
> +}
> +
> +/**
> + * Dequeue several objects from a ring (multi-consumers safe).
> + *
> + * This function uses a "compare and set" instruction to move the
> + * consumer index atomically.
> + *
> + * @param r
> + * A pointer to the ring structure.
> + * @param obj_table
> + * A pointer to a table of void * pointers (objects) that will be fill=
ed.
> + * @param esize
> + * The size of ring element, in bytes. It must be a multiple of 4.
> + * Currently, sizes 4, 8 and 16 are supported. This should be the same
> + * as passed while creating the ring, otherwise the results are undefi=
ned.
> + * @param n
> + * The number of objects to dequeue from the ring to the obj_table.
> + * @param available
> + * If non-NULL, returns the number of remaining ring entries after the
> + * dequeue has finished.
> + * @return
> + * The number of objects dequeued, either 0 or n
> + */
> +static __rte_always_inline unsigned int
> +rte_ring_mc_dequeue_bulk_elem(struct rte_ring *r, void *obj_table,
> + unsigned int esize, unsigned int n, unsigned int *available) {
> + return __rte_ring_do_dequeue_elem(r, obj_table, esize, n,
> + RTE_RING_QUEUE_FIXED, __IS_MC,
> available); }
> +
> +/**
> + * Dequeue several objects from a ring (NOT multi-consumers safe).
> + *
> + * @param r
> + * A pointer to the ring structure.
> + * @param obj_table
> + * A pointer to a table of void * pointers (objects) that will be fill=
ed.
> + * @param esize
> + * The size of ring element, in bytes. It must be a multiple of 4.
> + * Currently, sizes 4, 8 and 16 are supported. This should be the same
> + * as passed while creating the ring, otherwise the results are undefi=
ned.
> + * @param n
> + * The number of objects to dequeue from the ring to the obj_table,
> + * must be strictly positive.
> + * @param available
> + * If non-NULL, returns the number of remaining ring entries after the
> + * dequeue has finished.
> + * @return
> + * The number of objects dequeued, either 0 or n
> + */
> +static __rte_always_inline unsigned int
> +rte_ring_sc_dequeue_bulk_elem(struct rte_ring *r, void *obj_table,
> + unsigned int esize, unsigned int n, unsigned int *available) {
> + return __rte_ring_do_dequeue_elem(r, obj_table, esize, n,
> + RTE_RING_QUEUE_FIXED, __IS_SC, available); }
> +
> +/**
> + * Dequeue several objects from a ring.
> + *
> + * This function calls the multi-consumers or the single-consumer
> + * version, depending on the default behaviour that was specified at
> + * ring creation time (see flags).
> + *
> + * @param r
> + * A pointer to the ring structure.
> + * @param obj_table
> + * A pointer to a table of void * pointers (objects) that will be fill=
ed.
> + * @param esize
> + * The size of ring element, in bytes. It must be a multiple of 4.
> + * Currently, sizes 4, 8 and 16 are supported. This should be the same
> + * as passed while creating the ring, otherwise the results are undefi=
ned.
> + * @param n
> + * The number of objects to dequeue from the ring to the obj_table.
> + * @param available
> + * If non-NULL, returns the number of remaining ring entries after the
> + * dequeue has finished.
> + * @return
> + * The number of objects dequeued, either 0 or n
> + */
> +static __rte_always_inline unsigned int
> +rte_ring_dequeue_bulk_elem(struct rte_ring *r, void *obj_table,
> + unsigned int esize, unsigned int n, unsigned int *available) {
> + return __rte_ring_do_dequeue_elem(r, obj_table, esize, n,
> + RTE_RING_QUEUE_FIXED, r->cons.single, available); }
> +
> +/**
> + * Dequeue one object from a ring (multi-consumers safe).
> + *
> + * This function uses a "compare and set" instruction to move the
> + * consumer index atomically.
> + *
> + * @param r
> + * A pointer to the ring structure.
> + * @param obj_p
> + * A pointer to a void * pointer (object) that will be filled.
> + * @param esize
> + * The size of ring element, in bytes. It must be a multiple of 4.
> + * Currently, sizes 4, 8 and 16 are supported. This should be the same
> + * as passed while creating the ring, otherwise the results are undefi=
ned.
> + * @return
> + * - 0: Success; objects dequeued.
> + * - -ENOENT: Not enough entries in the ring to dequeue; no object is
> + * dequeued.
> + */
> +static __rte_always_inline int
> +rte_ring_mc_dequeue_elem(struct rte_ring *r, void *obj_p,
> + unsigned int esize)
> +{
> + return rte_ring_mc_dequeue_bulk_elem(r, obj_p, esize, 1, NULL) ? 0 :
> + -ENOENT;
> +}
> +
> +/**
> + * Dequeue one object from a ring (NOT multi-consumers safe).
> + *
> + * @param r
> + * A pointer to the ring structure.
> + * @param obj_p
> + * A pointer to a void * pointer (object) that will be filled.
> + * @param esize
> + * The size of ring element, in bytes. It must be a multiple of 4.
> + * Currently, sizes 4, 8 and 16 are supported. This should be the same
> + * as passed while creating the ring, otherwise the results are undefi=
ned.
> + * @return
> + * - 0: Success; objects dequeued.
> + * - -ENOENT: Not enough entries in the ring to dequeue, no object is
> + * dequeued.
> + */
> +static __rte_always_inline int
> +rte_ring_sc_dequeue_elem(struct rte_ring *r, void *obj_p,
> + unsigned int esize)
> +{
> + return rte_ring_sc_dequeue_bulk_elem(r, obj_p, esize, 1, NULL) ? 0 :
> + -ENOENT;
> +}
> +
> +/**
> + * Dequeue one object from a ring.
> + *
> + * This function calls the multi-consumers or the single-consumer
> + * version depending on the default behaviour that was specified at
> + * ring creation time (see flags).
> + *
> + * @param r
> + * A pointer to the ring structure.
> + * @param obj_p
> + * A pointer to a void * pointer (object) that will be filled.
> + * @param esize
> + * The size of ring element, in bytes. It must be a multiple of 4.
> + * Currently, sizes 4, 8 and 16 are supported. This should be the same
> + * as passed while creating the ring, otherwise the results are undefi=
ned.
> + * @return
> + * - 0: Success, objects dequeued.
> + * - -ENOENT: Not enough entries in the ring to dequeue, no object is
> + * dequeued.
> + */
> +static __rte_always_inline int
> +rte_ring_dequeue_elem(struct rte_ring *r, void *obj_p, unsigned int
> +esize) {
> + return rte_ring_dequeue_bulk_elem(r, obj_p, esize, 1, NULL) ? 0 :
> + -ENOENT;
> +}
> +
> +/**
> + * Enqueue several objects on the ring (multi-producers safe).
> + *
> + * This function uses a "compare and set" instruction to move the
> + * producer index atomically.
> + *
> + * @param r
> + * A pointer to the ring structure.
> + * @param obj_table
> + * A pointer to a table of void * pointers (objects).
> + * @param esize
> + * The size of ring element, in bytes. It must be a multiple of 4.
> + * Currently, sizes 4, 8 and 16 are supported. This should be the same
> + * as passed while creating the ring, otherwise the results are undefi=
ned.
> + * @param n
> + * The number of objects to add in the ring from the obj_table.
> + * @param free_space
> + * if non-NULL, returns the amount of space in the ring after the
> + * enqueue operation has finished.
> + * @return
> + * - n: Actual number of objects enqueued.
> + */
> +static __rte_always_inline unsigned
> +rte_ring_mp_enqueue_burst_elem(struct rte_ring *r, void * const obj_tabl=
e,
> + unsigned int esize, unsigned int n, unsigned int *free_space) {
> + return __rte_ring_do_enqueue_elem(r, obj_table, esize, n,
> + RTE_RING_QUEUE_VARIABLE, __IS_MP, free_space); }
> +
> +/**
> + * Enqueue several objects on a ring (NOT multi-producers safe).
> + *
> + * @param r
> + * A pointer to the ring structure.
> + * @param obj_table
> + * A pointer to a table of void * pointers (objects).
> + * @param esize
> + * The size of ring element, in bytes. It must be a multiple of 4.
> + * Currently, sizes 4, 8 and 16 are supported. This should be the same
> + * as passed while creating the ring, otherwise the results are undefi=
ned.
> + * @param n
> + * The number of objects to add in the ring from the obj_table.
> + * @param free_space
> + * if non-NULL, returns the amount of space in the ring after the
> + * enqueue operation has finished.
> + * @return
> + * - n: Actual number of objects enqueued.
> + */
> +static __rte_always_inline unsigned
> +rte_ring_sp_enqueue_burst_elem(struct rte_ring *r, void * const obj_tabl=
e,
> + unsigned int esize, unsigned int n, unsigned int *free_space) {
> + return __rte_ring_do_enqueue_elem(r, obj_table, esize, n,
> + RTE_RING_QUEUE_VARIABLE, __IS_SP, free_space); }
> +
> +/**
> + * Enqueue several objects on a ring.
> + *
> + * This function calls the multi-producer or the single-producer
> + * version depending on the default behavior that was specified at
> + * ring creation time (see flags).
> + *
> + * @param r
> + * A pointer to the ring structure.
> + * @param obj_table
> + * A pointer to a table of void * pointers (objects).
> + * @param esize
> + * The size of ring element, in bytes. It must be a multiple of 4.
> + * Currently, sizes 4, 8 and 16 are supported. This should be the same
> + * as passed while creating the ring, otherwise the results are undefi=
ned.
> + * @param n
> + * The number of objects to add in the ring from the obj_table.
> + * @param free_space
> + * if non-NULL, returns the amount of space in the ring after the
> + * enqueue operation has finished.
> + * @return
> + * - n: Actual number of objects enqueued.
> + */
> +static __rte_always_inline unsigned
> +rte_ring_enqueue_burst_elem(struct rte_ring *r, void * const obj_table,
> + unsigned int esize, unsigned int n, unsigned int *free_space) {
> + return __rte_ring_do_enqueue_elem(r, obj_table, esize, n,
> + RTE_RING_QUEUE_VARIABLE, r->prod.single,
> free_space); }
> +
> +/**
> + * Dequeue several objects from a ring (multi-consumers safe). When the
> +request
> + * objects are more than the available objects, only dequeue the actual
> +number
> + * of objects
> + *
> + * This function uses a "compare and set" instruction to move the
> + * consumer index atomically.
> + *
> + * @param r
> + * A pointer to the ring structure.
> + * @param obj_table
> + * A pointer to a table of void * pointers (objects) that will be fill=
ed.
> + * @param esize
> + * The size of ring element, in bytes. It must be a multiple of 4.
> + * Currently, sizes 4, 8 and 16 are supported. This should be the same
> + * as passed while creating the ring, otherwise the results are undefi=
ned.
> + * @param n
> + * The number of objects to dequeue from the ring to the obj_table.
> + * @param available
> + * If non-NULL, returns the number of remaining ring entries after the
> + * dequeue has finished.
> + * @return
> + * - n: Actual number of objects dequeued, 0 if ring is empty
> + */
> +static __rte_always_inline unsigned
> +rte_ring_mc_dequeue_burst_elem(struct rte_ring *r, void *obj_table,
> + unsigned int esize, unsigned int n, unsigned int *available) {
> + return __rte_ring_do_dequeue_elem(r, obj_table, esize, n,
> + RTE_RING_QUEUE_VARIABLE, __IS_MC, available); }
> +
> +/**
> + * Dequeue several objects from a ring (NOT multi-consumers safe).When
> +the
> + * request objects are more than the available objects, only dequeue
> +the
> + * actual number of objects
> + *
> + * @param r
> + * A pointer to the ring structure.
> + * @param obj_table
> + * A pointer to a table of void * pointers (objects) that will be fill=
ed.
> + * @param esize
> + * The size of ring element, in bytes. It must be a multiple of 4.
> + * Currently, sizes 4, 8 and 16 are supported. This should be the same
> + * as passed while creating the ring, otherwise the results are undefi=
ned.
> + * @param n
> + * The number of objects to dequeue from the ring to the obj_table.
> + * @param available
> + * If non-NULL, returns the number of remaining ring entries after the
> + * dequeue has finished.
> + * @return
> + * - n: Actual number of objects dequeued, 0 if ring is empty
> + */
> +static __rte_always_inline unsigned
> +rte_ring_sc_dequeue_burst_elem(struct rte_ring *r, void *obj_table,
> + unsigned int esize, unsigned int n, unsigned int *available) {
> + return __rte_ring_do_dequeue_elem(r, obj_table, esize, n,
> + RTE_RING_QUEUE_VARIABLE, __IS_SC, available); }
> +
> +/**
> + * Dequeue multiple objects from a ring up to a maximum number.
> + *
> + * This function calls the multi-consumers or the single-consumer
> + * version, depending on the default behaviour that was specified at
> + * ring creation time (see flags).
> + *
> + * @param r
> + * A pointer to the ring structure.
> + * @param obj_table
> + * A pointer to a table of void * pointers (objects) that will be fill=
ed.
> + * @param esize
> + * The size of ring element, in bytes. It must be a multiple of 4.
> + * Currently, sizes 4, 8 and 16 are supported. This should be the same
> + * as passed while creating the ring, otherwise the results are undefi=
ned.
> + * @param n
> + * The number of objects to dequeue from the ring to the obj_table.
> + * @param available
> + * If non-NULL, returns the number of remaining ring entries after the
> + * dequeue has finished.
> + * @return
> + * - Number of objects dequeued
> + */
> +static __rte_always_inline unsigned
> +rte_ring_dequeue_burst_elem(struct rte_ring *r, void *obj_table,
> + unsigned int esize, unsigned int n, unsigned int *available) {
> + return __rte_ring_do_dequeue_elem(r, obj_table, esize, n,
> + RTE_RING_QUEUE_VARIABLE,
> + r->cons.single, available);
> +}
> +
> +#ifdef __cplusplus
> +}
> +#endif
> +
> +#endif /* _RTE_RING_ELEM_H_ */
> diff --git a/lib/librte_ring/rte_ring_version.map
> b/lib/librte_ring/rte_ring_version.map
> index 510c1386e..e410a7503 100644
> --- a/lib/librte_ring/rte_ring_version.map
> +++ b/lib/librte_ring/rte_ring_version.map
> @@ -21,6 +21,8 @@ DPDK_2.2 {
> EXPERIMENTAL {
> global:
>=20
> + rte_ring_create_elem;
> + rte_ring_get_memsize_elem;
> rte_ring_reset;
>=20
> };
> --
> 2.17.1