Patch Detail
get:
Show a patch.
patch:
Update a patch.
put:
Update a patch.
GET /api/patches/120778/?format=api
{ "id": 120778, "url": "https://patches.dpdk.org/api/patches/120778/?format=api", "web_url": "https://patches.dpdk.org/project/dpdk/patch/20221212172108.17993-4-syalavarthi@marvell.com/", "project": { "id": 1, "url": "https://patches.dpdk.org/api/projects/1/?format=api", "name": "DPDK", "link_name": "dpdk", "list_id": "dev.dpdk.org", "list_email": "dev@dpdk.org", "web_url": "http://core.dpdk.org", "scm_url": "git://dpdk.org/dpdk", "webscm_url": "http://git.dpdk.org/dpdk", "list_archive_url": "https://inbox.dpdk.org/dev", "list_archive_url_format": "https://inbox.dpdk.org/dev/{}", "commit_url_format": "" }, "msgid": "<20221212172108.17993-4-syalavarthi@marvell.com>", "list_archive_url": "https://inbox.dpdk.org/dev/20221212172108.17993-4-syalavarthi@marvell.com", "date": "2022-12-12T17:21:07", "name": "[v2,3/4] common/ml: add scalar type conversion functions", "commit_ref": null, "pull_url": null, "state": "superseded", "archived": true, "hash": "3e437b3a58d042e5f322081cff9a56d1054ab4f2", "submitter": { "id": 2480, "url": "https://patches.dpdk.org/api/people/2480/?format=api", "name": "Srikanth Yalavarthi", "email": "syalavarthi@marvell.com" }, "delegate": { "id": 1, "url": "https://patches.dpdk.org/api/users/1/?format=api", "username": "tmonjalo", "first_name": "Thomas", "last_name": "Monjalon", "email": "thomas@monjalon.net" }, "mbox": "https://patches.dpdk.org/project/dpdk/patch/20221212172108.17993-4-syalavarthi@marvell.com/mbox/", "series": [ { "id": 26089, "url": "https://patches.dpdk.org/api/series/26089/?format=api", "web_url": "https://patches.dpdk.org/project/dpdk/list/?series=26089", "date": "2022-12-12T17:21:06", "name": "[v2,1/4] common/ml: add initial files for ML common code", "version": 2, "mbox": "https://patches.dpdk.org/series/26089/mbox/" } ], "comments": "https://patches.dpdk.org/api/patches/120778/comments/", "check": "success", "checks": "https://patches.dpdk.org/api/patches/120778/checks/", "tags": {}, "related": [], "headers": { "Return-Path": "<dev-bounces@dpdk.org>", "X-Original-To": "patchwork@inbox.dpdk.org", "Delivered-To": "patchwork@inbox.dpdk.org", "Received": [ "from mails.dpdk.org (mails.dpdk.org [217.70.189.124])\n\tby inbox.dpdk.org (Postfix) with ESMTP id CE8A0A034C;\n\tMon, 12 Dec 2022 18:21:35 +0100 (CET)", "from mails.dpdk.org (localhost [127.0.0.1])\n\tby mails.dpdk.org (Postfix) with ESMTP id 4DDDE42D1F;\n\tMon, 12 Dec 2022 18:21:21 +0100 (CET)", "from mx0b-0016f401.pphosted.com (mx0a-0016f401.pphosted.com\n [67.231.148.174])\n by mails.dpdk.org (Postfix) with ESMTP id 9AB5E4113F\n for <dev@dpdk.org>; Mon, 12 Dec 2022 18:21:17 +0100 (CET)", "from pps.filterd (m0045849.ppops.net [127.0.0.1])\n by mx0a-0016f401.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id\n 2BCFno29031301 for <dev@dpdk.org>; Mon, 12 Dec 2022 09:21:16 -0800", "from dc5-exch01.marvell.com ([199.233.59.181])\n by mx0a-0016f401.pphosted.com (PPS) with ESMTPS id 3mcrbveqpp-2\n (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT)\n for <dev@dpdk.org>; Mon, 12 Dec 2022 09:21:16 -0800", "from DC5-EXCH02.marvell.com (10.69.176.39) by DC5-EXCH01.marvell.com\n (10.69.176.38) with Microsoft SMTP Server (TLS) id 15.0.1497.42;\n Mon, 12 Dec 2022 09:21:14 -0800", "from maili.marvell.com (10.69.176.80) by DC5-EXCH02.marvell.com\n (10.69.176.39) with Microsoft SMTP Server id 15.0.1497.42 via Frontend\n Transport; Mon, 12 Dec 2022 09:21:14 -0800", "from ml-host-33.caveonetworks.com (unknown [10.110.143.233])\n by maili.marvell.com (Postfix) with ESMTP id BABC03F7077;\n Mon, 12 Dec 2022 09:21:14 -0800 (PST)" ], "DKIM-Signature": "v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com;\n h=from : to : cc :\n subject : date : message-id : in-reply-to : references : mime-version :\n content-type; s=pfpt0220; bh=/4//3Kjg32xEy97z94FtXBP8D4pjF0wC1Hh3xEIaPnw=;\n b=WPKALFlyuXHCODTgik/x/fMcVnvn2/sUqy3KudaanwPMPodPkQnip2/DUIpFVJW4dp6i\n V6igWIMJKHI/U9nqKElq09a+sTa25wyb7QHBGPXMTBtQ/5TVeq/xTeG+3clFOT8otEZA\n sqJ8yPAMxg563nuUpamgG77VuV0zRAyLdCE1oDzk3PvBXQsi3E52bPN8e6XDc9DMt2vK\n MnYgWG+wtasZ5kSGAFnMS4gzKvLeyQbf1htxDDuUMJgShunaTD5DlI0lwQqqDermZEw0\n LpWpaeGjLx/s/B/n3TYYRiY3630a2scGjZjDOdKHBf6kHYPp0bX9ywemjBetwEo+tsQk 9g==", "From": "Srikanth Yalavarthi <syalavarthi@marvell.com>", "To": "Srikanth Yalavarthi <syalavarthi@marvell.com>", "CC": "<dev@dpdk.org>, <sshankarnara@marvell.com>, <jerinj@marvell.com>,\n <aprabhu@marvell.com>", "Subject": "[PATCH v2 3/4] common/ml: add scalar type conversion functions", "Date": "Mon, 12 Dec 2022 09:21:07 -0800", "Message-ID": "<20221212172108.17993-4-syalavarthi@marvell.com>", "X-Mailer": "git-send-email 2.17.1", "In-Reply-To": "<20221212172108.17993-1-syalavarthi@marvell.com>", "References": "<20221208193532.16718-1-syalavarthi@marvell.com>\n <20221212172108.17993-1-syalavarthi@marvell.com>", "MIME-Version": "1.0", "Content-Type": "text/plain", "X-Proofpoint-GUID": "RS8ZBiZxZAQF_Zm9nwDRt14DVUWCmSB8", "X-Proofpoint-ORIG-GUID": "RS8ZBiZxZAQF_Zm9nwDRt14DVUWCmSB8", "X-Proofpoint-Virus-Version": "vendor=baseguard\n engine=ICAP:2.0.205,Aquarius:18.0.923,Hydra:6.0.545,FMLib:17.11.122.1\n definitions=2022-12-12_02,2022-12-12_02,2022-06-22_01", "X-BeenThere": "dev@dpdk.org", "X-Mailman-Version": "2.1.29", "Precedence": "list", "List-Id": "DPDK patches and discussions <dev.dpdk.org>", "List-Unsubscribe": "<https://mails.dpdk.org/options/dev>,\n <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>,\n <mailto:dev-request@dpdk.org?subject=subscribe>", "Errors-To": "dev-bounces@dpdk.org" }, "content": "Added scalar implementations to support conversion of data types.\nSupport is enabled to handle int8, uint8, int16, uint16, float16,\nfloat32 and bfloat16 types.\n\nSigned-off-by: Srikanth Yalavarthi <syalavarthi@marvell.com>\n---\nv2:\n* Updated internal function names\n* Updated function attributes to __rte_weak\n\n drivers/common/ml/meson.build | 1 +\n drivers/common/ml/ml_utils_scalar.c | 720 ++++++++++++++++++++++++++++\n drivers/common/ml/version.map | 16 +\n 3 files changed, 737 insertions(+)\n create mode 100644 drivers/common/ml/ml_utils_scalar.c\n\n--\n2.17.1", "diff": "diff --git a/drivers/common/ml/meson.build b/drivers/common/ml/meson.build\nindex 2749ab6c2e..59b58b95b4 100644\n--- a/drivers/common/ml/meson.build\n+++ b/drivers/common/ml/meson.build\n@@ -13,6 +13,7 @@ headers = files(\n\n sources = files(\n 'ml_utils.c',\n+ 'ml_utils_scalar.c',\n )\n\n deps += ['mldev']\ndiff --git a/drivers/common/ml/ml_utils_scalar.c b/drivers/common/ml/ml_utils_scalar.c\nnew file mode 100644\nindex 0000000000..1272d67593\n--- /dev/null\n+++ b/drivers/common/ml/ml_utils_scalar.c\n@@ -0,0 +1,720 @@\n+/* SPDX-License-Identifier: BSD-3-Clause\n+ * Copyright (c) 2022 Marvell.\n+ */\n+\n+#include <errno.h>\n+#include <math.h>\n+#include <stdint.h>\n+\n+#include \"ml_utils.h\"\n+\n+/* Description:\n+ * This file implements scalar versions of Machine Learning utility functions used to convert data\n+ * types from higher precision to lower precision and vice-versa.\n+ */\n+\n+#ifndef BIT\n+#define BIT(nr) (1UL << (nr))\n+#endif\n+\n+#ifndef BITS_PER_LONG\n+#define BITS_PER_LONG (__SIZEOF_LONG__ * 8)\n+#endif\n+\n+#ifndef GENMASK_U32\n+#define GENMASK_U32(h, l) (((~0UL) << (l)) & (~0UL >> (BITS_PER_LONG - 1 - (h))))\n+#endif\n+\n+/* float32: bit index of MSB & LSB of sign, exponent and mantissa */\n+#define FP32_LSB_M 0\n+#define FP32_MSB_M 22\n+#define FP32_LSB_E 23\n+#define FP32_MSB_E 30\n+#define FP32_LSB_S 31\n+#define FP32_MSB_S 31\n+\n+/* float32: bitmask for sign, exponent and mantissa */\n+#define FP32_MASK_S GENMASK_U32(FP32_MSB_S, FP32_LSB_S)\n+#define FP32_MASK_E GENMASK_U32(FP32_MSB_E, FP32_LSB_E)\n+#define FP32_MASK_M GENMASK_U32(FP32_MSB_M, FP32_LSB_M)\n+\n+/* float16: bit index of MSB & LSB of sign, exponent and mantissa */\n+#define FP16_LSB_M 0\n+#define FP16_MSB_M 9\n+#define FP16_LSB_E 10\n+#define FP16_MSB_E 14\n+#define FP16_LSB_S 15\n+#define FP16_MSB_S 15\n+\n+/* float16: bitmask for sign, exponent and mantissa */\n+#define FP16_MASK_S GENMASK_U32(FP16_MSB_S, FP16_LSB_S)\n+#define FP16_MASK_E GENMASK_U32(FP16_MSB_E, FP16_LSB_E)\n+#define FP16_MASK_M GENMASK_U32(FP16_MSB_M, FP16_LSB_M)\n+\n+/* bfloat16: bit index of MSB & LSB of sign, exponent and mantissa */\n+#define BF16_LSB_M 0\n+#define BF16_MSB_M 6\n+#define BF16_LSB_E 7\n+#define BF16_MSB_E 14\n+#define BF16_LSB_S 15\n+#define BF16_MSB_S 15\n+\n+/* bfloat16: bitmask for sign, exponent and mantissa */\n+#define BF16_MASK_S GENMASK_U32(BF16_MSB_S, BF16_LSB_S)\n+#define BF16_MASK_E GENMASK_U32(BF16_MSB_E, BF16_LSB_E)\n+#define BF16_MASK_M GENMASK_U32(BF16_MSB_M, BF16_LSB_M)\n+\n+/* Exponent bias */\n+#define FP32_BIAS_E 127\n+#define FP16_BIAS_E 15\n+#define BF16_BIAS_E 127\n+\n+#define FP32_PACK(sign, exponent, mantissa) \\\n+\t(((sign) << FP32_LSB_S) | ((exponent) << FP32_LSB_E) | (mantissa))\n+\n+#define FP16_PACK(sign, exponent, mantissa) \\\n+\t(((sign) << FP16_LSB_S) | ((exponent) << FP16_LSB_E) | (mantissa))\n+\n+#define BF16_PACK(sign, exponent, mantissa) \\\n+\t(((sign) << BF16_LSB_S) | ((exponent) << BF16_LSB_E) | (mantissa))\n+\n+/* Represent float32 as float and uint32_t */\n+union float32 {\n+\tfloat f;\n+\tuint32_t u;\n+};\n+\n+__rte_weak int\n+ml_float32_to_int8(float scale, uint64_t nb_elements, void *input, void *output)\n+{\n+\tfloat *input_buffer;\n+\tint8_t *output_buffer;\n+\tuint64_t i;\n+\tint i32;\n+\n+\tif ((scale == 0) || (nb_elements == 0) || (input == NULL) || (output == NULL))\n+\t\treturn -EINVAL;\n+\n+\tinput_buffer = (float *)input;\n+\toutput_buffer = (int8_t *)output;\n+\n+\tfor (i = 0; i < nb_elements; i++) {\n+\t\ti32 = (int32_t)round((*input_buffer) * scale);\n+\n+\t\tif (i32 < INT8_MIN)\n+\t\t\ti32 = INT8_MIN;\n+\n+\t\tif (i32 > INT8_MAX)\n+\t\t\ti32 = INT8_MAX;\n+\n+\t\t*output_buffer = (int8_t)i32;\n+\n+\t\tinput_buffer++;\n+\t\toutput_buffer++;\n+\t}\n+\n+\treturn 0;\n+}\n+\n+__rte_weak int\n+ml_int8_to_float32(float scale, uint64_t nb_elements, void *input, void *output)\n+{\n+\tint8_t *input_buffer;\n+\tfloat *output_buffer;\n+\tuint64_t i;\n+\n+\tif ((scale == 0) || (nb_elements == 0) || (input == NULL) || (output == NULL))\n+\t\treturn -EINVAL;\n+\n+\tinput_buffer = (int8_t *)input;\n+\toutput_buffer = (float *)output;\n+\n+\tfor (i = 0; i < nb_elements; i++) {\n+\t\t*output_buffer = scale * (float)(*input_buffer);\n+\n+\t\tinput_buffer++;\n+\t\toutput_buffer++;\n+\t}\n+\n+\treturn 0;\n+}\n+\n+__rte_weak int\n+ml_float32_to_uint8(float scale, uint64_t nb_elements, void *input, void *output)\n+{\n+\tfloat *input_buffer;\n+\tuint8_t *output_buffer;\n+\tint32_t i32;\n+\tuint64_t i;\n+\n+\tif ((scale == 0) || (nb_elements == 0) || (input == NULL) || (output == NULL))\n+\t\treturn -EINVAL;\n+\n+\tinput_buffer = (float *)input;\n+\toutput_buffer = (uint8_t *)output;\n+\n+\tfor (i = 0; i < nb_elements; i++) {\n+\t\ti32 = (int32_t)round((*input_buffer) * scale);\n+\n+\t\tif (i32 < 0)\n+\t\t\ti32 = 0;\n+\n+\t\tif (i32 > UINT8_MAX)\n+\t\t\ti32 = UINT8_MAX;\n+\n+\t\t*output_buffer = (uint8_t)i32;\n+\n+\t\tinput_buffer++;\n+\t\toutput_buffer++;\n+\t}\n+\n+\treturn 0;\n+}\n+\n+__rte_weak int\n+ml_uint8_to_float32(float scale, uint64_t nb_elements, void *input, void *output)\n+{\n+\tuint8_t *input_buffer;\n+\tfloat *output_buffer;\n+\tuint64_t i;\n+\n+\tif ((scale == 0) || (nb_elements == 0) || (input == NULL) || (output == NULL))\n+\t\treturn -EINVAL;\n+\n+\tinput_buffer = (uint8_t *)input;\n+\toutput_buffer = (float *)output;\n+\n+\tfor (i = 0; i < nb_elements; i++) {\n+\t\t*output_buffer = scale * (float)(*input_buffer);\n+\n+\t\tinput_buffer++;\n+\t\toutput_buffer++;\n+\t}\n+\n+\treturn 0;\n+}\n+\n+__rte_weak int\n+ml_float32_to_int16(float scale, uint64_t nb_elements, void *input, void *output)\n+{\n+\tfloat *input_buffer;\n+\tint16_t *output_buffer;\n+\tint32_t i32;\n+\tuint64_t i;\n+\n+\tif ((scale == 0) || (nb_elements == 0) || (input == NULL) || (output == NULL))\n+\t\treturn -EINVAL;\n+\n+\tinput_buffer = (float *)input;\n+\toutput_buffer = (int16_t *)output;\n+\n+\tfor (i = 0; i < nb_elements; i++) {\n+\t\ti32 = (int32_t)round((*input_buffer) * scale);\n+\n+\t\tif (i32 < INT16_MIN)\n+\t\t\ti32 = INT16_MIN;\n+\n+\t\tif (i32 > INT16_MAX)\n+\t\t\ti32 = INT16_MAX;\n+\n+\t\t*output_buffer = (int16_t)i32;\n+\n+\t\tinput_buffer++;\n+\t\toutput_buffer++;\n+\t}\n+\n+\treturn 0;\n+}\n+\n+__rte_weak int\n+ml_int16_to_float32(float scale, uint64_t nb_elements, void *input, void *output)\n+{\n+\tint16_t *input_buffer;\n+\tfloat *output_buffer;\n+\tuint64_t i;\n+\n+\tif ((scale == 0) || (nb_elements == 0) || (input == NULL) || (output == NULL))\n+\t\treturn -EINVAL;\n+\n+\tinput_buffer = (int16_t *)input;\n+\toutput_buffer = (float *)output;\n+\n+\tfor (i = 0; i < nb_elements; i++) {\n+\t\t*output_buffer = scale * (float)(*input_buffer);\n+\n+\t\tinput_buffer++;\n+\t\toutput_buffer++;\n+\t}\n+\n+\treturn 0;\n+}\n+\n+__rte_weak int\n+ml_float32_to_uint16(float scale, uint64_t nb_elements, void *input, void *output)\n+{\n+\tfloat *input_buffer;\n+\tuint16_t *output_buffer;\n+\tint32_t i32;\n+\tuint64_t i;\n+\n+\tif ((scale == 0) || (nb_elements == 0) || (input == NULL) || (output == NULL))\n+\t\treturn -EINVAL;\n+\n+\tinput_buffer = (float *)input;\n+\toutput_buffer = (uint16_t *)output;\n+\n+\tfor (i = 0; i < nb_elements; i++) {\n+\t\ti32 = (int32_t)round((*input_buffer) * scale);\n+\n+\t\tif (i32 < 0)\n+\t\t\ti32 = 0;\n+\n+\t\tif (i32 > UINT16_MAX)\n+\t\t\ti32 = UINT16_MAX;\n+\n+\t\t*output_buffer = (uint16_t)i32;\n+\n+\t\tinput_buffer++;\n+\t\toutput_buffer++;\n+\t}\n+\n+\treturn 0;\n+}\n+\n+__rte_weak int\n+ml_uint16_to_float32(float scale, uint64_t nb_elements, void *input, void *output)\n+{\n+\tuint16_t *input_buffer;\n+\tfloat *output_buffer;\n+\tuint64_t i;\n+\n+\tif ((scale == 0) || (nb_elements == 0) || (input == NULL) || (output == NULL))\n+\t\treturn -EINVAL;\n+\n+\tinput_buffer = (uint16_t *)input;\n+\toutput_buffer = (float *)output;\n+\n+\tfor (i = 0; i < nb_elements; i++) {\n+\t\t*output_buffer = scale * (float)(*input_buffer);\n+\n+\t\tinput_buffer++;\n+\t\toutput_buffer++;\n+\t}\n+\n+\treturn 0;\n+}\n+\n+/* Convert a single precision floating point number (float32) into a half precision\n+ * floating point number (float16) using round to nearest rounding mode.\n+ */\n+static uint16_t\n+__float32_to_float16_scalar_rtn(float x)\n+{\n+\tunion float32 f32; /* float32 input */\n+\tuint32_t f32_s;\t /* float32 sign */\n+\tuint32_t f32_e;\t /* float32 exponent */\n+\tuint32_t f32_m;\t /* float32 mantissa */\n+\tuint16_t f16_s;\t /* float16 sign */\n+\tuint16_t f16_e;\t /* float16 exponent */\n+\tuint16_t f16_m;\t /* float16 mantissa */\n+\tuint32_t tbits;\t /* number of truncated bits */\n+\tuint32_t tmsb;\t /* MSB position of truncated bits */\n+\tuint32_t m_32;\t /* temporary float32 mantissa */\n+\tuint16_t m_16;\t /* temporary float16 mantissa */\n+\tuint16_t u16;\t /* float16 output */\n+\tint be_16;\t /* float16 biased exponent, signed */\n+\n+\tf32.f = x;\n+\tf32_s = (f32.u & FP32_MASK_S) >> FP32_LSB_S;\n+\tf32_e = (f32.u & FP32_MASK_E) >> FP32_LSB_E;\n+\tf32_m = (f32.u & FP32_MASK_M) >> FP32_LSB_M;\n+\n+\tf16_s = f32_s;\n+\tf16_e = 0;\n+\tf16_m = 0;\n+\n+\tswitch (f32_e) {\n+\tcase (0): /* float32: zero or subnormal number */\n+\t\tf16_e = 0;\n+\t\tif (f32_m == 0) /* zero */\n+\t\t\tf16_m = 0;\n+\t\telse /* subnormal number, convert to zero */\n+\t\t\tf16_m = 0;\n+\t\tbreak;\n+\tcase (FP32_MASK_E >> FP32_LSB_E): /* float32: infinity or nan */\n+\t\tf16_e = FP16_MASK_E >> FP16_LSB_E;\n+\t\tif (f32_m == 0) { /* infinity */\n+\t\t\tf16_m = 0;\n+\t\t} else { /* nan, propagate mantissa and set MSB of mantissa to 1 */\n+\t\t\tf16_m = f32_m >> (FP32_MSB_M - FP16_MSB_M);\n+\t\t\tf16_m |= BIT(FP16_MSB_M);\n+\t\t}\n+\t\tbreak;\n+\tdefault: /* float32: normal number */\n+\t\t/* compute biased exponent for float16 */\n+\t\tbe_16 = (int)f32_e - FP32_BIAS_E + FP16_BIAS_E;\n+\n+\t\t/* overflow, be_16 = [31-INF], set to infinity */\n+\t\tif (be_16 >= (int)(FP16_MASK_E >> FP16_LSB_E)) {\n+\t\t\tf16_e = FP16_MASK_E >> FP16_LSB_E;\n+\t\t\tf16_m = 0;\n+\t\t} else if ((be_16 >= 1) && (be_16 < (int)(FP16_MASK_E >> FP16_LSB_E))) {\n+\t\t\t/* normal float16, be_16 = [1:30]*/\n+\t\t\tf16_e = be_16;\n+\t\t\tm_16 = f32_m >> (FP32_LSB_E - FP16_LSB_E);\n+\t\t\ttmsb = FP32_MSB_M - FP16_MSB_M - 1;\n+\t\t\tif ((f32_m & GENMASK_U32(tmsb, 0)) > BIT(tmsb)) {\n+\t\t\t\t/* round: non-zero truncated bits except MSB */\n+\t\t\t\tm_16++;\n+\n+\t\t\t\t/* overflow into exponent */\n+\t\t\t\tif (((m_16 & FP16_MASK_E) >> FP16_LSB_E) == 0x1)\n+\t\t\t\t\tf16_e++;\n+\t\t\t} else if ((f32_m & GENMASK_U32(tmsb, 0)) == BIT(tmsb)) {\n+\t\t\t\t/* round: MSB of truncated bits and LSB of m_16 is set */\n+\t\t\t\tif ((m_16 & 0x1) == 0x1) {\n+\t\t\t\t\tm_16++;\n+\n+\t\t\t\t\t/* overflow into exponent */\n+\t\t\t\t\tif (((m_16 & FP16_MASK_E) >> FP16_LSB_E) == 0x1)\n+\t\t\t\t\t\tf16_e++;\n+\t\t\t\t}\n+\t\t\t}\n+\t\t\tf16_m = m_16 & FP16_MASK_M;\n+\t\t} else if ((be_16 >= -(int)(FP16_MSB_M)) && (be_16 < 1)) {\n+\t\t\t/* underflow: zero / subnormal, be_16 = [-9:0] */\n+\t\t\tf16_e = 0;\n+\n+\t\t\t/* add implicit leading zero */\n+\t\t\tm_32 = f32_m | BIT(FP32_LSB_E);\n+\t\t\ttbits = FP32_LSB_E - FP16_LSB_E - be_16 + 1;\n+\t\t\tm_16 = m_32 >> tbits;\n+\n+\t\t\t/* if non-leading truncated bits are set */\n+\t\t\tif ((f32_m & GENMASK_U32(tbits - 1, 0)) > BIT(tbits - 1)) {\n+\t\t\t\tm_16++;\n+\n+\t\t\t\t/* overflow into exponent */\n+\t\t\t\tif (((m_16 & FP16_MASK_E) >> FP16_LSB_E) == 0x1)\n+\t\t\t\t\tf16_e++;\n+\t\t\t} else if ((f32_m & GENMASK_U32(tbits - 1, 0)) == BIT(tbits - 1)) {\n+\t\t\t\t/* if leading truncated bit is set */\n+\t\t\t\tif ((m_16 & 0x1) == 0x1) {\n+\t\t\t\t\tm_16++;\n+\n+\t\t\t\t\t/* overflow into exponent */\n+\t\t\t\t\tif (((m_16 & FP16_MASK_E) >> FP16_LSB_E) == 0x1)\n+\t\t\t\t\t\tf16_e++;\n+\t\t\t\t}\n+\t\t\t}\n+\t\t\tf16_m = m_16 & FP16_MASK_M;\n+\t\t} else if (be_16 == -(int)(FP16_MSB_M + 1)) {\n+\t\t\t/* underflow: zero, be_16 = [-10] */\n+\t\t\tf16_e = 0;\n+\t\t\tif (f32_m != 0)\n+\t\t\t\tf16_m = 1;\n+\t\t\telse\n+\t\t\t\tf16_m = 0;\n+\t\t} else {\n+\t\t\t/* underflow: zero, be_16 = [-INF:-11] */\n+\t\t\tf16_e = 0;\n+\t\t\tf16_m = 0;\n+\t\t}\n+\n+\t\tbreak;\n+\t}\n+\n+\tu16 = FP16_PACK(f16_s, f16_e, f16_m);\n+\n+\treturn u16;\n+}\n+\n+__rte_weak int\n+ml_float32_to_float16(uint64_t nb_elements, void *input, void *output)\n+{\n+\tfloat *input_buffer;\n+\tuint16_t *output_buffer;\n+\tuint64_t i;\n+\n+\tif ((nb_elements == 0) || (input == NULL) || (output == NULL))\n+\t\treturn -EINVAL;\n+\n+\tinput_buffer = (float *)input;\n+\toutput_buffer = (uint16_t *)output;\n+\n+\tfor (i = 0; i < nb_elements; i++) {\n+\t\t*output_buffer = __float32_to_float16_scalar_rtn(*input_buffer);\n+\n+\t\tinput_buffer = input_buffer + 1;\n+\t\toutput_buffer = output_buffer + 1;\n+\t}\n+\n+\treturn 0;\n+}\n+\n+/* Convert a half precision floating point number (float16) into a single precision\n+ * floating point number (float32).\n+ */\n+static float\n+__float16_to_float32_scalar_rtx(uint16_t f16)\n+{\n+\tunion float32 f32; /* float32 output */\n+\tuint16_t f16_s;\t /* float16 sign */\n+\tuint16_t f16_e;\t /* float16 exponent */\n+\tuint16_t f16_m;\t /* float16 mantissa */\n+\tuint32_t f32_s;\t /* float32 sign */\n+\tuint32_t f32_e;\t /* float32 exponent */\n+\tuint32_t f32_m;\t /* float32 mantissa*/\n+\tuint8_t shift;\t /* number of bits to be shifted */\n+\tuint32_t clz;\t /* count of leading zeroes */\n+\tint e_16;\t /* float16 exponent unbiased */\n+\n+\tf16_s = (f16 & FP16_MASK_S) >> FP16_LSB_S;\n+\tf16_e = (f16 & FP16_MASK_E) >> FP16_LSB_E;\n+\tf16_m = (f16 & FP16_MASK_M) >> FP16_LSB_M;\n+\n+\tf32_s = f16_s;\n+\tswitch (f16_e) {\n+\tcase (FP16_MASK_E >> FP16_LSB_E): /* float16: infinity or nan */\n+\t\tf32_e = FP32_MASK_E >> FP32_LSB_E;\n+\t\tif (f16_m == 0x0) { /* infinity */\n+\t\t\tf32_m = f16_m;\n+\t\t} else { /* nan, propagate mantissa, set MSB of mantissa to 1 */\n+\t\t\tf32_m = f16_m;\n+\t\t\tshift = FP32_MSB_M - FP16_MSB_M;\n+\t\t\tf32_m = (f32_m << shift) & FP32_MASK_M;\n+\t\t\tf32_m |= BIT(FP32_MSB_M);\n+\t\t}\n+\t\tbreak;\n+\tcase 0: /* float16: zero or sub-normal */\n+\t\tf32_m = f16_m;\n+\t\tif (f16_m == 0) { /* zero signed */\n+\t\t\tf32_e = 0;\n+\t\t} else { /* subnormal numbers */\n+\t\t\tclz = __builtin_clz((uint32_t)f16_m) - sizeof(uint32_t) * 8 + FP16_LSB_E;\n+\t\t\te_16 = (int)f16_e - clz;\n+\t\t\tf32_e = FP32_BIAS_E + e_16 - FP16_BIAS_E;\n+\n+\t\t\tshift = clz + (FP32_MSB_M - FP16_MSB_M) + 1;\n+\t\t\tf32_m = (f32_m << shift) & FP32_MASK_M;\n+\t\t}\n+\t\tbreak;\n+\tdefault: /* normal numbers */\n+\t\tf32_m = f16_m;\n+\t\te_16 = (int)f16_e;\n+\t\tf32_e = FP32_BIAS_E + e_16 - FP16_BIAS_E;\n+\n+\t\tshift = (FP32_MSB_M - FP16_MSB_M);\n+\t\tf32_m = (f32_m << shift) & FP32_MASK_M;\n+\t}\n+\n+\tf32.u = FP32_PACK(f32_s, f32_e, f32_m);\n+\n+\treturn f32.f;\n+}\n+\n+__rte_weak int\n+ml_float16_to_float32(uint64_t nb_elements, void *input, void *output)\n+{\n+\tuint16_t *input_buffer;\n+\tfloat *output_buffer;\n+\tuint64_t i;\n+\n+\tif ((nb_elements == 0) || (input == NULL) || (output == NULL))\n+\t\treturn -EINVAL;\n+\n+\tinput_buffer = (uint16_t *)input;\n+\toutput_buffer = (float *)output;\n+\n+\tfor (i = 0; i < nb_elements; i++) {\n+\t\t*output_buffer = __float16_to_float32_scalar_rtx(*input_buffer);\n+\n+\t\tinput_buffer = input_buffer + 1;\n+\t\toutput_buffer = output_buffer + 1;\n+\t}\n+\n+\treturn 0;\n+}\n+\n+/* Convert a single precision floating point number (float32) into a\n+ * brain float number (bfloat16) using round to nearest rounding mode.\n+ */\n+static uint16_t\n+__float32_to_bfloat16_scalar_rtn(float x)\n+{\n+\tunion float32 f32; /* float32 input */\n+\tuint32_t f32_s;\t /* float32 sign */\n+\tuint32_t f32_e;\t /* float32 exponent */\n+\tuint32_t f32_m;\t /* float32 mantissa */\n+\tuint16_t b16_s;\t /* float16 sign */\n+\tuint16_t b16_e;\t /* float16 exponent */\n+\tuint16_t b16_m;\t /* float16 mantissa */\n+\tuint32_t tbits;\t /* number of truncated bits */\n+\tuint16_t u16;\t /* float16 output */\n+\n+\tf32.f = x;\n+\tf32_s = (f32.u & FP32_MASK_S) >> FP32_LSB_S;\n+\tf32_e = (f32.u & FP32_MASK_E) >> FP32_LSB_E;\n+\tf32_m = (f32.u & FP32_MASK_M) >> FP32_LSB_M;\n+\n+\tb16_s = f32_s;\n+\tb16_e = 0;\n+\tb16_m = 0;\n+\n+\tswitch (f32_e) {\n+\tcase (0): /* float32: zero or subnormal number */\n+\t\tb16_e = 0;\n+\t\tif (f32_m == 0) /* zero */\n+\t\t\tb16_m = 0;\n+\t\telse /* subnormal float32 number, normal bfloat16 */\n+\t\t\tgoto bf16_normal;\n+\t\tbreak;\n+\tcase (FP32_MASK_E >> FP32_LSB_E): /* float32: infinity or nan */\n+\t\tb16_e = BF16_MASK_E >> BF16_LSB_E;\n+\t\tif (f32_m == 0) { /* infinity */\n+\t\t\tb16_m = 0;\n+\t\t} else { /* nan, propagate mantissa and set MSB of mantissa to 1 */\n+\t\t\tb16_m = f32_m >> (FP32_MSB_M - BF16_MSB_M);\n+\t\t\tb16_m |= BIT(BF16_MSB_M);\n+\t\t}\n+\t\tbreak;\n+\tdefault: /* float32: normal number, normal bfloat16 */\n+\t\tgoto bf16_normal;\n+\t}\n+\n+\tgoto bf16_pack;\n+\n+bf16_normal:\n+\tb16_e = f32_e;\n+\ttbits = FP32_MSB_M - BF16_MSB_M;\n+\tb16_m = f32_m >> tbits;\n+\n+\t/* if non-leading truncated bits are set */\n+\tif ((f32_m & GENMASK_U32(tbits - 1, 0)) > BIT(tbits - 1)) {\n+\t\tb16_m++;\n+\n+\t\t/* if overflow into exponent */\n+\t\tif (((b16_m & BF16_MASK_E) >> BF16_LSB_E) == 0x1)\n+\t\t\tb16_e++;\n+\t} else if ((f32_m & GENMASK_U32(tbits - 1, 0)) == BIT(tbits - 1)) {\n+\t\t/* if only leading truncated bit is set */\n+\t\tif ((b16_m & 0x1) == 0x1) {\n+\t\t\tb16_m++;\n+\n+\t\t\t/* if overflow into exponent */\n+\t\t\tif (((b16_m & BF16_MASK_E) >> BF16_LSB_E) == 0x1)\n+\t\t\t\tb16_e++;\n+\t\t}\n+\t}\n+\tb16_m = b16_m & BF16_MASK_M;\n+\n+bf16_pack:\n+\tu16 = BF16_PACK(b16_s, b16_e, b16_m);\n+\n+\treturn u16;\n+}\n+\n+__rte_weak int\n+ml_float32_to_bfloat16(uint64_t nb_elements, void *input, void *output)\n+{\n+\tfloat *input_buffer;\n+\tuint16_t *output_buffer;\n+\tuint64_t i;\n+\n+\tif ((nb_elements == 0) || (input == NULL) || (output == NULL))\n+\t\treturn -EINVAL;\n+\n+\tinput_buffer = (float *)input;\n+\toutput_buffer = (uint16_t *)output;\n+\n+\tfor (i = 0; i < nb_elements; i++) {\n+\t\t*output_buffer = __float32_to_bfloat16_scalar_rtn(*input_buffer);\n+\n+\t\tinput_buffer = input_buffer + 1;\n+\t\toutput_buffer = output_buffer + 1;\n+\t}\n+\n+\treturn 0;\n+}\n+\n+/* Convert a brain float number (bfloat16) into a\n+ * single precision floating point number (float32).\n+ */\n+static float\n+__bfloat16_to_float32_scalar_rtx(uint16_t f16)\n+{\n+\tunion float32 f32; /* float32 output */\n+\tuint16_t b16_s;\t /* float16 sign */\n+\tuint16_t b16_e;\t /* float16 exponent */\n+\tuint16_t b16_m;\t /* float16 mantissa */\n+\tuint32_t f32_s;\t /* float32 sign */\n+\tuint32_t f32_e;\t /* float32 exponent */\n+\tuint32_t f32_m;\t /* float32 mantissa*/\n+\tuint8_t shift;\t /* number of bits to be shifted */\n+\n+\tb16_s = (f16 & BF16_MASK_S) >> BF16_LSB_S;\n+\tb16_e = (f16 & BF16_MASK_E) >> BF16_LSB_E;\n+\tb16_m = (f16 & BF16_MASK_M) >> BF16_LSB_M;\n+\n+\tf32_s = b16_s;\n+\tswitch (b16_e) {\n+\tcase (BF16_MASK_E >> BF16_LSB_E): /* bfloat16: infinity or nan */\n+\t\tf32_e = FP32_MASK_E >> FP32_LSB_E;\n+\t\tif (b16_m == 0x0) { /* infinity */\n+\t\t\tf32_m = 0;\n+\t\t} else { /* nan, propagate mantissa, set MSB of mantissa to 1 */\n+\t\t\tf32_m = b16_m;\n+\t\t\tshift = FP32_MSB_M - BF16_MSB_M;\n+\t\t\tf32_m = (f32_m << shift) & FP32_MASK_M;\n+\t\t\tf32_m |= BIT(FP32_MSB_M);\n+\t\t}\n+\t\tbreak;\n+\tcase 0: /* bfloat16: zero or subnormal */\n+\t\tf32_m = b16_m;\n+\t\tif (b16_m == 0) { /* zero signed */\n+\t\t\tf32_e = 0;\n+\t\t} else { /* subnormal numbers */\n+\t\t\tgoto fp32_normal;\n+\t\t}\n+\t\tbreak;\n+\tdefault: /* bfloat16: normal number */\n+\t\tgoto fp32_normal;\n+\t}\n+\n+\tgoto fp32_pack;\n+\n+fp32_normal:\n+\tf32_m = b16_m;\n+\tf32_e = FP32_BIAS_E + b16_e - BF16_BIAS_E;\n+\n+\tshift = (FP32_MSB_M - BF16_MSB_M);\n+\tf32_m = (f32_m << shift) & FP32_MASK_M;\n+\n+fp32_pack:\n+\tf32.u = FP32_PACK(f32_s, f32_e, f32_m);\n+\n+\treturn f32.f;\n+}\n+\n+__rte_weak int\n+ml_bfloat16_to_float32(uint64_t nb_elements, void *input, void *output)\n+{\n+\tuint16_t *input_buffer;\n+\tfloat *output_buffer;\n+\tuint64_t i;\n+\n+\tif ((nb_elements == 0) || (input == NULL) || (output == NULL))\n+\t\treturn -EINVAL;\n+\n+\tinput_buffer = (uint16_t *)input;\n+\toutput_buffer = (float *)output;\n+\n+\tfor (i = 0; i < nb_elements; i++) {\n+\t\t*output_buffer = __bfloat16_to_float32_scalar_rtx(*input_buffer);\n+\n+\t\tinput_buffer = input_buffer + 1;\n+\t\toutput_buffer = output_buffer + 1;\n+\t}\n+\n+\treturn 0;\n+}\ndiff --git a/drivers/common/ml/version.map b/drivers/common/ml/version.map\nindex 7e33755f2f..35f270f637 100644\n--- a/drivers/common/ml/version.map\n+++ b/drivers/common/ml/version.map\n@@ -5,5 +5,21 @@ INTERNAL {\n \tml_io_type_to_str;\n \tml_io_format_to_str;\n\n+\tml_float32_to_int8;\n+\tml_int8_to_float32;\n+\tml_float32_to_uint8;\n+\tml_uint8_to_float32;\n+\n+\tml_float32_to_int16;\n+\tml_int16_to_float32;\n+\tml_float32_to_uint16;\n+\tml_uint16_to_float32;\n+\n+\tml_float32_to_float16;\n+\tml_float16_to_float32;\n+\n+\tml_float32_to_bfloat16;\n+\tml_bfloat16_to_float32;\n+\n \tlocal: *;\n };\n", "prefixes": [ "v2", "3/4" ] }