From patchwork Mon Jul 1 22:34:23 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Chautru, Nicolas" X-Patchwork-Id: 142002 X-Patchwork-Delegate: maxime.coquelin@redhat.com Return-Path: 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]) by inbox.dpdk.org (Postfix) with ESMTP id BE81B45540; Tue, 2 Jul 2024 00:34:19 +0200 (CEST) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 4BA5140656; Tue, 2 Jul 2024 00:34:15 +0200 (CEST) Received: from mgamail.intel.com (mgamail.intel.com [192.198.163.16]) by mails.dpdk.org (Postfix) with ESMTP id C357440289 for ; Tue, 2 Jul 2024 00:34:13 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1719873254; x=1751409254; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=JM1+KmS/ehoALuORunMrU1Zc6ehz+D68C/+mQddqbl4=; b=ANNd1rSUc7SjEpfPYIEKAq+bU2gNHWwzp8A5WCAczcBQKMRo7Nz6jfIC COYpHA1cJf0TGYEUIk/3BgH6tZnRmdJ4wf5+d2K9hdz0WRGUWoaEY+mjh cQzuNewvboKa8lfrL39p+gvj/vuzpflZrSDuqsYzuv14DWxTKyWZvNvq/ Fi9k/cMkrEMr7H2XykVhT8sjvn+dakeDvM/6li5n8Zc1HnVgZte+NUw2V cun4Tg8079tLfitqEGxXo055w/PNYQPbq77r4snIqLKtTdFMJll0vDIiL KqaW65JcbDnKbAxk1Lpnpd61ncu3rxj50Bdg4FmpEZySOjjm4zo11vFKT Q==; X-CSE-ConnectionGUID: lPDdOLLwS8av9NH0GEkp3g== X-CSE-MsgGUID: ixtEOPL6SUe6okdgWBGW4g== X-IronPort-AV: E=McAfee;i="6700,10204,11120"; a="12345770" X-IronPort-AV: E=Sophos;i="6.09,177,1716274800"; d="scan'208";a="12345770" Received: from orviesa010.jf.intel.com ([10.64.159.150]) by fmvoesa110.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 01 Jul 2024 15:34:12 -0700 X-CSE-ConnectionGUID: VqUwFx7YSPOJNjXg8tYDRw== X-CSE-MsgGUID: qLOyWlZ+Ra24nMWeRCG0/g== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.09,177,1716274800"; d="scan'208";a="45573291" Received: from spr-npg-bds1-eec2.sn.intel.com (HELO spr-npg-bds1-eec2..) ([10.233.181.123]) by orviesa010.jf.intel.com with ESMTP; 01 Jul 2024 15:34:12 -0700 From: Nicolas Chautru To: dev@dpdk.org, maxime.coquelin@redhat.com Cc: hemant.agrawal@nxp.com, david.marchand@redhat.com, hernan.vargas@intel.com, Nicolas Chautru Subject: [PATCH v1 1/2] bbdev: add new function to dump debug information Date: Mon, 1 Jul 2024 15:34:23 -0700 Message-Id: <20240701223424.427588-2-nicolas.chautru@intel.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20240701223424.427588-1-nicolas.chautru@intel.com> References: <20240701223424.427588-1-nicolas.chautru@intel.com> MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org This provides a new API to dump more debug information related to the status on a given bbdev queue. Some of this information is visible at bbdev level. This also provides a new option dev op, to print more information at the lower PMD level. This helps user to troubleshoot issues related to previous operations provided into a queue causing possible hard-to-debug negative scenarios. Signed-off-by: Nicolas Chautru --- lib/bbdev/rte_bbdev.c | 214 ++++++++++++++++++++++++++++++++++++++ lib/bbdev/rte_bbdev.h | 41 ++++++++ lib/bbdev/rte_bbdev_pmd.h | 9 ++ lib/bbdev/version.map | 4 + 4 files changed, 268 insertions(+) diff --git a/lib/bbdev/rte_bbdev.c b/lib/bbdev/rte_bbdev.c index 13bde3c25b..81c031fc09 100644 --- a/lib/bbdev/rte_bbdev.c +++ b/lib/bbdev/rte_bbdev.c @@ -1190,3 +1190,217 @@ rte_bbdev_enqueue_status_str(enum rte_bbdev_enqueue_status status) rte_bbdev_log(ERR, "Invalid enqueue status"); return NULL; } + + +int +rte_bbdev_queue_ops_dump(uint16_t dev_id, uint16_t queue_id, FILE *f) +{ + struct rte_bbdev_queue_data *q_data; + struct rte_bbdev_stats *stats; + uint16_t i; + struct rte_bbdev *dev = get_dev(dev_id); + + VALID_DEV_OR_RET_ERR(dev, dev_id); + VALID_QUEUE_OR_RET_ERR(queue_id, dev); + VALID_DEV_OPS_OR_RET_ERR(dev, dev_id); + VALID_FUNC_OR_RET_ERR(dev->dev_ops->queue_ops_dump, dev_id); + + q_data = &dev->data->queues[queue_id]; + + if (f == NULL) + return -EINVAL; + + fprintf(f, "Dump of operations on %s queue %d\n", + dev->data->name, queue_id); + fprintf(f, " Last Enqueue Status %s\n", + rte_bbdev_enqueue_status_str(q_data->enqueue_status)); + for (i = 0; i < 4; i++) + if (q_data->queue_stats.enqueue_status_count[i] > 0) + fprintf(f, " Enqueue Status Counters %s %" PRIu64 "\n", + rte_bbdev_enqueue_status_str(i), + q_data->queue_stats.enqueue_status_count[i]); + stats = &dev->data->queues[queue_id].queue_stats; + + fprintf(f, " Enqueue Count %" PRIu64 " Warning %" PRIu64 " Error %" PRIu64 "\n", + stats->enqueued_count, stats->enqueue_warn_count, + stats->enqueue_err_count); + fprintf(f, " Dequeue Count %" PRIu64 " Warning %" PRIu64 " Error %" PRIu64 "\n", + stats->dequeued_count, stats->dequeue_warn_count, + stats->dequeue_err_count); + + return dev->dev_ops->queue_ops_dump(dev, queue_id, f); +} + +char * +rte_bbdev_ops_param_string(void *op, enum rte_bbdev_op_type op_type) +{ + static char str[1024]; + static char partial[1024]; + struct rte_bbdev_dec_op *op_dec; + struct rte_bbdev_enc_op *op_enc; + struct rte_bbdev_fft_op *op_fft; + struct rte_bbdev_mldts_op *op_mldts; + + rte_iova_t add0 = 0, add1 = 0, add2 = 0, add3 = 0, add4 = 0; + + if (op == NULL) { + snprintf(str, sizeof(str), "Invalid Operation pointer\n"); + return str; + } + + if (op_type == RTE_BBDEV_OP_LDPC_DEC) { + op_dec = op; + if (op_dec->ldpc_dec.code_block_mode == RTE_BBDEV_TRANSPORT_BLOCK) + snprintf(partial, sizeof(partial), "C %d Cab %d Ea %d Eb %d r %d", + op_dec->ldpc_dec.tb_params.c, + op_dec->ldpc_dec.tb_params.cab, + op_dec->ldpc_dec.tb_params.ea, + op_dec->ldpc_dec.tb_params.eb, + op_dec->ldpc_dec.tb_params.r); + else + snprintf(partial, sizeof(partial), "E %d", op_dec->ldpc_dec.cb_params.e); + if (op_dec->ldpc_dec.input.data != NULL) + add0 = rte_pktmbuf_iova_offset(op_dec->ldpc_dec.input.data, 0); + if (op_dec->ldpc_dec.hard_output.data != NULL) + add1 = rte_pktmbuf_iova_offset(op_dec->ldpc_dec.hard_output.data, 0); + if (op_dec->ldpc_dec.soft_output.data != NULL) + add2 = rte_pktmbuf_iova_offset(op_dec->ldpc_dec.soft_output.data, 0); + if (op_dec->ldpc_dec.harq_combined_input.data != NULL) + add3 = rte_pktmbuf_iova_offset(op_dec->ldpc_dec.harq_combined_input.data, + 0); + if (op_dec->ldpc_dec.harq_combined_output.data != NULL) + add4 = rte_pktmbuf_iova_offset(op_dec->ldpc_dec.harq_combined_output.data, + 0); + snprintf(str, sizeof(str), "op %x st %x BG %d Zc %d Ncb %d qm %d F %d Rv %d It %d It %d " + "HARQin %d in %" PRIx64 " ho %" PRIx64 " so %" PRIx64 " hi %" PRIx64 " " + "ho %" PRIx64 " %s\n", + op_dec->ldpc_dec.op_flags, op_dec->status, + op_dec->ldpc_dec.basegraph, op_dec->ldpc_dec.z_c, + op_dec->ldpc_dec.n_cb, op_dec->ldpc_dec.q_m, + op_dec->ldpc_dec.n_filler, op_dec->ldpc_dec.rv_index, + op_dec->ldpc_dec.iter_max, op_dec->ldpc_dec.iter_count, + op_dec->ldpc_dec.harq_combined_input.length, + add0, add1, add2, add3, add4, partial); + } else if (op_type == RTE_BBDEV_OP_TURBO_DEC) { + op_dec = op; + if (op_dec->turbo_dec.code_block_mode == RTE_BBDEV_TRANSPORT_BLOCK) + snprintf(partial, sizeof(partial), "C %d Cab %d Ea %d Eb %d r %d K %d", + op_dec->turbo_dec.tb_params.c, + op_dec->turbo_dec.tb_params.cab, + op_dec->turbo_dec.tb_params.ea, + op_dec->turbo_dec.tb_params.eb, + op_dec->turbo_dec.tb_params.r, + op_dec->turbo_dec.tb_params.k_neg); + else + snprintf(partial, sizeof(partial), "E %d K %d", + op_dec->turbo_dec.cb_params.e, + op_dec->turbo_dec.cb_params.k); + if (op_dec->turbo_dec.input.data != NULL) + add0 = rte_pktmbuf_iova_offset(op_dec->turbo_dec.input.data, 0); + if (op_dec->turbo_dec.hard_output.data != NULL) + add1 = rte_pktmbuf_iova_offset(op_dec->turbo_dec.hard_output.data, 0); + if (op_dec->turbo_dec.soft_output.data != NULL) + add2 = rte_pktmbuf_iova_offset(op_dec->turbo_dec.soft_output.data, 0); + snprintf(str, sizeof(str), "op %x st %x CBM %d Iter %d map %d Rv %d ext %d " + "in %" PRIx64 " ho %" PRIx64 " so %" PRIx64 " %s\n", + op_dec->turbo_dec.op_flags, op_dec->status, + op_dec->turbo_dec.code_block_mode, + op_dec->turbo_dec.iter_max, op_dec->turbo_dec.num_maps, + op_dec->turbo_dec.rv_index, op_dec->turbo_dec.ext_scale, + add0, add1, add2, partial); + } else if (op_type == RTE_BBDEV_OP_LDPC_ENC) { + op_enc = op; + if (op_enc->ldpc_enc.code_block_mode == RTE_BBDEV_TRANSPORT_BLOCK) + snprintf(partial, sizeof(partial), "C %d Cab %d Ea %d Eb %d r %d", + op_enc->ldpc_enc.tb_params.c, + op_enc->ldpc_enc.tb_params.cab, + op_enc->ldpc_enc.tb_params.ea, + op_enc->ldpc_enc.tb_params.eb, + op_enc->ldpc_enc.tb_params.r); + else + snprintf(partial, sizeof(partial), "E %d", + op_enc->ldpc_enc.cb_params.e); + if (op_enc->ldpc_enc.input.data != NULL) + add0 = rte_pktmbuf_iova_offset(op_enc->ldpc_enc.input.data, 0); + if (op_enc->ldpc_enc.output.data != NULL) + add1 = rte_pktmbuf_iova_offset(op_enc->ldpc_enc.output.data, 0); + snprintf(str, sizeof(str), "op %x st %x BG %d Zc %d Ncb %d q_m %d F %d Rv %d " + "in %" PRIx64 " out %" PRIx64 " %s\n", + op_enc->ldpc_enc.op_flags, op_enc->status, + op_enc->ldpc_enc.basegraph, op_enc->ldpc_enc.z_c, + op_enc->ldpc_enc.n_cb, op_enc->ldpc_enc.q_m, + op_enc->ldpc_enc.n_filler, op_enc->ldpc_enc.rv_index, + add0, add1, partial); + } else if (op_type == RTE_BBDEV_OP_TURBO_ENC) { + op_enc = op; + if (op_enc->turbo_enc.code_block_mode == RTE_BBDEV_TRANSPORT_BLOCK) + snprintf(partial, sizeof(partial), + "C %d Cab %d Ea %d Eb %d r %d K %d Ncb %d", + op_enc->turbo_enc.tb_params.c, + op_enc->turbo_enc.tb_params.cab, + op_enc->turbo_enc.tb_params.ea, + op_enc->turbo_enc.tb_params.eb, + op_enc->turbo_enc.tb_params.r, + op_enc->turbo_enc.tb_params.k_neg, + op_enc->turbo_enc.tb_params.ncb_neg); + else + snprintf(partial, sizeof(partial), "E %d K %d", + op_enc->turbo_enc.cb_params.e, + op_enc->turbo_enc.cb_params.k); + if (op_enc->turbo_enc.input.data != NULL) + add0 = rte_pktmbuf_iova_offset(op_enc->turbo_enc.input.data, 0); + if (op_enc->turbo_enc.output.data != NULL) + add1 = rte_pktmbuf_iova_offset(op_enc->turbo_enc.output.data, 0); + snprintf(str, sizeof(str), "op %x st %x CBM %d Rv %d In %" PRIx64 " Out %" PRIx64 " %s\n", + op_enc->turbo_enc.op_flags, op_enc->status, + op_enc->turbo_enc.code_block_mode, op_enc->turbo_enc.rv_index, + add0, add1, partial); + } else if (op_type == RTE_BBDEV_OP_FFT) { + op_fft = op; + if (op_fft->fft.base_input.data != NULL) + add0 = rte_pktmbuf_iova_offset(op_fft->fft.base_input.data, 0); + if (op_fft->fft.base_output.data != NULL) + add1 = rte_pktmbuf_iova_offset(op_fft->fft.base_output.data, 0); + if (op_fft->fft.dewindowing_input.data != NULL) + add2 = rte_pktmbuf_iova_offset(op_fft->fft.dewindowing_input.data, 0); + if (op_fft->fft.power_meas_output.data != NULL) + add3 = rte_pktmbuf_iova_offset(op_fft->fft.power_meas_output.data, 0); + snprintf(str, sizeof(str), "op %x st %x in %d inl %d out %d outl %d cs %x ants %d " + "idft %d dft %d cst %d ish %d dsh %d ncs %d pwsh %d fp16 %d fr %d " + "outde %d in %" PRIx64 " out %" PRIx64 " dw %" PRIx64 " " + "pm %" PRIx64 "\n", + op_fft->fft.op_flags, op_fft->status, + op_fft->fft.input_sequence_size, op_fft->fft.input_leading_padding, + op_fft->fft.output_sequence_size, + op_fft->fft.output_leading_depadding, + op_fft->fft.cs_bitmap, op_fft->fft.num_antennas_log2, + op_fft->fft.idft_log2, op_fft->fft.dft_log2, + op_fft->fft.cs_time_adjustment, + op_fft->fft.idft_shift, op_fft->fft.dft_shift, + op_fft->fft.ncs_reciprocal, op_fft->fft.power_shift, + op_fft->fft.fp16_exp_adjust, op_fft->fft.freq_resample_mode, + op_fft->fft.output_depadded_size, add0, add1, add2, add3); + } else if (op_type == RTE_BBDEV_OP_MLDTS) { + op_mldts = op; + if (op_mldts->mldts.qhy_input.data != NULL) + add0 = rte_pktmbuf_iova_offset(op_mldts->mldts.qhy_input.data, 0); + if (op_mldts->mldts.r_input.data != NULL) + add1 = rte_pktmbuf_iova_offset(op_mldts->mldts.r_input.data, 0); + if (op_mldts->mldts.output.data != NULL) + add2 = rte_pktmbuf_iova_offset(op_mldts->mldts.output.data, 0); + snprintf(str, sizeof(str), + "op %x st %x rbs %d lay %d rrep %d crep%d qm %d %d %d %d " + "qhy %" PRIx64 " r %" PRIx64 " out %" PRIx64 "\n", + op_mldts->mldts.op_flags, op_mldts->status, + op_mldts->mldts.num_rbs, op_mldts->mldts.num_layers, + op_mldts->mldts.r_rep, op_mldts->mldts.c_rep, + op_mldts->mldts.q_m[0], op_mldts->mldts.q_m[1], + op_mldts->mldts.q_m[2], op_mldts->mldts.q_m[3], + add0, add1, add2); + + } else { + snprintf(str, sizeof(str), "Invalid Operation type %d\n", op_type); + } + + return str; +} diff --git a/lib/bbdev/rte_bbdev.h b/lib/bbdev/rte_bbdev.h index 0cbfdd1c95..8623b0725b 100644 --- a/lib/bbdev/rte_bbdev.h +++ b/lib/bbdev/rte_bbdev.h @@ -1061,6 +1061,47 @@ rte_bbdev_device_status_str(enum rte_bbdev_device_status status); const char* rte_bbdev_enqueue_status_str(enum rte_bbdev_enqueue_status status); +/** + * Dump operations info from device to a file. + * This API is used for debugging provided input operations, not a dataplane API. + * + * @param dev_id + * The device identifier. + * + * @param queue_index + * Index of queue. + * + * @param file + * A pointer to a file for output. + * + * @returns + * - 0 on success + * - ENOTSUP if interrupts are not supported by the identified device + * - negative value on failure - as returned from PMD + * + */ +__rte_experimental +int +rte_bbdev_queue_ops_dump(uint16_t dev_id, uint16_t queue_index, FILE *file); + + +/** + * String of parameters related to the parameters of an an operation of a given type. + * + * @param op + * Pointer to an operation. + * + * @param op_type + * Operation type enum. + * + * @returns + * String describing the provided operation. + * + */ +__rte_experimental +char * +rte_bbdev_ops_param_string(void *op, enum rte_bbdev_op_type op_type); + #ifdef __cplusplus } #endif diff --git a/lib/bbdev/rte_bbdev_pmd.h b/lib/bbdev/rte_bbdev_pmd.h index 442b23943d..c21a7f0c1e 100644 --- a/lib/bbdev/rte_bbdev_pmd.h +++ b/lib/bbdev/rte_bbdev_pmd.h @@ -133,6 +133,13 @@ typedef int (*rte_bbdev_queue_intr_enable_t)(struct rte_bbdev *dev, typedef int (*rte_bbdev_queue_intr_disable_t)(struct rte_bbdev *dev, uint16_t queue_id); +/* + * @internal + * Function to dump previous operations on a queue of a device. + */ +typedef int (*rte_bbdev_queue_ops_dump_t)(struct rte_bbdev *dev, + uint16_t queue_id, FILE *file); + /** * Operations implemented by drivers. Fields marked as "Required" must be * provided by a driver for a device to have basic functionality. "Optional" @@ -170,6 +177,8 @@ struct rte_bbdev_ops { rte_bbdev_queue_intr_enable_t queue_intr_enable; /** Disable queue interrupt. Optional */ rte_bbdev_queue_intr_disable_t queue_intr_disable; + /** Dump operations on the queue. Optional */ + rte_bbdev_queue_ops_dump_t queue_ops_dump; }; /** diff --git a/lib/bbdev/version.map b/lib/bbdev/version.map index 1840d2b2a4..0d037a93ca 100644 --- a/lib/bbdev/version.map +++ b/lib/bbdev/version.map @@ -54,4 +54,8 @@ EXPERIMENTAL { rte_bbdev_enqueue_mldts_ops; rte_bbdev_mldts_op_alloc_bulk; rte_bbdev_mldts_op_free_bulk; + + # added in 24.11 + rte_bbdev_queue_ops_dump; + rte_bbdev_ops_param_string; };