From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from NAM03-CO1-obe.outbound.protection.outlook.com (mail-co1nam03on0056.outbound.protection.outlook.com [104.47.40.56]) by dpdk.org (Postfix) with ESMTP id C3F5A5592 for ; Tue, 4 Jul 2017 11:24:19 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=CAVIUMNETWORKS.onmicrosoft.com; s=selector1-cavium-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version; bh=mHMAyV21CVKegsze6Bkcy00dese0tbL5yrMfrTkKKQM=; b=Hp3NRI1RqHOmcoxdpUi+at9cL75Ck8POLSm2JzBvQO9LYFClMLjoG64CXx176BspfvkuZoCDKQOwrCe+LvWbyYh8SAddggqs8P1bZURndw8tGibNZgrQcjYjk152oGk2r33TZyQ5SvFrtCxqI0k3UCHv1tSfOS+FyHnWw7gOMl8= Authentication-Results: caviumnetworks.com; dkim=none (message not signed) header.d=none;caviumnetworks.com; dmarc=none action=none header.from=caviumnetworks.com; Received: from 1scrb-1.caveonetworks.com (50.233.148.156) by MWHPR07MB3069.namprd07.prod.outlook.com (10.172.97.11) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1220.11; Tue, 4 Jul 2017 09:24:18 +0000 From: Ashwin Sekhar T K To: jerin.jacob@caviumnetworks.com, viktorin@rehivetech.com, jianbo.liu@linaro.org, jasvinder.singh@intel.com, thomas@monjalon.net Cc: dev@dpdk.org, Ashwin Sekhar T K Date: Tue, 4 Jul 2017 02:24:07 -0700 Message-Id: <20170704092408.30878-4-ashwin.sekhar@caviumnetworks.com> X-Mailer: git-send-email 2.12.2 In-Reply-To: <20170704092408.30878-1-ashwin.sekhar@caviumnetworks.com> References: <20170427140618.35897-1-ashwin.sekhar@caviumnetworks.com> <20170704092408.30878-1-ashwin.sekhar@caviumnetworks.com> MIME-Version: 1.0 Content-Type: text/plain X-Originating-IP: [50.233.148.156] X-ClientProxiedBy: MWHPR15CA0049.namprd15.prod.outlook.com (10.174.254.11) To MWHPR07MB3069.namprd07.prod.outlook.com (10.172.97.11) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 2ab0e7ce-3dab-47c8-6442-08d4c2be7262 X-Microsoft-Antispam: UriScan:; BCL:0; PCL:0; RULEID:(300000500095)(300135000095)(300000501095)(300135300095)(22001)(300000502095)(300135100095)(300000503095)(300135400095)(201703131423075)(201703031133081)(300000504095)(300135200095)(300000505095)(300135600095)(300000506095)(300135500095); SRVR:MWHPR07MB3069; X-Microsoft-Exchange-Diagnostics: 1; MWHPR07MB3069; 3:qUabCeBD6SlQyU9kAwgadHqElVREa07hmgD2nbI2EiopAl0HTkXALcbt13PawPi+I8qoh0XWXAii8lBG6q+eguMAdePERSP/TOBVZNIVMEWjZj5g4J0pr0ZI+HPNIC6vLwkL2t4Gq0Bt8t+1SyEEZh/TxIWeY2eZ6KOZ0fh9jVa04cDMBUJ5euBJsCgw7umZLoAJgA7+EIG7CdZn9Y9CPaA+7k0YipCxYKYyFV+7y0PpBpv6YF22cbcesAJyKhkl9wcMPU+ypMy8+i4eaRzHVdrrEkEj5a48gWwZLJ0hL8OkB8GY26F91MHJFgnAyHk24E/qr+VPVrDxn03c+ni7kWlGjuUOAzw1wPSNpN/Mgz6u4s1O+RAhu0s3bhdiOoQWN/S+ZatKw8EXX9yaOWJ7vtSgkz3fol2e3QPAa24aN1/3KF57bzHNiNyAlek/QpyOcQmkFPFFMtuoncsvbj2L8/wpsGk4h3Viip4ch/L8Zdy/5h3s6OVrqj9yQEFZY4OWM8+j7oGQ2pXVEDaCd8eMM0rzZeOHDFjxbcWrCsn5Brj7uNz/NO+IbfTL3wF6yoM8x+26MbjNkuJPzgy/g+4Wi7rFmpdFObwjT8Yr1AGrFGsY+3TCbytKl3sDJyJhQIF7ZGsqhSDLNy3DEAw4+byJxoBdCvvBuAl8Gb3lIx5AqLxzTIDLxZeUCHn/9DoRhBQ6NBSZcb3kbszKdEj5pJxDENuXLkHgjMkwJPOMeCC1rEdmSVpp1dGptvowf98e0zvU X-MS-TrafficTypeDiagnostic: MWHPR07MB3069: X-Microsoft-Exchange-Diagnostics: 1; MWHPR07MB3069; 25:GNBCFOZBWTl98daQNhXPYfsy72fIrzYVm6Ed2TSmAb6YvAlL5mOnddKcH3NQBuacroBkdqpItTNNVPg7X92vds5AK7/XD+yxd+BkjY+sei1tArBaiewYk+Zsa74fEE/iRcnn9pv3nWKAd0Z6FKmNN7GoqOC7E7DXqlegZ5ndu9qYklfeTsjb44TaHFzAF3vOHJwQOGFqOVet4b1+EjMweRWVWAYv4sb3S48ktSjvge+x2F+A3wgHax4LnSG6JZuSXyW/lRYR/kHJuxYBfsWqSDOU+3ykGpcs2VXuJHVp58+VVVO1Ko8i09oCj+PLOwJyo2sm0Rn/TEHSMZv9YTnwzwBZO+s1G8TtZZaKgc3u11lmla/2fN+QWZ9ea+VpdDKklAwcrnKPsrXlk7Q/vFCoNtJq47mjQtj9JBpWR+Hmqd/sxwL90NRyY5cMe05NK5Sprsld9LYp3q2dHRL3sVNYv/YVfxgzsSuHWMbQ9x4DniNJfLOeTuMrdAPMq43sOdUsPnRNysZTC4yeBkm4ADqmylDJuwSbLHg5e4QGzGWN4I6qHUZZeZEWthqJyKsFp/eSNwoyQR4F6heIVGhk56noiq36ztZz62Xq7Yb1/889wCjfKuD75H+3PIn3SwTz73/DJ1uGbkHKVtS78Ni1/2waNctkB1ieoA3GHGz5xeCpTlE5yhhyg3s6R4HhHK5KxLxAw74zh38eXaau/PnRW67gug8LnHXAGoRQF0iD210mVUxegJOgyXPVOK+mvyfT7ne01DkH2A/gI48hmxDv7e/WdpklOxWGCIVEZs+IiVR+6fr/uh8/dDLxDtwR5aw3kG5m3BiRxvZlt9caJwtem+EtzVTohq7+FNbpLUWMS93Hn1Oi8c2U9iUbdsSs9FphoTEPGgvtI+YGlA1nXrMXFRxuf55LHYCFiepfHDFJSf2QH60= X-Microsoft-Exchange-Diagnostics: 1; MWHPR07MB3069; 31:hTBxMUalX67kg8BkhQJRYXgs9czS4EvaOBzDXRqtCEA0tj0Q8jTSI9xkSFT5vY+yjA+CuJ8bTDk/Pzrp3lZp1a4ZAVSZJTayedihtFuT1Bf8Q07GaAmZz0rh2kGFpyEfyOdnTgKoV5UZTZEgOPm+r3JqeNMVXxsrTEMi9255DHrmCNihGGYHHB9Re4zq1TX6IoLtaKAQxRjeWkdFHL2VNdrulCFGV5SuQlSxX80hmEuAsWA0w3eWI79YlLINkk0eDUUp302rU6Wz/0JukqZtyOewRIQbvQHTZ+fvFRUlnc8YvFbtBdGKdp8SRkAnP3upH5QsI8bsPxfG6k3imUkC0M3WNi3nsirVkCJz2LjG3iw80l4VlFkDwU4F/yj+apd22g7KFAw1np7a0mJcARCkP0qbZPmL3JmJjQ8dcCKGNYd8kP8qvXXICIupWghUoLUjhx+T+TNdQ5bKHMoTEE4omWHnObplR0xn6ad8kEX0ac6y25nogsMwCGawOj/OeErc6C6I7rO8csrN+8djk2sLCtWcV0igUUVTGTPxLYfAPz8pjRKzWVOX3fdamAJG0CeiUeiX2igwUTQvij+SAmmJM7246NBGaOdI48k0bOfcdYBqpkO0oOmkAU4pD7vCOB/m/Zgf+H+tjmHru4w66VmP4j2BjQ9/Q0vNC+m8d0aO9Ow= X-Microsoft-Exchange-Diagnostics: 1; MWHPR07MB3069; 20:3J9UivUuH5X8fMYi3B2ze97Hx65+i5xAgNGhm6nkJBpw+05XijlKAH5lnAmwI9Cdxu3B6NbCSClwVIgAT292qC7QgoANrNA/yOdHrfsibqZMYFgiNlYhyEGAch+werTdFrrz0WZcLH9ModEYU4FIbD9fXGNs0Qw5pCa6yp36ffpCT9nv9uNE7Ujanm0WuxpWlsqZouWV313ScsnfC9I7FCnZAJZKtfXeQKOY58Cwe1cVmEdHLEcPw/shPShBjbXbjj9qvGxN0UQEnRS9s5J67yPQq+2OkLH6poux+rzpHhyVl0ZJu3tizZza8eKsnVuCrqgbGfx28kzZjg1X9OFTSm5fOnJgs7Z2ph1vXpVfcxDWpRK4EOKGVX4gJJmjERQRI4Fu+QcKb3bsMAysQxMt3Nm1p3ndVd+/ksj+5OVBpRTgNPI01ISsAQ2BhsFFWiOP0FicGHcImI9kqO2TtmNJaEqjvmE/bdjyddC18d+oPp42sMPCc6sF9689/+MF1bTtLIv5OKPBEfLq1PQmvHUxzVGMEA6TXa9lyefywcUQh/y71OgLroqfvHJYqYX2jFTCbEU9+6N0MvS2hh/rmSGKPrhGawHArivBm2fNFh8RU2U= X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(236129657087228)(148574349560750)(158140799945019)(247924648384137); X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(100000700101)(100105000095)(100000701101)(100105300095)(100000702101)(100105100095)(6040450)(601004)(2401047)(8121501046)(5005006)(10201501046)(100000703101)(100105400095)(93006095)(3002001)(6041248)(201703131423075)(201702281528075)(201703061421075)(201703061406153)(20161123555025)(20161123558100)(20161123562025)(20161123560025)(20161123564025)(6072148)(100000704101)(100105200095)(100000705101)(100105500095); SRVR:MWHPR07MB3069; BCL:0; PCL:0; RULEID:(100000800101)(100110000095)(100000801101)(100110300095)(100000802101)(100110100095)(100000803101)(100110400095)(100000804101)(100110200095)(100000805101)(100110500095); SRVR:MWHPR07MB3069; X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; MWHPR07MB3069; 4:YAB4rlC+wS8seEZSuMiynsifBWbY1WtPO+L22LQqOM?= =?us-ascii?Q?F9atsUh2IAcxdLMml+qBSml5BYEwkuQFLZwGfK8cpTnaJmsEeo+kY+lz6Wz5?= =?us-ascii?Q?xk5vg9IzRyZ2e2lT1raiApgmTgtGgMbHjdVFkxUfMRMXmzeJpcAU0eB05vhE?= =?us-ascii?Q?QOjqb63zTL3Uu/kQbufKycF0gFQyxvt6mMkjkwc0Hhg5sjyHl0GT9nYxKIpG?= =?us-ascii?Q?hK1tvrS+S/36zc/d2OhwglJdaM4aE0D9Q8U9tJfXANX2uCt1f4+vP2vZ8GPX?= =?us-ascii?Q?Xr9nkq+E7i4ro9EO4p7EulR+bq2ZUeli7s9GAs0Ri0SqBYMkwZqFeO8LQstW?= =?us-ascii?Q?uUBr6QUJw1LvBlJ8ozdqv1PpGgNdduRTkiuzH+6s5NxQsiKBSsIDdjqCZ4DJ?= =?us-ascii?Q?1N0WKoEVBUpi7vHkBUA1ARrCiHHnLcd7ClS6vDhCGTdbenYp4p5wifJENyS2?= =?us-ascii?Q?Zh+znHZHkmOd5Eb+g5R0EPh/DSbMk4sZCNzHeHTUW48iJNCu4EDYP/OiAafN?= =?us-ascii?Q?19iNeOvcSYuuVf3rce3oFNzMyekDLB35c2gtqt+o6w6B3NQcXuJ0TPWfngLL?= =?us-ascii?Q?d+z+/UnIsTCj1GzKdgfobxiJt/iaHOfl5u8SppqwURuoxNMw0VmNt5CQB0gy?= =?us-ascii?Q?4n3EacdtXoy6ktAQce2YbPqFBOf29CLxiNq16UHHKsf6ZOGpYSF7qSh/ZlyN?= =?us-ascii?Q?y7/DXGIL+6S68qiJeo+QHAiDFQLrXf0Kz71ZZTkmZCsoiBuSHUX/DZWlrmsu?= =?us-ascii?Q?5uUt3aYEMDxRe8NSfRqpltkvNYIoRAGhMa5DE6ZPKJ0rR9LGoTsKIfg0qkoE?= =?us-ascii?Q?7wdHwWlvyYKOLgLTEaZIOjUWT+OQoR3eaqbLgceZKgRoqHd9JCPE7Il+A7G0?= =?us-ascii?Q?O6XSv2iCHYzM8Acw3cGQPlW4BOtM6aT3vP3vbwji7NTKRsqHV8LM2TLzIm4t?= =?us-ascii?Q?o/eqfaliGMCUi0s3B+OY/MZnE46nkF162HOAhYr3b2T1mUGQ7LpSQL+h0ogD?= =?us-ascii?Q?rI+IoNEYg9n9PUKhl7pz1DQ5tcSBqx5BqAff6p6vKuf7Vpm9hpUT3U6YYlBM?= =?us-ascii?Q?SCIiiewoLU+19ADoA/eIvLivEBmAhlMans93fR+e7s68yKkC7R6SMBkqTWZ7?= =?us-ascii?Q?z58PG2WN8zd2rgW25bjCiHW91O1J2EBNT4KNZLMuqC6i2d9JeiLNj7yr8OZ1?= =?us-ascii?Q?TO47WXJuPNHFao8cFSpfiqKjcGhOa0EacK1VNVnDkzNXb2yHqzCY+0Ceu4Mj?= =?us-ascii?Q?HOxc2ubk5H5XvVF83gmTo+tlDZydgdexG49kg7?= X-Forefront-PRVS: 0358535363 X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(4630300001)(6009001)(39450400003)(39410400002)(39840400002)(39400400002)(39850400002)(33646002)(1076002)(50226002)(2906002)(53936002)(8676002)(6506006)(5660300001)(81166006)(76176999)(50986999)(3846002)(50466002)(189998001)(6512007)(107886003)(38730400002)(7736002)(110136004)(5003940100001)(6116002)(53416004)(47776003)(305945005)(4326008)(6486002)(42186005)(36756003)(575784001)(25786009)(66066001)(72206003)(2950100002)(478600001)(6666003)(42882006); DIR:OUT; SFP:1101; SCL:1; SRVR:MWHPR07MB3069; H:1scrb-1.caveonetworks.com; FPR:; SPF:None; MLV:sfv; LANG:en; X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; MWHPR07MB3069; 23:3Q5nRoYHdAphnDLdz+xKAo8q7Ff4Bkg7XE1OiGuk9?= =?us-ascii?Q?ohlZQu1ovnPQwaVrupsfeYgPOu2RgdLWx679DdpV0W92yqkPQCrfEWG2XHXs?= =?us-ascii?Q?v/D2GpVIG1IIC/f6/C6QfztAMQpWIrllOALJmq1gChtoXPd8WHFnd+W1EiT8?= =?us-ascii?Q?p0YfB6sEXUS0wrtYk7Jc7GUsi59cApZV7ExsErEdrMR+OGTJhK8rXrxTSHKp?= =?us-ascii?Q?mJGEn3Kh4NPvYEmd08gqU7e6Oz1v5XC/PJzSbQ7wOCkTAoXB+qpQjUmHNHnc?= =?us-ascii?Q?3FpfSKmzgOk5ABsc+cRNcZ8LxxWwg0U7cENbfKTvJKSTT9Xgksz7UIUCuW+f?= =?us-ascii?Q?J9YVexedyaTMozdkIOjXnz+xAHSoVD0ul1A0F7Sfn3sJlQSkuNapwpkWjtFA?= =?us-ascii?Q?5ZcZRI7I1zjRstzq8U1i1RTWhznYEwxTPBzBVNqm7BzY34KEClb3R3M9LfYc?= =?us-ascii?Q?+ziUXM6gEZWpT4/Q3kDJPU+e+Z3Ejmk7jdHRDQglnBBzOfkF+va6MUcw2+Vh?= =?us-ascii?Q?4JIyjLaVDlTUFjOOeDaJ1M1ugrKSMoPxDLOixzi3OPxfu7/i1yFVDgEfv45n?= =?us-ascii?Q?kItK9LqJ1OQTkKWTtmw313A8agdVQLcvVOJ2kFbXBgFx5aehaf/dXRLblbDR?= =?us-ascii?Q?cTObfnsy6llyxtEsNEn+8cykVbdg/D1jp5GZIpSzw53gkqGTE8Op8bTL5d2N?= =?us-ascii?Q?CkEe2zpICkM8y6G1o7EZV3azOa32hNcr0Lg+Tp6EvQlm714XkUsDmN41XTWR?= =?us-ascii?Q?4msmmaNfSt3UE06DPX7pOf+WrsBrDZFdsy+Ud4bszw8mbTUzyikxcBP6TOeb?= =?us-ascii?Q?+ZifsIrL0Y3nhnwqJReEQ1PA5FY2EAJQADoR3Oz7dA0ADy7vYKf+Rg8IC3QW?= =?us-ascii?Q?01KR5Cj7p4OCaQX1l7YHv5ewP6JLy5ViWb+VDRSuoJG3gpF+N2PPYNJcGPCm?= =?us-ascii?Q?AT1/DgOFe5xWLJTIS8jGj07FCGScQR7IpJ1YTBFrbMk5t6bM3WAn7iNOKAEZ?= =?us-ascii?Q?twTdxXv+5tn/2jKe9tw3dBqhQHncy+4LJxvVyTTdSVGhHNczol+WXO0HngIC?= =?us-ascii?Q?fuP1xWm/6PfMiL1h9WarIh+MpDsmhq/imjBdSCWf7Q/yRFD2w=3D=3D?= X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; MWHPR07MB3069; 6:o2hm7V/gvm0m7pnF1TNm0nvTB7XZG/N6GAP602Kv69?= =?us-ascii?Q?p/y+ygXWeaGc0xDo2IJQ2Z4ada/CpdaBkdPdwEyWd8TVtV6lY8U3IUC6ah1R?= =?us-ascii?Q?3xEOo2eqgLkEdyu8wBiQw1bN9xxIqat1ClIgydEdfIaQmx3zRo5dNteXRAdp?= =?us-ascii?Q?19a89UoL7m3ASBKs+Vj+IGv73UsecHMtl0wPas7JnooxKEzDqNi7RuWjcLzt?= =?us-ascii?Q?mMEaLl7icyvULR3ZzBqHs6z597sfEUfR7YpSXvF/DV74vtcENEj/2Hd1HPtK?= =?us-ascii?Q?6P2o6Xxb7jzDuQBrJ9hwuVtOZpRfdUMk79Okw9mx5tM6nadmMS37Ug0vyCsf?= =?us-ascii?Q?mOyiyhWZ6IQBWs/YMNWXFtUDYxjms2UtCaSggX+h8z2+clP07gDd+p38dlxa?= =?us-ascii?Q?vCg0aFiR2h+MZJUgFBHjsGb6cpngrFIgtXzOH6bqltGO8KckmljUZm++uDY9?= =?us-ascii?Q?ZD6b1ZvN8v3RenLz3iNa6OKJGveJePsoThaXMPRZMY2LpHRXKnd8hqcI6cSq?= =?us-ascii?Q?vi2GoztwXXduOmwusvaPJyz/bGVyhkCQje96jsmKzp4b+8bBa1u3SbypSb3s?= =?us-ascii?Q?nS4xJ797ZVetZHLpsrnvmioYPvAMtBa1+sodIvD20iCUio0GZag3wYOYzBUc?= =?us-ascii?Q?OpxTOMxlaYJmA1qiphL88jKE2g8YOknKs7uVFKELfBzLoKmi1GyoHq542Mau?= =?us-ascii?Q?MnCdc4oSLHPufjM9RQ64olw29glPJBqYe0HCwg3xqVUn7bWzOAb+oAmca4vf?= =?us-ascii?Q?NI57h2FQF8RC5iTg76RFLxKz6816UE7Mz1KZjhvwVsdYxtxHMu0P7owdLSip?= =?us-ascii?Q?4BE808cbMKkoKb43ucI/cmxniIEv4K60TA7JFw1R0xlVz6BeLooX9zMN7o13?= =?us-ascii?Q?7RPCszsxFTW8491ES54fZBXrY7W52RyW8ALCSV/lqDv31oV5ns07S9L4GCBG?= =?us-ascii?Q?D/vrxm/yZkjElz3Vr6ogw65nQEdOZZ6/PunV/vdu5W9kDQONJ8R9hPOtKjZe?= =?us-ascii?Q?g=3D?= X-Microsoft-Exchange-Diagnostics: 1; MWHPR07MB3069; 5:nTMuxWYWARlAYYvIZQxJNzKXLXy2MWFU6/HlMM2z4fB45qGCMBNQhnX0hCxmjB71MjXwk2fQWqWj9i2IffB1gkj/al1pZ8pvnVbWIkVXfR21tzeWZ368CTpaFoDKMTDoEsV2pxC+zZHhQBXu4pU1VWyODSeb22pcDm7VZl82t6CBelZglzToKfoiJ5+wch8dGUbkhhjJ1v2vfoOKpZsJcD52/KUQF3duSyV8gFv+/eG9NfW8sIGESvr5H+R2OVMzVdPAr1hczqGfas7zNlxdFlGd/Y6i0wRPRM5xC/vJZGeboU08bggJJKQy7R/XIPMz5zjZlARJLOGnVgUAwrvEm0CpvsDYKCKHVvTzOKe/DcImS8rV7v1QwLZo133iiUPd1m5gLmUkzZ3dMeG2rlmstJI4xDu8jn5zJ+T3GEQF5cU+LI3ruzSB4aRByF1osxVl/Uw8IwEJ9sGjGhsT0jhtInLLHwBsGxJCH+XsZbAFwku69QqjUsuRCesl+EIkWapS; 24:sLQY9482HS6fobaCftvlDzzqm8lBzpgHCyQbdZATcc4FUjAz38BawnmBOjZzLFN48sQEhIPwm6I1ZMlCXtY37epxV//iiYo7BCrXqoC70a0= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; MWHPR07MB3069; 7:duCY/CHxdX7/KV0zZgKuytsRTmUp7nXZgYRMXGArgDpbAy/94C5OTtIxMvxlpScyn6Hqfwy271ZL+qllyQSVkoUgwB2/B7DLXRt+786K8lsq9HEW3vGHe4YrzgFQJs0N5nb1R5hX4Tru/Ki+RMCWeu+bVn2hNoaKM7UuSsughq8fhrHnkOqCizeKJ+bH3CAjdHr0WVgnUdbnOzyhmCFbPiMX7w+tZ4rmi7r5LRfTf6XaQvWJKrdYqPMktRtFTcnE6LX9A2w7mHScFjenebuUn4ydJsdrp8TRYdLgfzHAwPcR8YZfH1wp8+VxVTwb2DQ+ei7mSbfZdIe+CyiKdTzbTSH1blRphIlP3OSIpKqpNpU1pzaJsKPgOVH411I2lMyFf74LVNRs2dhTZkYiKRvex2RsbJBDZUHhhMBN1oI4hqwXkz/9axtVdZj9mekzvuC6iohXGO/oA8Qz3Vwckz0Y1KT0RDg01CdSQv6PIyW0ztHG5vu0RQWKvGiKObJNCQtAxnOtWGiI4ATbdKrQYU/aMSk4WZdNitHj0rdZS2SRysxjWlBpgVU2icaonCYNrIelTU0YWabqwKp0mkjDz9iKhnj45C8QyzTTmnth+ILbF5MgHoD8ARpw3dLfCUved34VJuaQtdCE5FJo2zl1mhuZ9WiarbuQFTmEew6MnZp4zhut7d0tobKYsclHDXq+R2QOhhJEMARtaYkEHI6JtfI9L/4NsJEqvEuUGGSzOoTH19G6lps+wO0Oc0kZm/Z/mIztJwuZwVrj3bEHTTrkmySTVSicHyz+XCwJFzV1VX7+MJQ= X-OriginatorOrg: caviumnetworks.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 04 Jul 2017 09:24:18.2364 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-Transport-CrossTenantHeadersStamped: MWHPR07MB3069 Subject: [dpdk-dev] [PATCH v6 3/4] net: add arm64 neon version of CRC compute APIs X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 04 Jul 2017 09:24:20 -0000 Added CRC compute APIs for arm64 utilizing the pmull capability. Added new file net_crc_neon.h to hold the arm64 pmull CRC implementation. Added wrappers in rte_vect.h for those neon intrinsics which are not supported in GCC version < 7. Verified the changes with crc_autotest unit test case Signed-off-by: Ashwin Sekhar T K Acked-by: Jianbo Liu --- MAINTAINERS | 1 + lib/librte_eal/common/include/arch/arm/rte_vect.h | 88 +++++++ lib/librte_net/net_crc_neon.h | 297 ++++++++++++++++++++++ lib/librte_net/rte_net_crc.c | 34 ++- lib/librte_net/rte_net_crc.h | 2 + 5 files changed, 416 insertions(+), 6 deletions(-) create mode 100644 lib/librte_net/net_crc_neon.h diff --git a/MAINTAINERS b/MAINTAINERS index c14cbb90f..33921f721 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -149,6 +149,7 @@ F: lib/librte_lpm/rte_lpm_neon.h F: lib/librte_hash/rte*_arm64.h F: lib/librte_efd/rte*_arm64.h F: lib/librte_table/rte*_arm64.h +F: lib/librte_net/net_crc_neon.h F: drivers/net/ixgbe/ixgbe_rxtx_vec_neon.c F: drivers/net/i40e/i40e_rxtx_vec_neon.c F: drivers/net/virtio/virtio_rxtx_simple_neon.c diff --git a/lib/librte_eal/common/include/arch/arm/rte_vect.h b/lib/librte_eal/common/include/arch/arm/rte_vect.h index 4107c9988..55e228a77 100644 --- a/lib/librte_eal/common/include/arch/arm/rte_vect.h +++ b/lib/librte_eal/common/include/arch/arm/rte_vect.h @@ -35,6 +35,7 @@ #include #include "generic/rte_vect.h" +#include "rte_debug.h" #include "arm_neon.h" #ifdef __cplusplus @@ -78,6 +79,93 @@ vqtbl1q_u8(uint8x16_t a, uint8x16_t b) } #endif +#if defined(RTE_ARCH_ARM64) +#if defined(RTE_TOOLCHAIN_GCC) && (GCC_VERSION < 70000) +/* NEON intrinsic vreinterpretq_u64_p128() is supported since GCC version 7 */ +static inline uint64x2_t +vreinterpretq_u64_p128(poly128_t x) +{ + return (uint64x2_t)x; +} + +/* NEON intrinsic vreinterpretq_p64_u64() is supported since GCC version 7 */ +static inline poly64x2_t +vreinterpretq_p64_u64(uint64x2_t x) +{ + return (poly64x2_t)x; +} + +/* NEON intrinsic vgetq_lane_p64() is supported since GCC version 7 */ +static inline poly64_t +vgetq_lane_p64(poly64x2_t x, const int lane) +{ + RTE_ASSERT(lane >= 0 && lane <= 1); + + poly64_t *p = (poly64_t *)&x; + + return p[lane]; +} +#endif +#endif + +/* + * If (0 <= index <= 15), then call the ASIMD ext intruction on the + * 128 bit regs v0 and v1 with the appropriate index. + * + * Else returns a zero vector. + */ +static inline uint8x16_t +vextract(uint8x16_t v0, uint8x16_t v1, const int index) +{ + switch (index) { + case 0: return vextq_u8(v0, v1, 0); + case 1: return vextq_u8(v0, v1, 1); + case 2: return vextq_u8(v0, v1, 2); + case 3: return vextq_u8(v0, v1, 3); + case 4: return vextq_u8(v0, v1, 4); + case 5: return vextq_u8(v0, v1, 5); + case 6: return vextq_u8(v0, v1, 6); + case 7: return vextq_u8(v0, v1, 7); + case 8: return vextq_u8(v0, v1, 8); + case 9: return vextq_u8(v0, v1, 9); + case 10: return vextq_u8(v0, v1, 10); + case 11: return vextq_u8(v0, v1, 11); + case 12: return vextq_u8(v0, v1, 12); + case 13: return vextq_u8(v0, v1, 13); + case 14: return vextq_u8(v0, v1, 14); + case 15: return vextq_u8(v0, v1, 15); + } + return vdupq_n_u8(0); +} + +/** + * Shifts right 128 bit register by specified number of bytes + * + * Value of shift parameter must be in range 0 - 16 + */ +static inline uint64x2_t +vshift_bytes_right(uint64x2_t reg, const unsigned int shift) +{ + return vreinterpretq_u64_u8(vextract( + vreinterpretq_u8_u64(reg), + vdupq_n_u8(0), + shift)); +} + +/** + * Shifts left 128 bit register by specified number of bytes + * + * Value of shift parameter must be in range 0 - 16 + */ +static inline uint64x2_t +vshift_bytes_left(uint64x2_t reg, const unsigned int shift) +{ + return vreinterpretq_u64_u8(vextract( + vdupq_n_u8(0), + vreinterpretq_u8_u64(reg), + 16 - shift)); +} + #ifdef __cplusplus } #endif diff --git a/lib/librte_net/net_crc_neon.h b/lib/librte_net/net_crc_neon.h new file mode 100644 index 000000000..2be579d6b --- /dev/null +++ b/lib/librte_net/net_crc_neon.h @@ -0,0 +1,297 @@ +/* + * BSD LICENSE + * + * Copyright (C) Cavium networks Ltd. 2017. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Cavium networks nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _NET_CRC_NEON_H_ +#define _NET_CRC_NEON_H_ + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** PMULL CRC computation context structure */ +struct crc_pmull_ctx { + uint64x2_t rk1_rk2; + uint64x2_t rk5_rk6; + uint64x2_t rk7_rk8; +}; + +struct crc_pmull_ctx crc32_eth_pmull __rte_aligned(16); +struct crc_pmull_ctx crc16_ccitt_pmull __rte_aligned(16); + +/** + * @brief Performs one folding round + * + * Logically function operates as follows: + * DATA = READ_NEXT_16BYTES(); + * F1 = LSB8(FOLD) + * F2 = MSB8(FOLD) + * T1 = CLMUL(F1, RK1) + * T2 = CLMUL(F2, RK2) + * FOLD = XOR(T1, T2, DATA) + * + * @param data_block 16 byte data block + * @param precomp precomputed rk1 constanst + * @param fold running 16 byte folded data + * + * @return New 16 byte folded data + */ +static inline uint64x2_t +crcr32_folding_round(uint64x2_t data_block, uint64x2_t precomp, + uint64x2_t fold) +{ + uint64x2_t tmp0 = vreinterpretq_u64_p128(vmull_p64( + vgetq_lane_p64(vreinterpretq_p64_u64(fold), 1), + vgetq_lane_p64(vreinterpretq_p64_u64(precomp), 0))); + + uint64x2_t tmp1 = vreinterpretq_u64_p128(vmull_p64( + vgetq_lane_p64(vreinterpretq_p64_u64(fold), 0), + vgetq_lane_p64(vreinterpretq_p64_u64(precomp), 1))); + + return veorq_u64(tmp1, veorq_u64(data_block, tmp0)); +} + +/** + * Performs reduction from 128 bits to 64 bits + * + * @param data128 128 bits data to be reduced + * @param precomp rk5 and rk6 precomputed constants + * + * @return data reduced to 64 bits + */ +static inline uint64x2_t +crcr32_reduce_128_to_64(uint64x2_t data128, + uint64x2_t precomp) +{ + uint64x2_t tmp0, tmp1, tmp2; + + /* 64b fold */ + tmp0 = vreinterpretq_u64_p128(vmull_p64( + vgetq_lane_p64(vreinterpretq_p64_u64(data128), 0), + vgetq_lane_p64(vreinterpretq_p64_u64(precomp), 0))); + tmp1 = vshift_bytes_right(data128, 8); + tmp0 = veorq_u64(tmp0, tmp1); + + /* 32b fold */ + tmp2 = vshift_bytes_left(tmp0, 4); + tmp1 = vreinterpretq_u64_p128(vmull_p64( + vgetq_lane_p64(vreinterpretq_p64_u64(tmp2), 0), + vgetq_lane_p64(vreinterpretq_p64_u64(precomp), 1))); + + return veorq_u64(tmp1, tmp0); +} + +/** + * Performs Barret's reduction from 64 bits to 32 bits + * + * @param data64 64 bits data to be reduced + * @param precomp rk7 precomputed constant + * + * @return data reduced to 32 bits + */ +static inline uint32_t +crcr32_reduce_64_to_32(uint64x2_t data64, + uint64x2_t precomp) +{ + static uint32_t mask1[4] __rte_aligned(16) = { + 0xffffffff, 0xffffffff, 0x00000000, 0x00000000 + }; + static uint32_t mask2[4] __rte_aligned(16) = { + 0x00000000, 0xffffffff, 0xffffffff, 0xffffffff + }; + uint64x2_t tmp0, tmp1, tmp2; + + tmp0 = vandq_u64(data64, vld1q_u64((uint64_t *)mask2)); + + tmp1 = vreinterpretq_u64_p128(vmull_p64( + vgetq_lane_p64(vreinterpretq_p64_u64(tmp0), 0), + vgetq_lane_p64(vreinterpretq_p64_u64(precomp), 0))); + tmp1 = veorq_u64(tmp1, tmp0); + tmp1 = vandq_u64(tmp1, vld1q_u64((uint64_t *)mask1)); + + tmp2 = vreinterpretq_u64_p128(vmull_p64( + vgetq_lane_p64(vreinterpretq_p64_u64(tmp1), 0), + vgetq_lane_p64(vreinterpretq_p64_u64(precomp), 1))); + tmp2 = veorq_u64(tmp2, tmp1); + tmp2 = veorq_u64(tmp2, tmp0); + + return vgetq_lane_u32(vreinterpretq_u32_u64(tmp2), 2); +} + +static inline uint32_t +crc32_eth_calc_pmull( + const uint8_t *data, + uint32_t data_len, + uint32_t crc, + const struct crc_pmull_ctx *params) +{ + uint64x2_t temp, fold, k; + uint32_t n; + + /* Get CRC init value */ + temp = vreinterpretq_u64_u32(vsetq_lane_u32(crc, vmovq_n_u32(0), 0)); + + /** + * Folding all data into single 16 byte data block + * Assumes: fold holds first 16 bytes of data + */ + if (unlikely(data_len < 32)) { + if (unlikely(data_len == 16)) { + /* 16 bytes */ + fold = vld1q_u64((const uint64_t *)data); + fold = veorq_u64(fold, temp); + goto reduction_128_64; + } + + if (unlikely(data_len < 16)) { + /* 0 to 15 bytes */ + uint8_t buffer[16] __rte_aligned(16); + + memset(buffer, 0, sizeof(buffer)); + memcpy(buffer, data, data_len); + + fold = vld1q_u64((uint64_t *)buffer); + fold = veorq_u64(fold, temp); + if (unlikely(data_len < 4)) { + fold = vshift_bytes_left(fold, 8 - data_len); + goto barret_reduction; + } + fold = vshift_bytes_left(fold, 16 - data_len); + goto reduction_128_64; + } + /* 17 to 31 bytes */ + fold = vld1q_u64((const uint64_t *)data); + fold = veorq_u64(fold, temp); + n = 16; + k = params->rk1_rk2; + goto partial_bytes; + } + + /** At least 32 bytes in the buffer */ + /** Apply CRC initial value */ + fold = vld1q_u64((const uint64_t *)data); + fold = veorq_u64(fold, temp); + + /** Main folding loop - the last 16 bytes is processed separately */ + k = params->rk1_rk2; + for (n = 16; (n + 16) <= data_len; n += 16) { + temp = vld1q_u64((const uint64_t *)&data[n]); + fold = crcr32_folding_round(temp, k, fold); + } + +partial_bytes: + if (likely(n < data_len)) { + uint64x2_t last16, a, b, mask; + uint32_t rem = data_len & 15; + + last16 = vld1q_u64((const uint64_t *)&data[data_len - 16]); + a = vshift_bytes_left(fold, 16 - rem); + b = vshift_bytes_right(fold, rem); + mask = vshift_bytes_left(vdupq_n_u64(-1), 16 - rem); + b = vorrq_u64(b, vandq_u64(mask, last16)); + + /* k = rk1 & rk2 */ + temp = vreinterpretq_u64_p128(vmull_p64( + vgetq_lane_p64(vreinterpretq_p64_u64(a), 1), + vgetq_lane_p64(vreinterpretq_p64_u64(k), 0))); + fold = vreinterpretq_u64_p128(vmull_p64( + vgetq_lane_p64(vreinterpretq_p64_u64(a), 0), + vgetq_lane_p64(vreinterpretq_p64_u64(k), 1))); + fold = veorq_u64(fold, temp); + fold = veorq_u64(fold, b); + } + + /** Reduction 128 -> 32 Assumes: fold holds 128bit folded data */ +reduction_128_64: + k = params->rk5_rk6; + fold = crcr32_reduce_128_to_64(fold, k); + +barret_reduction: + k = params->rk7_rk8; + n = crcr32_reduce_64_to_32(fold, k); + + return n; +} + +static inline void +rte_net_crc_neon_init(void) +{ + /* Initialize CRC16 data */ + uint64_t ccitt_k1_k2[2] = {0x189aeLLU, 0x8e10LLU}; + uint64_t ccitt_k5_k6[2] = {0x189aeLLU, 0x114aaLLU}; + uint64_t ccitt_k7_k8[2] = {0x11c581910LLU, 0x10811LLU}; + + /* Initialize CRC32 data */ + uint64_t eth_k1_k2[2] = {0xccaa009eLLU, 0x1751997d0LLU}; + uint64_t eth_k5_k6[2] = {0xccaa009eLLU, 0x163cd6124LLU}; + uint64_t eth_k7_k8[2] = {0x1f7011640LLU, 0x1db710641LLU}; + + /** Save the params in context structure */ + crc16_ccitt_pmull.rk1_rk2 = vld1q_u64(ccitt_k1_k2); + crc16_ccitt_pmull.rk5_rk6 = vld1q_u64(ccitt_k5_k6); + crc16_ccitt_pmull.rk7_rk8 = vld1q_u64(ccitt_k7_k8); + + /** Save the params in context structure */ + crc32_eth_pmull.rk1_rk2 = vld1q_u64(eth_k1_k2); + crc32_eth_pmull.rk5_rk6 = vld1q_u64(eth_k5_k6); + crc32_eth_pmull.rk7_rk8 = vld1q_u64(eth_k7_k8); +} + +static inline uint32_t +rte_crc16_ccitt_neon_handler(const uint8_t *data, + uint32_t data_len) +{ + return (uint16_t)~crc32_eth_calc_pmull(data, + data_len, + 0xffff, + &crc16_ccitt_pmull); +} + +static inline uint32_t +rte_crc32_eth_neon_handler(const uint8_t *data, + uint32_t data_len) +{ + return ~crc32_eth_calc_pmull(data, + data_len, + 0xffffffffUL, + &crc32_eth_pmull); +} + +#ifdef __cplusplus +} +#endif + +#endif /* _NET_CRC_NEON_H_ */ diff --git a/lib/librte_net/rte_net_crc.c b/lib/librte_net/rte_net_crc.c index 0391c7209..331737abe 100644 --- a/lib/librte_net/rte_net_crc.c +++ b/lib/librte_net/rte_net_crc.c @@ -43,10 +43,16 @@ && defined(RTE_MACHINE_CPUFLAG_SSE4_2) \ && defined(RTE_MACHINE_CPUFLAG_PCLMULQDQ) #define X86_64_SSE42_PCLMULQDQ 1 +#elif defined(RTE_ARCH_ARM64) +#if defined(RTE_MACHINE_CPUFLAG_PMULL) +#define ARM64_NEON_PMULL 1 +#endif #endif #ifdef X86_64_SSE42_PCLMULQDQ #include +#elif defined(ARM64_NEON_PMULL) +#include #endif /* crc tables */ @@ -74,6 +80,11 @@ static rte_net_crc_handler handlers_sse42[] = { [RTE_NET_CRC16_CCITT] = rte_crc16_ccitt_sse42_handler, [RTE_NET_CRC32_ETH] = rte_crc32_eth_sse42_handler, }; +#elif defined(ARM64_NEON_PMULL) +static rte_net_crc_handler handlers_neon[] = { + [RTE_NET_CRC16_CCITT] = rte_crc16_ccitt_neon_handler, + [RTE_NET_CRC32_ETH] = rte_crc32_eth_neon_handler, +}; #endif /** @@ -162,14 +173,20 @@ void rte_net_crc_set_alg(enum rte_net_crc_alg alg) { switch (alg) { - case RTE_NET_CRC_SSE42: #ifdef X86_64_SSE42_PCLMULQDQ + case RTE_NET_CRC_SSE42: handlers = handlers_sse42; -#else - alg = RTE_NET_CRC_SCALAR; -#endif break; +#elif defined(ARM64_NEON_PMULL) + case RTE_NET_CRC_NEON: + if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_PMULL)) { + handlers = handlers_neon; + break; + } + /* fall-through */ +#endif case RTE_NET_CRC_SCALAR: + /* fall-through */ default: handlers = handlers_scalar; break; @@ -199,8 +216,13 @@ rte_net_crc_init(void) rte_net_crc_scalar_init(); #ifdef X86_64_SSE42_PCLMULQDQ - alg = RTE_NET_CRC_SSE42; - rte_net_crc_sse42_init(); + alg = RTE_NET_CRC_SSE42; + rte_net_crc_sse42_init(); +#elif defined(ARM64_NEON_PMULL) + if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_PMULL)) { + alg = RTE_NET_CRC_NEON; + rte_net_crc_neon_init(); + } #endif rte_net_crc_set_alg(alg); diff --git a/lib/librte_net/rte_net_crc.h b/lib/librte_net/rte_net_crc.h index d22286c6e..d01cf4b47 100644 --- a/lib/librte_net/rte_net_crc.h +++ b/lib/librte_net/rte_net_crc.h @@ -57,6 +57,7 @@ enum rte_net_crc_type { enum rte_net_crc_alg { RTE_NET_CRC_SCALAR = 0, RTE_NET_CRC_SSE42, + RTE_NET_CRC_NEON, }; /** @@ -68,6 +69,7 @@ enum rte_net_crc_alg { * This parameter is used to select the CRC implementation version. * - RTE_NET_CRC_SCALAR * - RTE_NET_CRC_SSE42 (Use 64-bit SSE4.2 intrinsic) + * - RTE_NET_CRC_NEON (Use ARM Neon intrinsic) */ void rte_net_crc_set_alg(enum rte_net_crc_alg alg); -- 2.12.2