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 73AC1A00C5;
Fri, 8 May 2020 12:04:41 +0200 (CEST)
Received: from [92.243.14.124] (localhost [127.0.0.1])
by dpdk.org (Postfix) with ESMTP id F0EEB1DAAC;
Fri, 8 May 2020 12:04:40 +0200 (CEST)
Received: from mga05.intel.com (mga05.intel.com [192.55.52.43])
by dpdk.org (Postfix) with ESMTP id EE1AD1DAAB
for <dev@dpdk.org>; Fri, 8 May 2020 12:04:38 +0200 (CEST)
IronPort-SDR: g9c6SM+vXU2JnuIwZGmGpsE9Q3Hj/qnCcn9ssJ7FuwUwhWrUPEfIcYeDDunpe0TbHJf5+kzgrb
vCeDh1VBM87g==
X-Amp-Result: SKIPPED(no attachment in message)
X-Amp-File-Uploaded: False
Received: from fmsmga002.fm.intel.com ([10.253.24.26])
by fmsmga105.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384;
08 May 2020 03:04:38 -0700
IronPort-SDR: qOLHTxYqKwBHZsPM7khkqPG7autE4lWRhPJWZcosxz7uzSpklSvHbMyTJN32LIkX0R3kJ0Y7BQ
muNnzXTXx+tw==
X-ExtLoop1: 1
X-IronPort-AV: E=Sophos;i="5.73,367,1583222400"; d="scan'208";a="296032407"
Received: from fmsmsx107.amr.corp.intel.com ([10.18.124.205])
by fmsmga002.fm.intel.com with ESMTP; 08 May 2020 03:04:38 -0700
Received: from FMSEDG002.ED.cps.intel.com (10.1.192.134) by
fmsmsx107.amr.corp.intel.com (10.18.124.205) with Microsoft SMTP Server (TLS)
id 14.3.439.0; Fri, 8 May 2020 03:04:38 -0700
Received: from NAM11-CO1-obe.outbound.protection.outlook.com (104.47.56.172)
by edgegateway.intel.com (192.55.55.69) with Microsoft SMTP Server (TLS) id
14.3.439.0; Fri, 8 May 2020 03:04:38 -0700
ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none;
b=Ifkx3/AvxoujOdaexllX94UxR2CP2YGJ3ezxD/XAFKFzvj6vlCkhCPUxJAT1inrxKOZPfx2zbrF7Tn9GAC/R0CR46hiK8BEef5SASdnMmyv7T1eThN7uspliYTMiOCxa631yaaXD0xzAF5DTWMIDOb59Mc4jaFr2sfyyOM9d87N3zoZPvV+ua/DwNqD8lP+cdS7gTVZySND5nYZSnB3PEQWJ2xhtaF9ts+WWera8bN3Ekx7v+y+k1w5X1kglRm1BcNrPass1w/ZQF5WnSjpxjob2iAVq4c+cAtXCg8Jtlu99QQIk/mhbkZH8UcY/mtHefL+mfMFdY6lA7pvcvGaE6Q==
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=c1IAt50Dn0V7c6oxsCgizY+AuoZ4h9D2SYyCNT68Dgg=;
b=SE4pFcgbqKh85hXnE50UVoA1XOPZVmr1Pkbf/Y5jh5pljZMGtUANLmBo/OV7xddh3hDOHF70IJ26NOrNekvEQxnDtwzFM8LtDJ0EeIprrokmS6H6fvbFsfB3qKREdug+SG9ztc5tep0jujOLFiFw7H6hYIamMQMq44+tkTwHz1Hvo5WYbpQVXRrzR3OxTdPfsm58Oae48oZmE2zwuLer+BerGziP19uIuCe9oi9rZD4b5I6+GAyq//3dMuRiXp8p+wzBcfmLzlzb9GxhEaqYWxbCgsXCc8hsvlVpI/CLBdgxZG2IJhP/DaFZ/r73DA4wZUyeUaJ7XwWpbRwrqpzd3g==
ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass
smtp.mailfrom=intel.com; dmarc=pass action=none header.from=intel.com;
dkim=pass header.d=intel.com; arc=none
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=intel.onmicrosoft.com;
s=selector2-intel-onmicrosoft-com;
h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck;
bh=c1IAt50Dn0V7c6oxsCgizY+AuoZ4h9D2SYyCNT68Dgg=;
b=IsKb4mx2gImddlRNqUjUPg5JMETuw+ssRSBtoTQT5gUydwzrg3WiEnA3RDe3LsWgRpCi8wgA6smK3A0r9R5wxfkBCZ30RZ5tdOZbNtJiO/ZX4qWCB+clT6Jov8cskTZT30MHZbCdtG0w/nwd7e0FmlLP3A8P1xyFgrjsPYndVrM=
Received: from BYAPR11MB3301.namprd11.prod.outlook.com (2603:10b6:a03:7f::26)
by BYAPR11MB2888.namprd11.prod.outlook.com (2603:10b6:a03:8c::19)
with Microsoft SMTP Server (version=TLS1_2,
cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.2958.29; Fri, 8 May
2020 10:04:36 +0000
Received: from BYAPR11MB3301.namprd11.prod.outlook.com
([fe80::f8cb:58cd:e958:fff4]) by BYAPR11MB3301.namprd11.prod.outlook.com
([fe80::f8cb:58cd:e958:fff4%6]) with mapi id 15.20.2958.035; Fri, 8 May 2020
10:04:36 +0000
From: "Ananyev, Konstantin" <konstantin.ananyev@intel.com>
To: Honnappa Nagarahalli <Honnappa.Nagarahalli@arm.com>, "dev@dpdk.org"
<dev@dpdk.org>
CC: "aconole@redhat.com" <aconole@redhat.com>, nd <nd@arm.com>, nd <nd@arm.com>
Thread-Topic: [PATCH] test/ring: code rework to reduce compilation time
Thread-Index: AQHWHk+83qvZh/D4lkSDqayxys8lo6iQ6NuAgAC+FfCAAd3OAIAF4jmwgAAsKwCAAAFFAIAAQNgAgAAJKZCAA9kSgIAAR/AA
Date: Fri, 8 May 2020 10:04:36 +0000
Message-ID: <BYAPR11MB33011D03356D52F31BE7A33F9AA20@BYAPR11MB3301.namprd11.prod.outlook.com>
References: <20200429175714.31141-1-konstantin.ananyev@intel.com>
<DBBPR08MB4646949FAFC2EAC67AF98EF398AA0@DBBPR08MB4646.eurprd08.prod.outlook.com>
<BYAPR11MB33012D89AC7524B941AB15E19AAA0@BYAPR11MB3301.namprd11.prod.outlook.com>
<DBBPR08MB4646E5CEC63BBB6BFCDF795898AB0@DBBPR08MB4646.eurprd08.prod.outlook.com>
<BYAPR11MB330166F6C08EB86C212FB9059AA70@BYAPR11MB3301.namprd11.prod.outlook.com>
<DBBPR08MB4646C7AE79054DF2F95CE16F98A70@DBBPR08MB4646.eurprd08.prod.outlook.com>
<BYAPR11MB33014E6B0F9368E341A705809AA70@BYAPR11MB3301.namprd11.prod.outlook.com>
<AM6PR08MB4644A00CAD759FBFBCA65A3898A70@AM6PR08MB4644.eurprd08.prod.outlook.com>
<BYAPR11MB3301F125B93267EE36FBA6D79AA70@BYAPR11MB3301.namprd11.prod.outlook.com>
<DBBPR08MB4646A2911C2A1BD37ACEE59798A20@DBBPR08MB4646.eurprd08.prod.outlook.com>
In-Reply-To: <DBBPR08MB4646A2911C2A1BD37ACEE59798A20@DBBPR08MB4646.eurprd08.prod.outlook.com>
Accept-Language: en-GB, en-US
Content-Language: en-US
X-MS-Has-Attach:
X-MS-TNEF-Correlator:
dlp-product: dlpe-windows
dlp-reaction: no-action
dlp-version: 11.2.0.6
authentication-results: arm.com; dkim=none (message not signed)
header.d=none;arm.com; dmarc=none action=none header.from=intel.com;
x-originating-ip: [192.198.151.175]
x-ms-publictraffictype: Email
x-ms-office365-filtering-correlation-id: 7cc45326-095e-4067-b565-08d7f33736be
x-ms-traffictypediagnostic: BYAPR11MB2888:
x-microsoft-antispam-prvs: <BYAPR11MB288852CFF5E800F09F02D96E9AA20@BYAPR11MB2888.namprd11.prod.outlook.com>
x-ms-oob-tlc-oobclassifiers: OLM:9508;
x-forefront-prvs: 039735BC4E
x-ms-exchange-senderadcheck: 1
x-microsoft-antispam: BCL:0;
x-microsoft-antispam-message-info: aHveLwGXxrjrMAnVEXkx3ogtzd9HZNcgY7SoqknIYiTE4sKSv7S28F9G9e2Bc6xExD8lf8W2AYBuXc/ztXZaWCE/B7wBa3jWl1zAEMw5AnQMw8y9JnueHRjn2c6V87HmAsvUY6xNBUOBWA/vaESrHIFQjYzxOuMk0+SbX8UvZF/2vJIo1Mk1QGvZLrtvJnaG89mKqNG4kzhI5qgIDzS0wOuSQsvUDmafu4Gac2FegKfoxXqqs46nzQ26bf8Hq/6dwNMsy7SrhuSLEhsdSrUFG0wo7ymxrBo6SjxwKJVNHtyx7kdlsFQlcBz1ROcip+lc/NwjRHLkyjgQFIVvgkjn9XgtmVvhYK7tqk4ioNGOA81f/r8uYbJzpXSchxQaT41wDWyVhMle1jYii+MaRvVZ6l9URl6peG4vElRPAo8KmT+zGYiv2joASTaeadAYF+Nk8xP+IFtK4I+IXA/pIveQ/4KZEIn/lqYui3lL/8TtzNkY1pRBefsgmT0oVSTZvq9wxid509aQwxsNIkhSDxeiFe1oUIkBXI9sRypshoOT9RzPa41DIl3W0cPzswAuhpHo1UJWHMma2knRtQh0c7qwHfCy/t9qj7MTEMxCQuY8U2lZ+fAsH1WxIAvP2m0YVLNu
x-forefront-antispam-report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:;
IPV:NLI; SFV:NSPM; H:BYAPR11MB3301.namprd11.prod.outlook.com; PTR:; CAT:NONE;
SFTY:;
SFS:(346002)(376002)(366004)(396003)(39860400002)(136003)(33430700001)(66946007)(8936002)(66476007)(66446008)(64756008)(55016002)(2906002)(6506007)(4326008)(86362001)(30864003)(52536014)(186003)(8676002)(26005)(76116006)(478600001)(71200400001)(66556008)(9686003)(966005)(5660300002)(33656002)(83320400001)(83290400001)(83280400001)(83310400001)(7696005)(110136005)(54906003)(316002)(33440700001)(83300400001)(21314003)(559001)(579004);
DIR:OUT; SFP:1102;
x-ms-exchange-antispam-messagedata: QFIu9s3tBrSKm3qJwUZ2WmSJ40RulqpjVincR71VSk/X5+eTdOPoHPbNAJZrmnin+DhEfvYotu27A7+9aEv2UPS42G7xbpK6bZ1+dALCC/Z0wY3COQqlMIxW+Sez9k4BvAaCnR/zvNtorBUrkmfILSBAp2vKI26LzyKFQgbZ+7vv3p35U5V06QhBDzuDYE9Ln22o6e3FXsQ2Mgj/q1DViu5YLxZs1zqy2Spzq6a56jHzL2LzpX/3W3/w+mmYCHuQ6YCJ0pT5Lm4FS2HKFO/fGZLUYJgqwFqExwjvTlSSdUDGGaqQywHx2QTR9eQJlx0PrWzKxqV+3QMBjAEJaAYHP03qxOPzElMJC32+f/hQGUoiLvkip/IiYrdmgTmqxeJ+arOLEMjNyj1gQFoPqqEVLL2PyaA1NTzDs6drREatxKOUrg/jiqvTAyJ4Xt8NAdlQqkgVFmdiXaDmEu1xr2VR1VVqHkYCkIjYCi0AmOIKQQBbB5Ekjszm8heuPJAj0MEE
x-ms-exchange-transport-forked: True
Content-Type: text/plain; charset="us-ascii"
Content-Transfer-Encoding: quoted-printable
MIME-Version: 1.0
X-MS-Exchange-CrossTenant-Network-Message-Id: 7cc45326-095e-4067-b565-08d7f33736be
X-MS-Exchange-CrossTenant-originalarrivaltime: 08 May 2020 10:04:36.1304 (UTC)
X-MS-Exchange-CrossTenant-fromentityheader: Hosted
X-MS-Exchange-CrossTenant-id: 46c98d88-e344-4ed4-8496-4ed7712e255d
X-MS-Exchange-CrossTenant-mailboxtype: HOSTED
X-MS-Exchange-CrossTenant-userprincipalname: 1FoC3YtWpbLKpaT7Y2Ww3jvM38L4S7wBWk52Xn4CndiCTk8vZES1uPYTC5Sm+5gksrLkIWU6/WTe4uXffM65moGN+Je431OIxKUnyA5jjKQ=
X-MS-Exchange-Transport-CrossTenantHeadersStamped: BYAPR11MB2888
X-OriginatorOrg: intel.com
Subject: Re: [dpdk-dev] [PATCH] test/ring: code rework to reduce compilation
time
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>
> > > <snip>
> > >
> > > > > > > >
> > > > > > > > > Hi Konstantin,
> > > > > > > > > I like the way the tests are organized and it looks good=
.
> > > > > > > > >
> > > > > > > > > I am just wondering about the way it is being tested here=
.
> > > > > > > > > The intent to write the test cases the way they are
> > > > > > > > > currently is to mimic how the APIs would be used mostly.
> > > > > > > > > IMO, the APIs would be used with a constant
> > > > > > > > value for element size so that the compiler will throw away
> > > > > > > > the unwanted code (in the functions where the actual copy i=
s being
> > done).
> > > > > > > > >
> > > > > > > > > With your method here, it looks to me like all the
> > > > > > > > > branches in the copy
> > > > > > > > functions are kept and the branch decisions are done at run=
time.
> > > > > > > > > Is my understanding correct?
> > > > > > > >
> > > > > > > > You mean branching on esize[] values?
> > > > > > > Yes
> I was wondering where is the confusion. I interpreted as referring to the=
esize parameter in rte_ring_xxx_elem APIs. Anyway, please see
> below.
>=20
> > > > > > >
> > > > > > > > Actually from what I've seen that happens for both cases:
> > > > > > > > before and after the patch (gcc 7.3 -O3).
> > > > > > > I did not look at the generated code. If it is happening with
> > > > > > > your patch too, I
> > > > > > think we can go with your patch.
> > > > > >
> > > > > > Just to clarify, what I meant:
> > > > > > For both binaries (without the patch and with the patch) inside
> > > > > > test_ring() I see runtime branches on esize value.
> > > > > > Literally the code that corresponds to:
> > > > > > if (esize =3D=3D 8) {...}
> > > > > > else if (esize =3D=3D 16) {...}
> > > > > > else {...}
> > > I am not concerned about the functions in test_ring.c.
> > >
> > > > > Do you see this in the actual ring library functions?
> > > >
> > > > Which ones? AFAIK all ring dequeue/enqueue functions are inline rig=
ht
> > now.
> > > Please see below.
> > >
> > > >
> > > > > I want to make sure that the library functions
> > > > > '__rte_ring_enqueue_elems' and '__rte_ring_dequeue_elems' are
> > optimized.
> > > Each enqueue/dequeue function ultimately calls these 2 functions.
> >
> > Yes, and then each instance of enqueue/dequeue functions that is used b=
y
> > upper layer would be in-lined.
> > So what upper layer function (library or app) you asked me to check?
> I am not bothered much about upper layer functions. I looked at the gener=
ate code for the function __rte_ring_enqueue_elems.
> Existing code has the if checks for 8 and 16.
> Your patch also has the checks.
> My patch does not have the checks as it passes the constants directly wit=
hout using esize[] array in functions test_ring_burst_bulk_tests4.
For test_burst_bulk_test[1-4] - yes, for other test functions it is still t=
here.
Though I don't think it is that important for functional test cases.
Anyway, I think we dragged away a bit in our discussion,
so with what patch should we go ahead?
My preference is 69559, as it compiles faster and doesn't reduce=20
test coverage, but I can live with both.
Konstantin
>=20
> >
> > > The compiler here should remove the 'if (esize =3D=3D 8) {...} else i=
f
> > > (esize =3D=3D
> > > 16) {...} else {...}' with just the required piece of code depending =
on the
> > 'esize'.
> > > If we can validate that for at least one ring library function used i=
n
> > > this patch, we should be good.
> > >
> > > > >
> > > > > >
> > > > > > Probably gcc wasn't able to remove it because we use esize[]
> > > > > > instead of hard- coded values, might be there is some other
> > > > > > reason, I don't know
> > > > for sure.
> > > > > > As it is a functional (not performance) test, I didn't dig furt=
her.
> > > > > The esize[] array is declared as a const. The compiler should be
> > > > > able to see
> > > > that it is a compile time constant.
> > > >
> > > > That was my expectation too, but that not what I am seeing.
> > > >
> > > > > >
> > > > > > > But, can you do similar
> > > > > > > change to test_ring_perf.c to keep it consistent?
> > > > > >
> > > > > > In principle it is doable, but needs extra care.
> > > > > > We need to make sure that compiler will be able to inline
> > > > > > functions via pointers.
> > > > > > AFAIK, gcc does that with -O3', but not with '-O2'.
> > > > > If the unwanted code is not removed during compilation, we will
> > > > > see it
> > > > affect the performance numbers.
> > > >
> > > > Exactly.
> > > > The last thing I want - someone who uses older version of compiler,
> > > > etc., will start to see lower performance numbers with that test.
> > > >
> > > > > > Don't know what the story with clang and different versions of
> > > > > > the
> > > > compiler.
> > > > > > Is there any real need for that?
> > > > > > On my box test_ring_perf.c compilation takes ~8s.
> > > > > > Konstantin
> > > > > >
> > > > > >
> > > > > > >
> > > > > > > >
> > > > > > > > Main intention in my changes was to avoid using
> > > > > > > > test_ring_enqueue/test_ring_dequeue,
> > > > > > > > as it seems too many branches here and it takes compiler a
> > > > > > > > lot of effort to resolve all of them at compile time.
> > > > > > > > So I replaced it with array of function pointers
> > > > > > > > (test_enqdeq_impl[]) and iterating over it.
> > > > > > > > That way compiler knows straightway which function to use.
> > > > > > > >
> > > > > > > > > Can you please check this?
> > > > > > > > > https://patches.dpdk.org/patch/69567/
> > > > > > > >
> > > > > > > > As I can see your approach reduces number of test-cases by =
factor
> > of 5:
> > > > > > > > now each of test_ring_burst_bulk_tests[1-4] is executed onl=
y
> > > > > > > > with just one esize value, correct?
> > > > > > > Yes, basically test_ring_burst_bulk_tests[1-4] were covering
> > > > > > > different scenarios with the same APIs. So, distributed the
> > > > > > > esize across different test
> > > > > > functions.
> > > > > > >
> > > > > > > > In term of compilation speed - it helps.
> > > > > > > > On my box with (gcc 7.3 -O3) compiling test_ring.c takes:
> > > > > > > > orig code: ~100s
> > > > > > > > with 69567 (your patch): < 20s
> > > > > > > > with 69559 (my patch): < 10s
> > > > > > > >
> > > > > > > > Konstantin
> > > > > > > >
> > > > > > > > >
> > > > > > > > > > -----Original Message-----
> > > > > > > > > > From: Konstantin Ananyev <konstantin.ananyev@intel.com>
> > > > > > > > > > Sent: Wednesday, April 29, 2020 12:57 PM
> > > > > > > > > > To: dev@dpdk.org
> > > > > > > > > > Cc: aconole@redhat.com; Honnappa Nagarahalli
> > > > > > > > > > <Honnappa.Nagarahalli@arm.com>; Konstantin Ananyev
> > > > > > > > > > <konstantin.ananyev@intel.com>
> > > > > > > > > > Subject: [PATCH] test/ring: code rework to reduce
> > > > > > > > > > compilation time
> > > > > > > > > >
> > > > > > > > > > Rework test code to reduce code complexity for the
> > > > > > > > > > compiler and bring down compilation time and memory
> > consumption.
> > > > > > > > > >
> > > > > > > > > > Signed-off-by: Konstantin Ananyev
> > > > > > > > > > <konstantin.ananyev@intel.com>
> > > > > > > > > > ---
> > > > > > > > > > app/test/test_ring.c | 373
> > > > > > > > > > +++++++++++++++++++++++++++++--------------
> > > > > > > > > > 1 file changed, 249 insertions(+), 124 deletions(-)
> > > > > > > > > >
> > > > > > > > > > diff --git a/app/test/test_ring.c b/app/test/test_ring.=
c
> > > > > > > > > > index
> > > > > > > > > > e21557cd9..0ae97d341 100644
> > > > > > > > > > --- a/app/test/test_ring.c
> > > > > > > > > > +++ b/app/test/test_ring.c
> > > > > > > > > > @@ -58,6 +58,181 @@
> > > > > > > > > >
> > > > > > > > > > static const int esize[] =3D {-1, 4, 8, 16, 20};
> > > > > > > > > >
> > > > > > > > > > +static const struct {
> > > > > > > > > > + const char *desc;
> > > > > > > > > > + uint32_t api_type;
> > > > > > > > > > + uint32_t create_flags;
> > > > > > > > > > + struct {
> > > > > > > > > > + unsigned int (*flegacy)(struct rte_ring *r,
> > > > > > > > > > + void * const *obj_table, unsigned int n,
> > > > > > > > > > + unsigned int *free_space);
> > > > > > > > > > + unsigned int (*felem)(struct rte_ring *r, const void
> > > > > > *obj_table,
> > > > > > > > > > + unsigned int esize, unsigned int n,
> > > > > > > > > > + unsigned int *free_space);
> > > > > > > > > > + } enq;
> > > > > > > > > > + struct {
> > > > > > > > > > + unsigned int (*flegacy)(struct rte_ring *r,
> > > > > > > > > > + void **obj_table, unsigned int n,
> > > > > > > > > > + unsigned int *available);
> > > > > > > > > > + unsigned int (*felem)(struct rte_ring *r, void
> > > > > > *obj_table,
> > > > > > > > > > + unsigned int esize, unsigned int n,
> > > > > > > > > > + unsigned int *available);
> > > > > > > > > > + } deq;
> > > > > > > > > > +} test_enqdeq_impl[] =3D {
> > > > > > > > > > + {
> > > > > > > > > > + .desc =3D "MP/MC sync mode",
> > > > > > > > > Details about the tests are already printed by the
> > > > > > > > > function
> > > > > > > > 'test_ring_print_test_string'. This string should be 'Test =
standard
> > ring'.
> > > > > > > > >
> > > > > > > > > > + .api_type =3D TEST_RING_ELEM_BULK |
> > > > > > > > > > TEST_RING_THREAD_DEF,
> > > > > > > > > > + .create_flags =3D 0,
> > > > > > > > > > + .enq =3D {
> > > > > > > > > > + .flegacy =3D rte_ring_enqueue_bulk,
> > > > > > > > > > + .felem =3D rte_ring_enqueue_bulk_elem,
> > > > > > > > > > + },
> > > > > > > > > > + .deq =3D {
> > > > > > > > > > + .flegacy =3D rte_ring_dequeue_bulk,
> > > > > > > > > > + .felem =3D rte_ring_dequeue_bulk_elem,
> > > > > > > > > > + },
> > > > > > > > > > + },
> > > > > > > > > > + {
> > > > > > > > > > + .desc =3D "SP/SC sync mode",
> > > > > > > > > > + .api_type =3D TEST_RING_ELEM_BULK |
> > > > > > > > > > TEST_RING_THREAD_SPSC,
> > > > > > > > > > + .create_flags =3D RING_F_SP_ENQ | RING_F_SC_DEQ,
> > > > > > > > > > + .enq =3D {
> > > > > > > > > > + .flegacy =3D rte_ring_sp_enqueue_bulk,
> > > > > > > > > > + .felem =3D rte_ring_sp_enqueue_bulk_elem,
> > > > > > > > > > + },
> > > > > > > > > > + .deq =3D {
> > > > > > > > > > + .flegacy =3D rte_ring_sc_dequeue_bulk,
> > > > > > > > > > + .felem =3D rte_ring_sc_dequeue_bulk_elem,
> > > > > > > > > > + },
> > > > > > > > > > + },
> > > > > > > > > > + {
> > > > > > > > > > + .desc =3D "MP/MC sync mode",
> > > > > > > > > > + .api_type =3D TEST_RING_ELEM_BULK |
> > > > > > > > > > TEST_RING_THREAD_MPMC,
> > > > > > > > > > + .create_flags =3D 0,
> > > > > > > > > > + .enq =3D {
> > > > > > > > > > + .flegacy =3D rte_ring_mp_enqueue_bulk,
> > > > > > > > > > + .felem =3D rte_ring_mp_enqueue_bulk_elem,
> > > > > > > > > > + },
> > > > > > > > > > + .deq =3D {
> > > > > > > > > > + .flegacy =3D rte_ring_mc_dequeue_bulk,
> > > > > > > > > > + .felem =3D rte_ring_mc_dequeue_bulk_elem,
> > > > > > > > > > + },
> > > > > > > > > > + },
> > > > > > > > > > + {
> > > > > > > > > > + .desc =3D "MP_RTS/MC_RTS sync mode",
> > > > > > > > > > + .api_type =3D TEST_RING_ELEM_BULK |
> > > > > > > > > > TEST_RING_THREAD_DEF,
> > > > > > > > > > + .create_flags =3D RING_F_MP_RTS_ENQ |
> > > > > > > > > > RING_F_MC_RTS_DEQ,
> > > > > > > > > > + .enq =3D {
> > > > > > > > > > + .flegacy =3D rte_ring_enqueue_bulk,
> > > > > > > > > > + .felem =3D rte_ring_enqueue_bulk_elem,
> > > > > > > > > > + },
> > > > > > > > > > + .deq =3D {
> > > > > > > > > > + .flegacy =3D rte_ring_dequeue_bulk,
> > > > > > > > > > + .felem =3D rte_ring_dequeue_bulk_elem,
> > > > > > > > > > + },
> > > > > > > > > > + },
> > > > > > > > > > + {
> > > > > > > > > > + .desc =3D "MP_HTS/MC_HTS sync mode",
> > > > > > > > > > + .api_type =3D TEST_RING_ELEM_BULK |
> > > > > > > > > > TEST_RING_THREAD_DEF,
> > > > > > > > > > + .create_flags =3D RING_F_MP_HTS_ENQ |
> > > > > > > > > > RING_F_MC_HTS_DEQ,
> > > > > > > > > > + .enq =3D {
> > > > > > > > > > + .flegacy =3D rte_ring_enqueue_bulk,
> > > > > > > > > > + .felem =3D rte_ring_enqueue_bulk_elem,
> > > > > > > > > > + },
> > > > > > > > > > + .deq =3D {
> > > > > > > > > > + .flegacy =3D rte_ring_dequeue_bulk,
> > > > > > > > > > + .felem =3D rte_ring_dequeue_bulk_elem,
> > > > > > > > > > + },
> > > > > > > > > > + },
> > > > > > > > > > + {
> > > > > > > > > > + .desc =3D "MP/MC sync mode",
> > > > > > > > > > + .api_type =3D TEST_RING_ELEM_BURST |
> > > > > > > > > > TEST_RING_THREAD_DEF,
> > > > > > > > > > + .create_flags =3D 0,
> > > > > > > > > > + .enq =3D {
> > > > > > > > > > + .flegacy =3D rte_ring_enqueue_burst,
> > > > > > > > > > + .felem =3D rte_ring_enqueue_burst_elem,
> > > > > > > > > > + },
> > > > > > > > > > + .deq =3D {
> > > > > > > > > > + .flegacy =3D rte_ring_dequeue_burst,
> > > > > > > > > > + .felem =3D rte_ring_dequeue_burst_elem,
> > > > > > > > > > + },
> > > > > > > > > > + },
> > > > > > > > > > + {
> > > > > > > > > > + .desc =3D "SP/SC sync mode",
> > > > > > > > > > + .api_type =3D TEST_RING_ELEM_BURST |
> > > > > > > > > > TEST_RING_THREAD_SPSC,
> > > > > > > > > > + .create_flags =3D RING_F_SP_ENQ | RING_F_SC_DEQ,
> > > > > > > > > > + .enq =3D {
> > > > > > > > > > + .flegacy =3D rte_ring_sp_enqueue_burst,
> > > > > > > > > > + .felem =3D rte_ring_sp_enqueue_burst_elem,
> > > > > > > > > > + },
> > > > > > > > > > + .deq =3D {
> > > > > > > > > > + .flegacy =3D rte_ring_sc_dequeue_burst,
> > > > > > > > > > + .felem =3D rte_ring_sc_dequeue_burst_elem,
> > > > > > > > > > + },
> > > > > > > > > > + },
> > > > > > > > > > + {
> > > > > > > > > > + .desc =3D "MP/MC sync mode",
> > > > > > > > > > + .api_type =3D TEST_RING_ELEM_BURST |
> > > > > > > > > > TEST_RING_THREAD_MPMC,
> > > > > > > > > > + .create_flags =3D 0,
> > > > > > > > > > + .enq =3D {
> > > > > > > > > > + .flegacy =3D rte_ring_mp_enqueue_burst,
> > > > > > > > > > + .felem =3D rte_ring_mp_enqueue_burst_elem,
> > > > > > > > > > + },
> > > > > > > > > > + .deq =3D {
> > > > > > > > > > + .flegacy =3D rte_ring_mc_dequeue_burst,
> > > > > > > > > > + .felem =3D rte_ring_mc_dequeue_burst_elem,
> > > > > > > > > > + },
> > > > > > > > > > + },
> > > > > > > > > > + {
> > > > > > > > > > + .desc =3D "MP_RTS/MC_RTS sync mode",
> > > > > > > > > > + .api_type =3D TEST_RING_ELEM_BURST |
> > > > > > > > > > TEST_RING_THREAD_DEF,
> > > > > > > > > > + .create_flags =3D RING_F_MP_RTS_ENQ |
> > > > > > > > > > RING_F_MC_RTS_DEQ,
> > > > > > > > > > + .enq =3D {
> > > > > > > > > > + .flegacy =3D rte_ring_enqueue_burst,
> > > > > > > > > > + .felem =3D rte_ring_enqueue_burst_elem,
> > > > > > > > > > + },
> > > > > > > > > > + .deq =3D {
> > > > > > > > > > + .flegacy =3D rte_ring_dequeue_burst,
> > > > > > > > > > + .felem =3D rte_ring_dequeue_burst_elem,
> > > > > > > > > > + },
> > > > > > > > > > + },
> > > > > > > > > > + {
> > > > > > > > > > + .desc =3D "MP_HTS/MC_HTS sync mode",
> > > > > > > > > > + .api_type =3D TEST_RING_ELEM_BURST |
> > > > > > > > > > TEST_RING_THREAD_DEF,
> > > > > > > > > > + .create_flags =3D RING_F_MP_HTS_ENQ |
> > > > > > > > > > RING_F_MC_HTS_DEQ,
> > > > > > > > > > + .enq =3D {
> > > > > > > > > > + .flegacy =3D rte_ring_enqueue_burst,
> > > > > > > > > > + .felem =3D rte_ring_enqueue_burst_elem,
> > > > > > > > > > + },
> > > > > > > > > > + .deq =3D {
> > > > > > > > > > + .flegacy =3D rte_ring_dequeue_burst,
> > > > > > > > > > + .felem =3D rte_ring_dequeue_burst_elem,
> > > > > > > > > > + },
> > > > > > > > > > + },
> > > > > > > > > > +};
> > > > > > > > > > +
> > > > > > > > > > +static unsigned int
> > > > > > > > > > +test_ring_enq_impl(struct rte_ring *r, void **obj, int
> > > > > > > > > > +esize, unsigned
> > > > > > int n,
> > > > > > > > > > + unsigned int test_idx) {
> > > > > > > > > > + if (esize =3D=3D -1)
> > > > > > > > > > + return test_enqdeq_impl[test_idx].enq.flegacy(r, obj=
,
> > > > > > n, NULL);
> > > > > > > > > > + else
> > > > > > > > > > + return test_enqdeq_impl[test_idx].enq.felem(r, obj,
> > > > > > esize, n,
> > > > > > > > > > + NULL);
> > > > > > > > > > +}
> > > > > > > > > > +
> > > > > > > > > > +static unsigned int
> > > > > > > > > > +test_ring_deq_impl(struct rte_ring *r, void **obj, int
> > > > > > > > > > +esize, unsigned
> > > > > > int n,
> > > > > > > > > > + unsigned int test_idx) {
> > > > > > > > > > + if (esize =3D=3D -1)
> > > > > > > > > > + return test_enqdeq_impl[test_idx].deq.flegacy(r, obj=
,
> > > > > > n, NULL);
> > > > > > > > > > + else
> > > > > > > > > > + return test_enqdeq_impl[test_idx].deq.felem(r, obj,
> > > > > > esize, n,
> > > > > > > > > > + NULL);
> > > > > > > > > > +}
> > > > > > > > > > +
> > > > > > > > > > static void**
> > > > > > > > > > test_ring_inc_ptr(void **obj, int esize, unsigned int
> > > > > > > > > > n) { @@
> > > > > > > > > > -203,8 +378,7 @@ test_ring_negative_tests(void)
> > > > > > > > > > * Random number of elements are enqueued and dequeued=
.
> > > > > > > > > > */
> > > > > > > > > > static int
> > > > > > > > > > -test_ring_burst_bulk_tests1(unsigned int api_type,
> > > > > > > > > > unsigned int
> > > > > > > > create_flags,
> > > > > > > > > > - const char *tname)
> > > > > > > > > > +test_ring_burst_bulk_tests1(unsigned int test_idx)
> > > > > > > > > > {
> > > > > > > > > > struct rte_ring *r;
> > > > > > > > > > void **src =3D NULL, **cur_src =3D NULL, **dst =3D NU=
LL,
> > > > > > > > > > **cur_dst =3D NULL; @@ -214,11 +388,13 @@
> > > > > > test_ring_burst_bulk_tests1(unsigned
> > > > > > > > > > int api_type, unsigned int create_flags,
> > > > > > > > > > const unsigned int rsz =3D RING_SIZE - 1;
> > > > > > > > > >
> > > > > > > > > > for (i =3D 0; i < RTE_DIM(esize); i++) {
> > > > > > > > > > - test_ring_print_test_string(tname, api_type, esize[i=
]);
> > > > > > > > > > +
> > > > > > test_ring_print_test_string(test_enqdeq_impl[test_idx].desc,
> > > > > > > > > > + test_enqdeq_impl[test_idx].api_type, esize[i]);
> > > > > > > > > >
> > > > > > > > > > /* Create the ring */
> > > > > > > > > > r =3D test_ring_create("test_ring_burst_bulk_tests",
> > > > esize[i],
> > > > > > > > > > - RING_SIZE, SOCKET_ID_ANY,
> > > > > > > > > > create_flags);
> > > > > > > > > > + RING_SIZE, SOCKET_ID_ANY,
> > > > > > > > > > +
> > > > > > test_enqdeq_impl[test_idx].create_flags);
> > > > > > > > > >
> > > > > > > > > > /* alloc dummy object pointers */
> > > > > > > > > > src =3D test_ring_calloc(RING_SIZE * 2, esize[i]); @=
@
> > > > > > > > > > -240,17
> > > > > > > > > > +416,17 @@ test_ring_burst_bulk_tests1(unsigned int
> > > > > > > > > > +api_type, unsigned int
> > > > > > > > > > create_flags,
> > > > > > > > > > rand =3D RTE_MAX(rte_rand() % RING_SIZE,
> > > > 1UL);
> > > > > > > > > > printf("%s: iteration %u, random shift: %u;\n",
> > > > > > > > > > __func__, i, rand);
> > > > > > > > > > - ret =3D test_ring_enqueue(r, cur_src, esize[i],
> > > > > > rand,
> > > > > > > > > > - api_type);
> > > > > > > > > > + ret =3D test_ring_enq_impl(r, cur_src, esize[i],
> > > > > > rand,
> > > > > > > > > > + test_idx);
> > > > > > > > > > TEST_RING_VERIFY(ret !=3D 0);
> > > > > > > > > >
> > > > > > > > > > - ret =3D test_ring_dequeue(r, cur_dst, esize[i],
> > > > > > rand,
> > > > > > > > > > - api_type);
> > > > > > > > > > + ret =3D test_ring_deq_impl(r, cur_dst, esize[i],
> > > > > > rand,
> > > > > > > > > > + test_idx);
> > > > > > > > > > TEST_RING_VERIFY(ret =3D=3D rand);
> > > > > > > > > >
> > > > > > > > > > /* fill the ring */
> > > > > > > > > > - ret =3D test_ring_enqueue(r, cur_src, esize[i],
> > rsz,
> > > > > > > > > > - api_type);
> > > > > > > > > > + ret =3D test_ring_enq_impl(r, cur_src, esize[i],
> > > > > > rsz,
> > > > > > > > > > + test_idx);
> > > > > > > > > > TEST_RING_VERIFY(ret !=3D 0);
> > > > > > > > > >
> > > > > > > > > > TEST_RING_VERIFY(rte_ring_free_count(r) =3D=3D
> > > > 0); @@
> > > > > > > > > > -259,8 +435,8 @@ test_ring_burst_bulk_tests1(unsigned
> > > > > > > > > > int api_type, unsigned int create_flags,
> > > > > > > > > > TEST_RING_VERIFY(rte_ring_empty(r) =3D=3D 0);
> > > > > > > > > >
> > > > > > > > > > /* empty the ring */
> > > > > > > > > > - ret =3D test_ring_dequeue(r, cur_dst, esize[i],
> > rsz,
> > > > > > > > > > - api_type);
> > > > > > > > > > + ret =3D test_ring_deq_impl(r, cur_dst, esize[i],
> > > > > > rsz,
> > > > > > > > > > + test_idx);
> > > > > > > > > > TEST_RING_VERIFY(ret =3D=3D (int)rsz);
> > > > > > > > > > TEST_RING_VERIFY(rsz =3D=3D
> > > > rte_ring_free_count(r));
> > > > > > > > > > TEST_RING_VERIFY(rte_ring_count(r) =3D=3D 0);
> > > > @@ -
> > > > > > > > > > 294,8 +470,7 @@ test_ring_burst_bulk_tests1(unsigned in=
t
> > > > > > > > > > api_type, unsigned int create_flags,
> > > > > > > > > > * dequeued data.
> > > > > > > > > > */
> > > > > > > > > > static int
> > > > > > > > > > -test_ring_burst_bulk_tests2(unsigned int api_type,
> > > > > > > > > > unsigned int
> > > > > > > > create_flags,
> > > > > > > > > > - const char *tname)
> > > > > > > > > > +test_ring_burst_bulk_tests2(unsigned int test_idx)
> > > > > > > > > > {
> > > > > > > > > > struct rte_ring *r;
> > > > > > > > > > void **src =3D NULL, **cur_src =3D NULL, **dst =3D NU=
LL,
> > > > > > > > > > **cur_dst =3D NULL; @@ -303,11 +478,13 @@
> > > > > > test_ring_burst_bulk_tests2(unsigned
> > > > > > > > > > int api_type, unsigned int create_flags,
> > > > > > > > > > unsigned int i;
> > > > > > > > > >
> > > > > > > > > > for (i =3D 0; i < RTE_DIM(esize); i++) {
> > > > > > > > > > - test_ring_print_test_string(tname, api_type, esize[i=
]);
> > > > > > > > > > +
> > > > > > test_ring_print_test_string(test_enqdeq_impl[test_idx].desc,
> > > > > > > > > > + test_enqdeq_impl[test_idx].api_type, esize[i]);
> > > > > > > > > >
> > > > > > > > > > /* Create the ring */
> > > > > > > > > > r =3D test_ring_create("test_ring_burst_bulk_tests",
> > > > esize[i],
> > > > > > > > > > - RING_SIZE, SOCKET_ID_ANY,
> > > > > > > > > > create_flags);
> > > > > > > > > > + RING_SIZE, SOCKET_ID_ANY,
> > > > > > > > > > +
> > > > > > test_enqdeq_impl[test_idx].create_flags);
> > > > > > > > > >
> > > > > > > > > > /* alloc dummy object pointers */
> > > > > > > > > > src =3D test_ring_calloc(RING_SIZE * 2, esize[i]); @=
@
> > > > > > > > > > -323,39
> > > > > > > > > > +500,39 @@ test_ring_burst_bulk_tests2(unsigned int
> > > > > > > > > > +api_type, unsigned int
> > > > > > > > > > create_flags,
> > > > > > > > > > cur_dst =3D dst;
> > > > > > > > > >
> > > > > > > > > > printf("enqueue 1 obj\n");
> > > > > > > > > > - ret =3D test_ring_enqueue(r, cur_src, esize[i], 1,
> > > > > > api_type);
> > > > > > > > > > + ret =3D test_ring_enq_impl(r, cur_src, esize[i], 1,
> > > > > > test_idx);
> > > > > > > > > > if (ret !=3D 1)
> > > > > > > > > > goto fail;
> > > > > > > > > > cur_src =3D test_ring_inc_ptr(cur_src, esize[i], 1);
> > > > > > > > > >
> > > > > > > > > > printf("enqueue 2 objs\n");
> > > > > > > > > > - ret =3D test_ring_enqueue(r, cur_src, esize[i], 2,
> > > > > > api_type);
> > > > > > > > > > + ret =3D test_ring_enq_impl(r, cur_src, esize[i], 2,
> > > > > > test_idx);
> > > > > > > > > > if (ret !=3D 2)
> > > > > > > > > > goto fail;
> > > > > > > > > > cur_src =3D test_ring_inc_ptr(cur_src, esize[i], 2);
> > > > > > > > > >
> > > > > > > > > > printf("enqueue MAX_BULK objs\n");
> > > > > > > > > > - ret =3D test_ring_enqueue(r, cur_src, esize[i],
> > > > > > MAX_BULK,
> > > > > > > > > > - api_type);
> > > > > > > > > > + ret =3D test_ring_enq_impl(r, cur_src, esize[i],
> > > > > > MAX_BULK,
> > > > > > > > > > + test_idx);
> > > > > > > > > > if (ret !=3D MAX_BULK)
> > > > > > > > > > goto fail;
> > > > > > > > > > cur_src =3D test_ring_inc_ptr(cur_src, esize[i],
> > > > MAX_BULK);
> > > > > > > > > >
> > > > > > > > > > printf("dequeue 1 obj\n");
> > > > > > > > > > - ret =3D test_ring_dequeue(r, cur_dst, esize[i], 1,
> > > > > > api_type);
> > > > > > > > > > + ret =3D test_ring_deq_impl(r, cur_dst, esize[i], 1,
> > > > > > test_idx);
> > > > > > > > > > if (ret !=3D 1)
> > > > > > > > > > goto fail;
> > > > > > > > > > cur_dst =3D test_ring_inc_ptr(cur_dst, esize[i], 1);
> > > > > > > > > >
> > > > > > > > > > printf("dequeue 2 objs\n");
> > > > > > > > > > - ret =3D test_ring_dequeue(r, cur_dst, esize[i], 2,
> > > > > > api_type);
> > > > > > > > > > + ret =3D test_ring_deq_impl(r, cur_dst, esize[i], 2,
> > > > > > test_idx);
> > > > > > > > > > if (ret !=3D 2)
> > > > > > > > > > goto fail;
> > > > > > > > > > cur_dst =3D test_ring_inc_ptr(cur_dst, esize[i], 2);
> > > > > > > > > >
> > > > > > > > > > printf("dequeue MAX_BULK objs\n");
> > > > > > > > > > - ret =3D test_ring_dequeue(r, cur_dst, esize[i],
> > > > > > MAX_BULK,
> > > > > > > > > > - api_type);
> > > > > > > > > > + ret =3D test_ring_deq_impl(r, cur_dst, esize[i],
> > > > > > MAX_BULK,
> > > > > > > > > > + test_idx);
> > > > > > > > > > if (ret !=3D MAX_BULK)
> > > > > > > > > > goto fail;
> > > > > > > > > > cur_dst =3D test_ring_inc_ptr(cur_dst, esize[i],
> > > > MAX_BULK);
> > > > > > > > > > @@
> > > > > > > > > > -390,8 +567,7 @@ test_ring_burst_bulk_tests2(unsigned
> > > > > > > > > > int api_type, unsigned int create_flags,
> > > > > > > > > > * Enqueue and dequeue to cover the entire ring length=
.
> > > > > > > > > > */
> > > > > > > > > > static int
> > > > > > > > > > -test_ring_burst_bulk_tests3(unsigned int api_type,
> > > > > > > > > > unsigned int
> > > > > > > > create_flags,
> > > > > > > > > > - const char *tname)
> > > > > > > > > > +test_ring_burst_bulk_tests3(unsigned int test_idx)
> > > > > > > > > > {
> > > > > > > > > > struct rte_ring *r;
> > > > > > > > > > void **src =3D NULL, **cur_src =3D NULL, **dst =3D NU=
LL,
> > > > > > > > > > **cur_dst =3D NULL; @@ -399,11 +575,13 @@
> > > > > > test_ring_burst_bulk_tests3(unsigned
> > > > > > > > > > int api_type, unsigned int create_flags,
> > > > > > > > > > unsigned int i, j;
> > > > > > > > > >
> > > > > > > > > > for (i =3D 0; i < RTE_DIM(esize); i++) {
> > > > > > > > > > - test_ring_print_test_string(tname, api_type, esize[i=
]);
> > > > > > > > > > +
> > > > > > test_ring_print_test_string(test_enqdeq_impl[test_idx].desc,
> > > > > > > > > > + test_enqdeq_impl[test_idx].api_type, esize[i]);
> > > > > > > > > >
> > > > > > > > > > /* Create the ring */
> > > > > > > > > > r =3D test_ring_create("test_ring_burst_bulk_tests",
> > > > esize[i],
> > > > > > > > > > - RING_SIZE, SOCKET_ID_ANY,
> > > > > > > > > > create_flags);
> > > > > > > > > > + RING_SIZE, SOCKET_ID_ANY,
> > > > > > > > > > +
> > > > > > test_enqdeq_impl[test_idx].create_flags);
> > > > > > > > > >
> > > > > > > > > > /* alloc dummy object pointers */
> > > > > > > > > > src =3D test_ring_calloc(RING_SIZE * 2, esize[i]); @=
@
> > > > > > > > > > -420,15
> > > > > > > > > > +598,15 @@ test_ring_burst_bulk_tests3(unsigned int
> > > > > > > > > > +api_type, unsigned int
> > > > > > > > > > create_flags,
> > > > > > > > > >
> > > > > > > > > > printf("fill and empty the ring\n");
> > > > > > > > > > for (j =3D 0; j < RING_SIZE / MAX_BULK; j++) {
> > > > > > > > > > - ret =3D test_ring_enqueue(r, cur_src, esize[i],
> > > > > > > > > > MAX_BULK,
> > > > > > > > > > - api_type);
> > > > > > > > > > + ret =3D test_ring_enq_impl(r, cur_src, esize[i],
> > > > > > > > > > MAX_BULK,
> > > > > > > > > > + test_idx);
> > > > > > > > > > if (ret !=3D MAX_BULK)
> > > > > > > > > > goto fail;
> > > > > > > > > > cur_src =3D test_ring_inc_ptr(cur_src, esize[i],
> > > > > > > > > >
> > > > MAX_BULK);
> > > > > > > > > >
> > > > > > > > > > - ret =3D test_ring_dequeue(r, cur_dst, esize[i],
> > > > > > > > > > MAX_BULK,
> > > > > > > > > > - api_type);
> > > > > > > > > > + ret =3D test_ring_deq_impl(r, cur_dst, esize[i],
> > > > > > > > > > MAX_BULK,
> > > > > > > > > > + test_idx);
> > > > > > > > > > if (ret !=3D MAX_BULK)
> > > > > > > > > > goto fail;
> > > > > > > > > > cur_dst =3D test_ring_inc_ptr(cur_dst, esize[i],
> > > > @@ -
> > > > > > > > > > 465,21 +643,24 @@ test_ring_burst_bulk_tests3(unsigned
> > > > > > > > > > int api_type, unsigned int create_flags,
> > > > > > > > > > * Enqueue till the ring is full and dequeue till the
> > > > > > > > > > ring becomes
> > > > empty.
> > > > > > > > > > */
> > > > > > > > > > static int
> > > > > > > > > > -test_ring_burst_bulk_tests4(unsigned int api_type,
> > > > > > > > > > unsigned int
> > > > > > > > create_flags,
> > > > > > > > > > - const char *tname)
> > > > > > > > > > +test_ring_burst_bulk_tests4(unsigned int test_idx)
> > > > > > > > > > {
> > > > > > > > > > struct rte_ring *r;
> > > > > > > > > > void **src =3D NULL, **cur_src =3D NULL, **dst =3D NU=
LL,
> > > > > > > > > > **cur_dst
> > > > =3D NULL;
> > > > > > > > > > int ret;
> > > > > > > > > > unsigned int i, j;
> > > > > > > > > > - unsigned int num_elems;
> > > > > > > > > > + unsigned int api_type, num_elems;
> > > > > > > > > > +
> > > > > > > > > > + api_type =3D test_enqdeq_impl[test_idx].api_type;
> > > > > > > > > >
> > > > > > > > > > for (i =3D 0; i < RTE_DIM(esize); i++) {
> > > > > > > > > > - test_ring_print_test_string(tname, api_type, esize[i=
]);
> > > > > > > > > > +
> > > > > > test_ring_print_test_string(test_enqdeq_impl[test_idx].desc,
> > > > > > > > > > + test_enqdeq_impl[test_idx].api_type, esize[i]);
> > > > > > > > > >
> > > > > > > > > > /* Create the ring */
> > > > > > > > > > r =3D test_ring_create("test_ring_burst_bulk_tests",
> > > > esize[i],
> > > > > > > > > > - RING_SIZE, SOCKET_ID_ANY,
> > > > > > > > > > create_flags);
> > > > > > > > > > + RING_SIZE, SOCKET_ID_ANY,
> > > > > > > > > > +
> > > > > > test_enqdeq_impl[test_idx].create_flags);
> > > > > > > > > >
> > > > > > > > > > /* alloc dummy object pointers */
> > > > > > > > > > src =3D test_ring_calloc(RING_SIZE * 2, esize[i]); @=
@
> > > > > > > > > > -496,8
> > > > > > > > > > +677,8 @@ test_ring_burst_bulk_tests4(unsigned int
> > > > > > > > > > +api_type, unsigned int
> > > > > > > > > > create_flags,
> > > > > > > > > >
> > > > > > > > > > printf("Test enqueue without enough memory
> > > > space\n");
> > > > > > > > > > for (j =3D 0; j < (RING_SIZE/MAX_BULK - 1); j++) {
> > > > > > > > > > - ret =3D test_ring_enqueue(r, cur_src, esize[i],
> > > > > > > > > > MAX_BULK,
> > > > > > > > > > - api_type);
> > > > > > > > > > + ret =3D test_ring_enq_impl(r, cur_src, esize[i],
> > > > > > > > > > MAX_BULK,
> > > > > > > > > > + test_idx);
> > > > > > > > > > if (ret !=3D MAX_BULK)
> > > > > > > > > > goto fail;
> > > > > > > > > > cur_src =3D test_ring_inc_ptr(cur_src, esize[i],
> > > > @@ -
> > > > > > > > > > 505,7 +686,7 @@ test_ring_burst_bulk_tests4(unsigned in=
t
> > > > > > > > > > api_type, unsigned int create_flags,
> > > > > > > > > > }
> > > > > > > > > >
> > > > > > > > > > printf("Enqueue 2 objects, free entries =3D MAX_BULK=
-
> > > > 2\n");
> > > > > > > > > > - ret =3D test_ring_enqueue(r, cur_src, esize[i], 2,
> > > > > > api_type);
> > > > > > > > > > + ret =3D test_ring_enq_impl(r, cur_src, esize[i], 2,
> > > > > > test_idx);
> > > > > > > > > > if (ret !=3D 2)
> > > > > > > > > > goto fail;
> > > > > > > > > > cur_src =3D test_ring_inc_ptr(cur_src, esize[i], 2);=
@@
> > > > > > > > > > -517,8
> > > > > > > > > > +698,8 @@ test_ring_burst_bulk_tests4(unsigned int
> > > > > > > > > > +api_type, unsigned int
> > > > > > > > > > create_flags,
> > > > > > > > > > else
> > > > > > > > > > num_elems =3D MAX_BULK;
> > > > > > > > > > /* Always one free entry left */
> > > > > > > > > > - ret =3D test_ring_enqueue(r, cur_src, esize[i],
> > > > > > num_elems,
> > > > > > > > > > - api_type);
> > > > > > > > > > + ret =3D test_ring_enq_impl(r, cur_src, esize[i],
> > > > > > num_elems,
> > > > > > > > > > + test_idx);
> > > > > > > > > > if (ret !=3D MAX_BULK - 3)
> > > > > > > > > > goto fail;
> > > > > > > > > > cur_src =3D test_ring_inc_ptr(cur_src, esize[i],
> > > > MAX_BULK -
> > > > > > > > > > 3);
> > > > > > > > @@
> > > > > > > > > > -528,15 +709,15 @@ test_ring_burst_bulk_tests4(unsigned
> > > > > > > > > > int api_type, unsigned int create_flags,
> > > > > > > > > > goto fail;
> > > > > > > > > >
> > > > > > > > > > printf("Test enqueue for a full entry\n");
> > > > > > > > > > - ret =3D test_ring_enqueue(r, cur_src, esize[i],
> > > > > > MAX_BULK,
> > > > > > > > > > - api_type);
> > > > > > > > > > + ret =3D test_ring_enq_impl(r, cur_src, esize[i],
> > > > > > MAX_BULK,
> > > > > > > > > > + test_idx);
> > > > > > > > > > if (ret !=3D 0)
> > > > > > > > > > goto fail;
> > > > > > > > > >
> > > > > > > > > > printf("Test dequeue without enough objects\n");
> > > > > > > > > > for (j =3D 0; j < RING_SIZE / MAX_BULK - 1; j++) {
> > > > > > > > > > - ret =3D test_ring_dequeue(r, cur_dst, esize[i],
> > > > > > > > > > MAX_BULK,
> > > > > > > > > > - api_type);
> > > > > > > > > > + ret =3D test_ring_deq_impl(r, cur_dst, esize[i],
> > > > > > > > > > MAX_BULK,
> > > > > > > > > > + test_idx);
> > > > > > > > > > if (ret !=3D MAX_BULK)
> > > > > > > > > > goto fail;
> > > > > > > > > > cur_dst =3D test_ring_inc_ptr(cur_dst, esize[i],
> > > > @@ -
> > > > > > > > > > 544,7 +725,7 @@ test_ring_burst_bulk_tests4(unsigned in=
t
> > > > > > > > > > api_type, unsigned int create_flags,
> > > > > > > > > > }
> > > > > > > > > >
> > > > > > > > > > /* Available memory space for the exact MAX_BULK
> > > > entries
> > > > > > > > */
> > > > > > > > > > - ret =3D test_ring_dequeue(r, cur_dst, esize[i], 2,
> > > > > > api_type);
> > > > > > > > > > + ret =3D test_ring_deq_impl(r, cur_dst, esize[i], 2,
> > > > > > test_idx);
> > > > > > > > > > if (ret !=3D 2)
> > > > > > > > > > goto fail;
> > > > > > > > > > cur_dst =3D test_ring_inc_ptr(cur_dst, esize[i], 2);=
@@
> > > > > > > > > > -554,8
> > > > > > > > > > +735,8 @@ test_ring_burst_bulk_tests4(unsigned int
> > > > > > > > > > +api_type, unsigned int
> > > > > > > > > > create_flags,
> > > > > > > > > > num_elems =3D MAX_BULK - 3;
> > > > > > > > > > else
> > > > > > > > > > num_elems =3D MAX_BULK;
> > > > > > > > > > - ret =3D test_ring_dequeue(r, cur_dst, esize[i],
> > > > > > num_elems,
> > > > > > > > > > - api_type);
> > > > > > > > > > + ret =3D test_ring_deq_impl(r, cur_dst, esize[i],
> > > > > > num_elems,
> > > > > > > > > > + test_idx);
> > > > > > > > > > if (ret !=3D MAX_BULK - 3)
> > > > > > > > > > goto fail;
> > > > > > > > > > cur_dst =3D test_ring_inc_ptr(cur_dst, esize[i],
> > > > MAX_BULK -
> > > > > > > > > > 3);
> > > > > > > > @@
> > > > > > > > > > -816,22 +997,7 @@ static int
> > > > > > > > > > test_ring(void)
> > > > > > > > > > {
> > > > > > > > > > int32_t rc;
> > > > > > > > > > - unsigned int i, j;
> > > > > > > > > > - const char *tname;
> > > > > > > > > > -
> > > > > > > > > > - static const struct {
> > > > > > > > > > - uint32_t create_flags;
> > > > > > > > > > - const char *name;
> > > > > > > > > > - } test_sync_modes[] =3D {
> > > > > > > > > > - {
> > > > > > > > > > - RING_F_MP_RTS_ENQ |
> > > > > > RING_F_MC_RTS_DEQ,
> > > > > > > > > > - "Test MT_RTS ring",
> > > > > > > > > > - },
> > > > > > > > > > - {
> > > > > > > > > > - RING_F_MP_HTS_ENQ |
> > > > > > RING_F_MC_HTS_DEQ,
> > > > > > > > > > - "Test MT_HTS ring",
> > > > > > > > > > - },
> > > > > > > > > > - };
> > > > > > > > > > + unsigned int i;
> > > > > > > > > >
> > > > > > > > > > /* Negative test cases */
> > > > > > > > > > if (test_ring_negative_tests() < 0) @@ -848,65
> > > > > > > > > > +1014,24 @@
> > > > > > > > > > test_ring(void)
> > > > > > > > > > * The test cases are split into smaller test cases t=
o
> > > > > > > > > > * help clang compile faster.
> > > > > > > > > > */
> > > > > > > > > > - tname =3D "Test standard ring";
> > > > > > > > > > -
> > > > > > > > > > - for (j =3D TEST_RING_ELEM_BULK; j <=3D
> > TEST_RING_ELEM_BURST;
> > > > > > j <<=3D 1)
> > > > > > > > > > - for (i =3D TEST_RING_THREAD_DEF;
> > > > > > > > > > - i <=3D
> > > > > > TEST_RING_THREAD_MPMC; i
> > > > > > > > > > <<=3D 1)
> > > > > > > > > > - if (test_ring_burst_bulk_tests1(i | j, 0, tname)
> > > > > > < 0)
> > > > > > > > > > - goto test_fail;
> > > > > > > > > > -
> > > > > > > > > > - for (j =3D TEST_RING_ELEM_BULK; j <=3D
> > TEST_RING_ELEM_BURST;
> > > > > > j <<=3D 1)
> > > > > > > > > > - for (i =3D TEST_RING_THREAD_DEF;
> > > > > > > > > > - i <=3D
> > > > > > TEST_RING_THREAD_MPMC; i
> > > > > > > > > > <<=3D 1)
> > > > > > > > > > - if (test_ring_burst_bulk_tests2(i | j, 0, tname)
> > > > > > < 0)
> > > > > > > > > > - goto test_fail;
> > > > > > > > > > -
> > > > > > > > > > - for (j =3D TEST_RING_ELEM_BULK; j <=3D
> > TEST_RING_ELEM_BURST;
> > > > > > j <<=3D 1)
> > > > > > > > > > - for (i =3D TEST_RING_THREAD_DEF;
> > > > > > > > > > - i <=3D
> > > > > > TEST_RING_THREAD_MPMC; i
> > > > > > > > > > <<=3D 1)
> > > > > > > > > > - if (test_ring_burst_bulk_tests3(i | j, 0, tname)
> > > > > > < 0)
> > > > > > > > > > - goto test_fail;
> > > > > > > > > > -
> > > > > > > > > > - for (j =3D TEST_RING_ELEM_BULK; j <=3D
> > TEST_RING_ELEM_BURST;
> > > > > > j <<=3D 1)
> > > > > > > > > > - for (i =3D TEST_RING_THREAD_DEF;
> > > > > > > > > > - i <=3D
> > > > > > TEST_RING_THREAD_MPMC; i
> > > > > > > > > > <<=3D 1)
> > > > > > > > > > - if (test_ring_burst_bulk_tests4(i | j, 0, tname)
> > > > > > < 0)
> > > > > > > > > > - goto test_fail;
> > > > > > > > > > -
> > > > > > > > > > - /* Burst and bulk operations with MT_RTS and MT_HTS s=
ync
> > > > > > modes
> > > > > > > > > > */
> > > > > > > > > > - for (i =3D 0; i !=3D RTE_DIM(test_sync_modes); i++) {
> > > > > > > > > > - for (j =3D TEST_RING_ELEM_BULK; j <=3D
> > > > > > TEST_RING_ELEM_BURST;
> > > > > > > > > > - j <<=3D 1) {
> > > > > > > > > > -
> > > > > > > > > > - rc =3D test_ring_burst_bulk_tests1(
> > > > > > > > > > - TEST_RING_THREAD_DEF | j,
> > > > > > > > > > - test_sync_modes[i].create_flags,
> > > > > > > > > > - test_sync_modes[i].name);
> > > > > > > > > > - if (rc < 0)
> > > > > > > > > > - goto test_fail;
> > > > > > > > > > -
> > > > > > > > > > - rc =3D test_ring_burst_bulk_tests2(
> > > > > > > > > > - TEST_RING_THREAD_DEF | j,
> > > > > > > > > > - test_sync_modes[i].create_flags,
> > > > > > > > > > - test_sync_modes[i].name);
> > > > > > > > > > - if (rc < 0)
> > > > > > > > > > - goto test_fail;
> > > > > > > > > > -
> > > > > > > > > > - rc =3D test_ring_burst_bulk_tests3(
> > > > > > > > > > - TEST_RING_THREAD_DEF | j,
> > > > > > > > > > - test_sync_modes[i].create_flags,
> > > > > > > > > > - test_sync_modes[i].name);
> > > > > > > > > > - if (rc < 0)
> > > > > > > > > > - goto test_fail;
> > > > > > > > > > -
> > > > > > > > > > - rc =3D test_ring_burst_bulk_tests3(
> > > > > > > > > > - TEST_RING_THREAD_DEF | j,
> > > > > > > > > > - test_sync_modes[i].create_flags,
> > > > > > > > > > - test_sync_modes[i].name);
> > > > > > > > > > - if (rc < 0)
> > > > > > > > > > - goto test_fail;
> > > > > > > > > > - }
> > > > > > > > > > + for (i =3D 0; i !=3D RTE_DIM(test_enqdeq_impl); i++) =
{
> > > > > > > > > > +
> > > > > > > > > > +
> > > > > > > > > > + rc =3D test_ring_burst_bulk_tests1(i);
> > > > > > > > > > + if (rc < 0)
> > > > > > > > > > + goto test_fail;
> > > > > > > > > > +
> > > > > > > > > > + rc =3D test_ring_burst_bulk_tests2(i);
> > > > > > > > > > + if (rc < 0)
> > > > > > > > > > + goto test_fail;
> > > > > > > > > > +
> > > > > > > > > > + rc =3D test_ring_burst_bulk_tests3(i);
> > > > > > > > > > + if (rc < 0)
> > > > > > > > > > + goto test_fail;
> > > > > > > > > > +
> > > > > > > > > > + rc =3D test_ring_burst_bulk_tests4(i);
> > > > > > > > > > + if (rc < 0)
> > > > > > > > > > + goto test_fail;
> > > > > > > > > > }
> > > > > > > > > >
> > > > > > > > > > /* dump the ring status */
> > > > > > > > > > --
> > > > > > > > > > 2.17.1