From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 3F0E4A0548; Tue, 11 Oct 2022 23:17:58 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 2250842C67; Tue, 11 Oct 2022 23:16:21 +0200 (CEST) Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) by mails.dpdk.org (Postfix) with ESMTP id F252442C11 for ; Tue, 11 Oct 2022 23:16:10 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1665522971; x=1697058971; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=ABth2HHSd8GVTqIeq92HfO0Nm9RIjDebz7rR7dyyPYQ=; b=SC/j0MG7AwPPUrmOrFC18QrPwtHaz4ceGfTVHK6JN19AETFh20o84AGc JiX0zuscXGgCEYwauPlwN5sHnqtQpfND+l8ci6EMw3vcOCJhREAIw2foC zo8ldCYk8PY5Zn+v1VphkSU4AbyrkDycUBOUNanExaE1C4a4dcWx6DhF2 suWP+z0AIHY3Hbw1sAUEpwKuuklwX9XbhmG+20d0AtIy1gTn4aop7+CUG UOJVM5cpqyWrhW/+SIk3rFJpMDbXQkyvbdZgRFfqGy4sYoRgiHDGYhgQu WrYDK9cROz6Jb1v5WP6EYY62GXo2anOmUC4iq0I1libaAVpyXBh1gba2d A==; X-IronPort-AV: E=McAfee;i="6500,9779,10497"; a="331116328" X-IronPort-AV: E=Sophos;i="5.95,177,1661842800"; d="scan'208";a="331116328" Received: from fmsmga003.fm.intel.com ([10.253.24.29]) by fmsmga101.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 11 Oct 2022 14:16:09 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=McAfee;i="6500,9779,10497"; a="715670528" X-IronPort-AV: E=Sophos;i="5.95,177,1661842800"; d="scan'208";a="715670528" Received: from unknown (HELO icx-npg-scs1-cp1.localdomain) ([10.233.180.245]) by FMSMGA003.fm.intel.com with ESMTP; 11 Oct 2022 14:16:09 -0700 From: Nicolas Chautru To: dev@dpdk.org, gakhil@marvell.com, maxime.coquelin@redhat.com Cc: trix@redhat.com, mdr@ashroe.eu, bruce.richardson@intel.com, hemant.agrawal@nxp.com, david.marchand@redhat.com, stephen@networkplumber.org, hernan.vargas@intel.com, Nic Chautru Subject: [PATCH v10 16/16] test-bbdev: unit test capability extension Date: Tue, 11 Oct 2022 14:15:38 -0700 Message-Id: <20221011211538.14106-17-nicolas.chautru@intel.com> X-Mailer: git-send-email 2.37.1 In-Reply-To: <20221011211538.14106-1-nicolas.chautru@intel.com> References: <20221011211538.14106-1-nicolas.chautru@intel.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit 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 From: Nic Chautru Added support for bbdev level unit test for the FFT operations and for Soft-Output options. Also added 2 small test vectors for the FFT operation. Signed-off-by: Nic Chautru --- app/test-bbdev/test_bbdev_perf.c | 542 +++++++++++++++++++- app/test-bbdev/test_bbdev_vector.c | 182 +++++++ app/test-bbdev/test_bbdev_vector.h | 1 + app/test-bbdev/test_vectors/fft_150.data | 475 +++++++++++++++++ app/test-bbdev/test_vectors/fft_byp_28.data | 103 ++++ 5 files changed, 1286 insertions(+), 17 deletions(-) create mode 100644 app/test-bbdev/test_vectors/fft_150.data create mode 100644 app/test-bbdev/test_vectors/fft_byp_28.data diff --git a/app/test-bbdev/test_bbdev_perf.c b/app/test-bbdev/test_bbdev_perf.c index 85c68a10ce..c716dd0e46 100644 --- a/app/test-bbdev/test_bbdev_perf.c +++ b/app/test-bbdev/test_bbdev_perf.c @@ -137,6 +137,7 @@ struct test_op_params { struct rte_mempool *mp; struct rte_bbdev_dec_op *ref_dec_op; struct rte_bbdev_enc_op *ref_enc_op; + struct rte_bbdev_fft_op *ref_fft_op; uint16_t burst_sz; uint16_t num_to_process; uint16_t num_lcores; @@ -162,6 +163,7 @@ struct thread_params { struct test_op_params *op_params; struct rte_bbdev_dec_op *dec_ops[MAX_BURST]; struct rte_bbdev_enc_op *enc_ops[MAX_BURST]; + struct rte_bbdev_fft_op *fft_ops[MAX_BURST]; }; #ifdef RTE_BBDEV_OFFLOAD_COST @@ -449,6 +451,19 @@ check_dev_cap(const struct rte_bbdev_info *dev_info) return TEST_FAILED; } return TEST_SUCCESS; + } else if (op_cap->type == RTE_BBDEV_OP_FFT) { + const struct rte_bbdev_op_cap_fft *cap = &op_cap->cap.fft; + + if (!flags_match(test_vector.fft.op_flags, cap->capability_flags)) { + printf("Flag Mismatch\n"); + return TEST_FAILED; + } + if (nb_inputs > cap->num_buffers_src) { + printf("Too many inputs defined: %u, max: %u\n", + nb_inputs, cap->num_buffers_src); + return TEST_FAILED; + } + return TEST_SUCCESS; } } @@ -1050,7 +1065,7 @@ init_op_data_objs(struct rte_bbdev_op_data *bufs, op_type, n * ref_entries->nb_segments, mbuf_pool->size); - if (seg->length > RTE_BBDEV_LDPC_E_MAX_MBUF) { + if ((seg->length + RTE_PKTMBUF_HEADROOM) > RTE_BBDEV_LDPC_E_MAX_MBUF) { /* * Special case when DPDK mbuf cannot handle * the required input size @@ -1064,7 +1079,7 @@ init_op_data_objs(struct rte_bbdev_op_data *bufs, bufs[i].length = 0; if ((op_type == DATA_INPUT) || (op_type == DATA_HARQ_INPUT)) { - if ((op_type == DATA_INPUT) && large_input) { + if (large_input) { /* Allocate a fake overused mbuf */ data = rte_malloc(NULL, seg->length, 0); TEST_ASSERT_NOT_NULL(data, @@ -1118,22 +1133,36 @@ init_op_data_objs(struct rte_bbdev_op_data *bufs, op_type); } } else { - - /* allocate chained-mbuf for output buffer */ - for (j = 1; j < ref_entries->nb_segments; ++j) { - struct rte_mbuf *m_tail = + if (((op_type == DATA_HARD_OUTPUT) || (op_type == DATA_SOFT_OUTPUT)) + && ((seg->length + RTE_PKTMBUF_HEADROOM) + > RTE_BBDEV_LDPC_E_MAX_MBUF)) { + /* Allocate a fake overused mbuf + margin */ + data = rte_malloc(NULL, seg->length + 1024, 0); + TEST_ASSERT_NOT_NULL(data, + "rte malloc failed with %u bytes", + seg->length + 1024); + m_head->buf_addr = data; + m_head->buf_iova = rte_malloc_virt2iova(data); + m_head->data_off = 0; + m_head->data_len = seg->length; + } else { + /* allocate chained-mbuf for output buffer */ + for (j = 1; j < ref_entries->nb_segments; ++j) { + struct rte_mbuf *m_tail = rte_pktmbuf_alloc(mbuf_pool); - TEST_ASSERT_NOT_NULL(m_tail, + TEST_ASSERT_NOT_NULL(m_tail, "Not enough mbufs in %d data type mbuf pool (needed %u, available %u)", op_type, n * ref_entries->nb_segments, mbuf_pool->size); - ret = rte_pktmbuf_chain(m_head, m_tail); - TEST_ASSERT_SUCCESS(ret, + ret = rte_pktmbuf_chain(m_head, m_tail); + TEST_ASSERT_SUCCESS(ret, "Couldn't chain mbufs from %d data type mbuf pool", op_type); + } } + bufs[i].length += seg->length; } } @@ -1851,6 +1880,40 @@ copy_reference_ldpc_enc_op(struct rte_bbdev_enc_op **ops, unsigned int n, } } +static void +copy_reference_fft_op(struct rte_bbdev_fft_op **ops, unsigned int n, + unsigned int start_idx, struct rte_bbdev_op_data *inputs, + struct rte_bbdev_op_data *outputs, struct rte_bbdev_op_data *pwrouts, + struct rte_bbdev_fft_op *ref_op) +{ + unsigned int i, j; + struct rte_bbdev_op_fft *fft = &ref_op->fft; + for (i = 0; i < n; i++) { + ops[i]->fft.input_sequence_size = fft->input_sequence_size; + ops[i]->fft.input_leading_padding = fft->input_leading_padding; + ops[i]->fft.output_sequence_size = fft->output_sequence_size; + ops[i]->fft.output_leading_depadding = + fft->output_leading_depadding; + for (j = 0; j < RTE_BBDEV_MAX_CS_2; j++) + ops[i]->fft.window_index[j] = fft->window_index[j]; + ops[i]->fft.cs_bitmap = fft->cs_bitmap; + ops[i]->fft.num_antennas_log2 = fft->num_antennas_log2; + ops[i]->fft.idft_log2 = fft->idft_log2; + ops[i]->fft.dft_log2 = fft->dft_log2; + ops[i]->fft.cs_time_adjustment = fft->cs_time_adjustment; + ops[i]->fft.idft_shift = fft->idft_shift; + ops[i]->fft.dft_shift = fft->dft_shift; + ops[i]->fft.ncs_reciprocal = fft->ncs_reciprocal; + ops[i]->fft.power_shift = fft->power_shift; + ops[i]->fft.fp16_exp_adjust = fft->fp16_exp_adjust; + ops[i]->fft.base_output = outputs[start_idx + i]; + ops[i]->fft.base_input = inputs[start_idx + i]; + if (pwrouts != NULL) + ops[i]->fft.power_meas_output = pwrouts[start_idx + i]; + ops[i]->fft.op_flags = fft->op_flags; + } +} + static int check_dec_status_and_ordering(struct rte_bbdev_dec_op *op, unsigned int order_idx, const int expected_status) @@ -1897,6 +1960,21 @@ check_enc_status_and_ordering(struct rte_bbdev_enc_op *op, return TEST_SUCCESS; } +static int +check_fft_status_and_ordering(struct rte_bbdev_fft_op *op, + unsigned int order_idx, const int expected_status) +{ + TEST_ASSERT(op->status == expected_status, + "op_status (%d) != expected_status (%d)", + op->status, expected_status); + + TEST_ASSERT((void *)(uintptr_t)order_idx == op->opaque_data, + "Ordering error, expected %p, got %p", + (void *)(uintptr_t)order_idx, op->opaque_data); + + return TEST_SUCCESS; +} + static inline int validate_op_chain(struct rte_bbdev_op_data *op, struct op_data_entries *orig_op) @@ -2103,6 +2181,59 @@ validate_op_harq_chain(struct rte_bbdev_op_data *op, return TEST_SUCCESS; } + +static inline int +validate_op_so_chain(struct rte_bbdev_op_data *op, + struct op_data_entries *orig_op) +{ + struct rte_mbuf *m = op->data; + uint8_t i, nb_dst_segments = orig_op->nb_segments; + uint32_t j, jj, total_data_size = 0; + int8_t *so_orig, *so_out; + uint32_t byte_error = 0, cum_error = 0, error, margin_error = 0; + + TEST_ASSERT(nb_dst_segments == m->nb_segs, + "Number of segments differ in original (%u) and filled (%u) op", + nb_dst_segments, m->nb_segs); + + /* Validate each mbuf segment length. */ + for (i = 0; i < nb_dst_segments; ++i) { + /* Apply offset to the first mbuf segment. */ + uint16_t offset = (i == 0) ? op->offset : 0; + uint16_t data_len = rte_pktmbuf_data_len(m) - offset; + total_data_size += orig_op->segments[i].length; + + TEST_ASSERT(orig_op->segments[i].length == data_len, + "Length of segment differ in original (%u) and filled (%u) op", + orig_op->segments[i].length, data_len); + so_orig = (int8_t *) orig_op->segments[i].addr; + so_out = rte_pktmbuf_mtod_offset(m, int8_t *, offset); + margin_error += data_len / 8; /* Allow for few % errors. */ + + /* SO output can have minor differences due to algorithm variations. */ + for (j = 0, jj = 0; j < data_len; j++, jj++) { + if (so_orig[j] != so_out[jj]) { + error = (so_orig[j] > so_out[jj]) ? so_orig[j] - so_out[jj] : + so_out[jj] - so_orig[j]; + /* Residual quantization error. */ + if (error > 32) { + printf("Warning: Soft mismatch %d: exp %d act %d => %d\n", + j, so_orig[j], so_out[jj], error); + byte_error++; + cum_error += error; + } + } + } + m = m->next; + } + + if (byte_error > margin_error) + TEST_ASSERT(byte_error <= 1, "Soft output mismatch (%d) %d", + byte_error, margin_error); + + return TEST_SUCCESS; +} + static int validate_dec_op(struct rte_bbdev_dec_op **ops, const uint16_t n, struct rte_bbdev_dec_op *ref_op, const int vector_mask) @@ -2137,7 +2268,7 @@ validate_dec_op(struct rte_bbdev_dec_op **ops, const uint16_t n, i); if (ref_op->turbo_dec.op_flags & RTE_BBDEV_TURBO_SOFT_OUTPUT) - TEST_ASSERT_SUCCESS(validate_op_chain(soft_output, + TEST_ASSERT_SUCCESS(validate_op_so_chain(soft_output, soft_data_orig), "Soft output buffers (CB=%u) are not equal", i); @@ -2286,6 +2417,76 @@ validate_ldpc_enc_op(struct rte_bbdev_enc_op **ops, const uint16_t n, return TEST_SUCCESS; } + +static inline int +validate_op_fft_chain(struct rte_bbdev_op_data *op, struct op_data_entries *orig_op) +{ + struct rte_mbuf *m = op->data; + uint8_t i, nb_dst_segments = orig_op->nb_segments; + int16_t delt, abs_delt, thres_hold = 3; + uint32_t j, data_len_iq, error_num; + int16_t *ref_out, *op_out; + + TEST_ASSERT(nb_dst_segments == m->nb_segs, + "Number of segments differ in original (%u) and filled (%u) op fft", + nb_dst_segments, m->nb_segs); + + /* Due to size limitation of mbuf, FFT doesn't use real mbuf. */ + for (i = 0; i < nb_dst_segments; ++i) { + uint16_t offset = (i == 0) ? op->offset : 0; + uint32_t data_len = op->length; + + TEST_ASSERT(orig_op->segments[i].length == data_len, + "Length of segment differ in original (%u) and filled (%u) op fft", + orig_op->segments[i].length, data_len); + /* Divided by 2 to get the number of 16bits data. */ + data_len_iq = data_len >> 1; + ref_out = (int16_t *)(orig_op->segments[i].addr); + op_out = rte_pktmbuf_mtod_offset(m, int16_t *, offset), + error_num = 0; + for (j = 0; j < data_len_iq; j++) { + delt = ref_out[j] - op_out[j]; + abs_delt = delt > 0 ? delt : -delt; + error_num += (abs_delt > thres_hold ? 1 : 0); + } + if (error_num > 0) { + rte_memdump(stdout, "Buffer A", ref_out, data_len); + rte_memdump(stdout, "Buffer B", op_out, data_len); + TEST_ASSERT(error_num == 0, + "FFT Output are not matched total (%u) errors (%u)", + data_len_iq, error_num); + } + + m = m->next; + } + + return TEST_SUCCESS; +} + +static int +validate_fft_op(struct rte_bbdev_fft_op **ops, const uint16_t n, + struct rte_bbdev_fft_op *ref_op) +{ + unsigned int i; + int ret; + struct op_data_entries *fft_data_orig = &test_vector.entries[DATA_HARD_OUTPUT]; + struct op_data_entries *fft_pwr_orig = &test_vector.entries[DATA_SOFT_OUTPUT]; + + for (i = 0; i < n; ++i) { + ret = check_fft_status_and_ordering(ops[i], i, ref_op->status); + TEST_ASSERT_SUCCESS(ret, "Checking status and ordering for FFT failed"); + TEST_ASSERT_SUCCESS(validate_op_fft_chain( + &ops[i]->fft.base_output, fft_data_orig), + "FFT Output buffers (op=%u) are not matched", i); + if (check_bit(ops[i]->fft.op_flags, RTE_BBDEV_FFT_POWER_MEAS)) + TEST_ASSERT_SUCCESS(validate_op_fft_chain( + &ops[i]->fft.power_meas_output, fft_pwr_orig), + "FFT Power Output buffers (op=%u) are not matched", i); + } + + return TEST_SUCCESS; +} + static void create_reference_dec_op(struct rte_bbdev_dec_op *op) { @@ -2319,6 +2520,16 @@ create_reference_ldpc_dec_op(struct rte_bbdev_dec_op *op) } } +static void +create_reference_fft_op(struct rte_bbdev_fft_op *op) +{ + unsigned int i; + struct op_data_entries *entry; + op->fft = test_vector.fft; + entry = &test_vector.entries[DATA_INPUT]; + for (i = 0; i < entry->nb_segments; ++i) + op->fft.base_input.length += entry->segments[i].length; +} static void create_reference_enc_op(struct rte_bbdev_enc_op *op) @@ -2422,6 +2633,17 @@ calc_ldpc_enc_TB_size(struct rte_bbdev_enc_op *op) return tb_size; } +static uint32_t +calc_fft_size(struct rte_bbdev_fft_op *op) +{ + uint32_t output_size; + int num_cs = 0, i; + for (i = 0; i < 12; i++) + if (check_bit(op->fft.cs_bitmap, 1 << i)) + num_cs++; + output_size = (num_cs * op->fft.output_sequence_size * 4) << op->fft.num_antennas_log2; + return output_size; +} static int init_test_op_params(struct test_op_params *op_params, @@ -2434,6 +2656,9 @@ init_test_op_params(struct test_op_params *op_params, op_type == RTE_BBDEV_OP_LDPC_DEC) ret = rte_bbdev_dec_op_alloc_bulk(ops_mp, &op_params->ref_dec_op, 1); + else if (op_type == RTE_BBDEV_OP_FFT) + ret = rte_bbdev_fft_op_alloc_bulk(ops_mp, + &op_params->ref_fft_op, 1); else ret = rte_bbdev_enc_op_alloc_bulk(ops_mp, &op_params->ref_enc_op, 1); @@ -2451,6 +2676,8 @@ init_test_op_params(struct test_op_params *op_params, else if (op_type == RTE_BBDEV_OP_TURBO_ENC || op_type == RTE_BBDEV_OP_LDPC_ENC) op_params->ref_enc_op->status = expected_status; + else if (op_type == RTE_BBDEV_OP_FFT) + op_params->ref_fft_op->status = expected_status; return 0; } @@ -2517,6 +2744,8 @@ run_test_case_on_device(test_case_function *test_case_func, uint8_t dev_id, create_reference_ldpc_enc_op(op_params->ref_enc_op); else if (test_vector.op_type == RTE_BBDEV_OP_LDPC_DEC) create_reference_ldpc_dec_op(op_params->ref_dec_op); + else if (test_vector.op_type == RTE_BBDEV_OP_FFT) + create_reference_fft_op(op_params->ref_fft_op); for (i = 0; i < ad->nb_queues; ++i) { f_ret = fill_queue_buffers(op_params, @@ -2728,6 +2957,11 @@ dequeue_event_callback(uint16_t dev_id, &tp->enc_ops[ __atomic_load_n(&tp->nb_dequeued, __ATOMIC_RELAXED)], burst_sz); + else if (test_vector.op_type == RTE_BBDEV_OP_FFT) + deq = rte_bbdev_dequeue_fft_ops(dev_id, queue_id, + &tp->fft_ops[ + __atomic_load_n(&tp->nb_dequeued, __ATOMIC_RELAXED)], + burst_sz); else /*RTE_BBDEV_OP_TURBO_ENC*/ deq = rte_bbdev_dequeue_enc_ops(dev_id, queue_id, &tp->enc_ops[ @@ -2771,6 +3005,10 @@ dequeue_event_callback(uint16_t dev_id, struct rte_bbdev_enc_op *ref_op = tp->op_params->ref_enc_op; ret = validate_ldpc_enc_op(tp->enc_ops, num_ops, ref_op); rte_bbdev_enc_op_free_bulk(tp->enc_ops, deq); + } else if (test_vector.op_type == RTE_BBDEV_OP_FFT) { + struct rte_bbdev_fft_op *ref_op = tp->op_params->ref_fft_op; + ret = validate_fft_op(tp->fft_ops, num_ops, ref_op); + rte_bbdev_fft_op_free_bulk(tp->fft_ops, deq); } else if (test_vector.op_type == RTE_BBDEV_OP_LDPC_DEC) { struct rte_bbdev_dec_op *ref_op = tp->op_params->ref_dec_op; ret = validate_ldpc_dec_op(tp->dec_ops, num_ops, ref_op, @@ -2793,6 +3031,9 @@ dequeue_event_callback(uint16_t dev_id, case RTE_BBDEV_OP_LDPC_DEC: tb_len_bits = calc_ldpc_dec_TB_size(tp->op_params->ref_dec_op); break; + case RTE_BBDEV_OP_FFT: + tb_len_bits = calc_fft_size(tp->op_params->ref_fft_op); + break; case RTE_BBDEV_OP_LDPC_ENC: tb_len_bits = calc_ldpc_enc_TB_size(tp->op_params->ref_enc_op); break; @@ -2924,6 +3165,7 @@ throughput_intr_lcore_dec(void *arg) struct rte_bbdev_dec_op *ops[num_to_process]; struct test_buffers *bufs = NULL; struct rte_bbdev_info info; + struct rte_bbdev_dec_op *ref_op = tp->op_params->ref_dec_op; int ret, i, j; uint16_t num_to_enq, enq; @@ -2949,20 +3191,24 @@ throughput_intr_lcore_dec(void *arg) ret = rte_bbdev_dec_op_alloc_bulk(tp->op_params->mp, ops, num_to_process); - TEST_ASSERT_SUCCESS(ret, "Allocation failed for %d ops", - num_to_process); + TEST_ASSERT_SUCCESS(ret, "Allocation failed for %d ops", num_to_process); + ref_op->turbo_dec.iter_max = get_iter_max(); if (test_vector.op_type != RTE_BBDEV_OP_NONE) copy_reference_dec_op(ops, num_to_process, 0, bufs->inputs, bufs->hard_outputs, bufs->soft_outputs, tp->op_params->ref_dec_op); - /* Set counter to validate the ordering */ + /* Set counter to validate the ordering. */ for (j = 0; j < num_to_process; ++j) ops[j]->opaque_data = (void *)(uintptr_t)j; for (j = 0; j < TEST_REPETITIONS; ++j) { - for (i = 0; i < num_to_process; ++i) + for (i = 0; i < num_to_process; ++i) { rte_pktmbuf_reset(ops[i]->turbo_dec.hard_output.data); + if (ops[i]->turbo_dec.soft_output.data != NULL) + rte_pktmbuf_reset(ops[i]->turbo_dec.soft_output.data); + } + tp->start_time = rte_rdtsc_precise(); for (enqueued = 0; enqueued < num_to_process;) { @@ -3175,6 +3421,93 @@ throughput_intr_lcore_ldpc_enc(void *arg) return TEST_SUCCESS; } + +static int +throughput_intr_lcore_fft(void *arg) +{ + struct thread_params *tp = arg; + unsigned int enqueued; + const uint16_t queue_id = tp->queue_id; + const uint16_t burst_sz = tp->op_params->burst_sz; + const uint16_t num_to_process = tp->op_params->num_to_process; + struct rte_bbdev_fft_op *ops[num_to_process]; + struct test_buffers *bufs = NULL; + struct rte_bbdev_info info; + int ret, i, j; + uint16_t num_to_enq, enq; + + TEST_ASSERT_SUCCESS((burst_sz > MAX_BURST), + "BURST_SIZE should be <= %u", MAX_BURST); + + TEST_ASSERT_SUCCESS(rte_bbdev_queue_intr_enable(tp->dev_id, queue_id), + "Failed to enable interrupts for dev: %u, queue_id: %u", + tp->dev_id, queue_id); + + rte_bbdev_info_get(tp->dev_id, &info); + + TEST_ASSERT_SUCCESS((num_to_process > info.drv.queue_size_lim), + "NUM_OPS cannot exceed %u for this device", + info.drv.queue_size_lim); + + bufs = &tp->op_params->q_bufs[GET_SOCKET(info.socket_id)][queue_id]; + + __atomic_store_n(&tp->processing_status, 0, __ATOMIC_RELAXED); + __atomic_store_n(&tp->nb_dequeued, 0, __ATOMIC_RELAXED); + + rte_wait_until_equal_16(&tp->op_params->sync, SYNC_START, __ATOMIC_RELAXED); + + ret = rte_bbdev_fft_op_alloc_bulk(tp->op_params->mp, ops, + num_to_process); + TEST_ASSERT_SUCCESS(ret, "Allocation failed for %d ops", + num_to_process); + if (test_vector.op_type != RTE_BBDEV_OP_NONE) + copy_reference_fft_op(ops, num_to_process, 0, bufs->inputs, + bufs->hard_outputs, bufs->soft_outputs, tp->op_params->ref_fft_op); + + /* Set counter to validate the ordering */ + for (j = 0; j < num_to_process; ++j) + ops[j]->opaque_data = (void *)(uintptr_t)j; + + for (j = 0; j < TEST_REPETITIONS; ++j) { + for (i = 0; i < num_to_process; ++i) + rte_pktmbuf_reset(ops[i]->fft.base_output.data); + + tp->start_time = rte_rdtsc_precise(); + for (enqueued = 0; enqueued < num_to_process;) { + num_to_enq = burst_sz; + + if (unlikely(num_to_process - enqueued < num_to_enq)) + num_to_enq = num_to_process - enqueued; + + enq = 0; + do { + enq += rte_bbdev_enqueue_fft_ops(tp->dev_id, + queue_id, &ops[enqueued], + num_to_enq); + } while (unlikely(enq != num_to_enq)); + enqueued += enq; + + /* Write to thread burst_sz current number of enqueued + * descriptors. It ensures that proper number of + * descriptors will be dequeued in callback + * function - needed for last batch in case where + * the number of operations is not a multiple of + * burst size. + */ + __atomic_store_n(&tp->burst_sz, num_to_enq, __ATOMIC_RELAXED); + + /* Wait until processing of previous batch is + * completed + */ + rte_wait_until_equal_16(&tp->nb_dequeued, enqueued, __ATOMIC_RELAXED); + } + if (j != TEST_REPETITIONS - 1) + __atomic_store_n(&tp->nb_dequeued, 0, __ATOMIC_RELAXED); + } + + return TEST_SUCCESS; +} + static int throughput_pmd_lcore_dec(void *arg) { @@ -3191,6 +3524,7 @@ throughput_pmd_lcore_dec(void *arg) int i, j, ret; struct rte_bbdev_info info; uint16_t num_to_enq; + bool so_enable; TEST_ASSERT_SUCCESS((burst_sz > MAX_BURST), "BURST_SIZE should be <= %u", MAX_BURST); @@ -3207,11 +3541,13 @@ throughput_pmd_lcore_dec(void *arg) ret = rte_bbdev_dec_op_alloc_bulk(tp->op_params->mp, ops_enq, num_ops); TEST_ASSERT_SUCCESS(ret, "Allocation failed for %d ops", num_ops); - + ref_op->turbo_dec.iter_max = get_iter_max(); if (test_vector.op_type != RTE_BBDEV_OP_NONE) copy_reference_dec_op(ops_enq, num_ops, 0, bufs->inputs, bufs->hard_outputs, bufs->soft_outputs, ref_op); + so_enable = check_bit(ops_enq[0]->turbo_dec.op_flags, RTE_BBDEV_TURBO_SOFT_OUTPUT); + /* Set counter to validate the ordering */ for (j = 0; j < num_ops; ++j) ops_enq[j]->opaque_data = (void *)(uintptr_t)j; @@ -3220,6 +3556,9 @@ throughput_pmd_lcore_dec(void *arg) for (j = 0; j < num_ops; ++j) mbuf_reset(ops_enq[j]->turbo_dec.hard_output.data); + if (so_enable) + for (j = 0; j < num_ops; ++j) + mbuf_reset(ops_enq[j]->turbo_dec.soft_output.data); start_time = rte_rdtsc_precise(); @@ -3335,8 +3674,7 @@ bler_pmd_lcore_ldpc_dec(void *arg) mbuf_reset( ops_enq[j]->ldpc_dec.hard_output.data); if (hc_out || loopback) - mbuf_reset( - ops_enq[j]->ldpc_dec.harq_combined_output.data); + mbuf_reset(ops_enq[j]->ldpc_dec.harq_combined_output.data); } if (extDdr) preload_harq_ddr(tp->dev_id, queue_id, ops_enq, @@ -3703,6 +4041,94 @@ throughput_pmd_lcore_ldpc_enc(void *arg) return TEST_SUCCESS; } +static int +throughput_pmd_lcore_fft(void *arg) +{ + struct thread_params *tp = arg; + uint16_t enq, deq; + uint64_t total_time = 0, start_time; + const uint16_t queue_id = tp->queue_id; + const uint16_t burst_sz = tp->op_params->burst_sz; + const uint16_t num_ops = tp->op_params->num_to_process; + struct rte_bbdev_fft_op *ops_enq[num_ops]; + struct rte_bbdev_fft_op *ops_deq[num_ops]; + struct rte_bbdev_fft_op *ref_op = tp->op_params->ref_fft_op; + struct test_buffers *bufs = NULL; + int i, j, ret; + struct rte_bbdev_info info; + uint16_t num_to_enq; + + TEST_ASSERT_SUCCESS((burst_sz > MAX_BURST), + "BURST_SIZE should be <= %u", MAX_BURST); + + rte_bbdev_info_get(tp->dev_id, &info); + + TEST_ASSERT_SUCCESS((num_ops > info.drv.queue_size_lim), + "NUM_OPS cannot exceed %u for this device", + info.drv.queue_size_lim); + + bufs = &tp->op_params->q_bufs[GET_SOCKET(info.socket_id)][queue_id]; + + rte_wait_until_equal_16(&tp->op_params->sync, SYNC_START, __ATOMIC_RELAXED); + + ret = rte_bbdev_fft_op_alloc_bulk(tp->op_params->mp, ops_enq, num_ops); + TEST_ASSERT_SUCCESS(ret, "Allocation failed for %d ops", num_ops); + + if (test_vector.op_type != RTE_BBDEV_OP_NONE) + copy_reference_fft_op(ops_enq, num_ops, 0, bufs->inputs, + bufs->hard_outputs, bufs->soft_outputs, ref_op); + + /* Set counter to validate the ordering */ + for (j = 0; j < num_ops; ++j) + ops_enq[j]->opaque_data = (void *)(uintptr_t)j; + + for (i = 0; i < TEST_REPETITIONS; ++i) { + + for (j = 0; j < num_ops; ++j) + mbuf_reset(ops_enq[j]->fft.base_output.data); + + start_time = rte_rdtsc_precise(); + + for (enq = 0, deq = 0; enq < num_ops;) { + num_to_enq = burst_sz; + + if (unlikely(num_ops - enq < num_to_enq)) + num_to_enq = num_ops - enq; + + enq += rte_bbdev_enqueue_fft_ops(tp->dev_id, + queue_id, &ops_enq[enq], num_to_enq); + + deq += rte_bbdev_dequeue_fft_ops(tp->dev_id, + queue_id, &ops_deq[deq], enq - deq); + } + + /* dequeue the remaining */ + while (deq < enq) { + deq += rte_bbdev_dequeue_fft_ops(tp->dev_id, + queue_id, &ops_deq[deq], enq - deq); + } + + total_time += rte_rdtsc_precise() - start_time; + } + + if (test_vector.op_type != RTE_BBDEV_OP_NONE) { + ret = validate_fft_op(ops_deq, num_ops, ref_op); + TEST_ASSERT_SUCCESS(ret, "Validation failed!"); + } + + rte_bbdev_fft_op_free_bulk(ops_enq, num_ops); + + double tb_len_bits = calc_fft_size(ref_op); + + tp->ops_per_sec = ((double)num_ops * TEST_REPETITIONS) / + ((double)total_time / (double)rte_get_tsc_hz()); + tp->mbps = (((double)(num_ops * TEST_REPETITIONS * tb_len_bits)) / + 1000000.0) / ((double)total_time / + (double)rte_get_tsc_hz()); + + return TEST_SUCCESS; +} + static void print_enc_throughput(struct thread_params *t_params, unsigned int used_cores) { @@ -3918,6 +4344,8 @@ throughput_test(struct active_device *ad, throughput_function = throughput_intr_lcore_enc; else if (test_vector.op_type == RTE_BBDEV_OP_LDPC_ENC) throughput_function = throughput_intr_lcore_ldpc_enc; + else if (test_vector.op_type == RTE_BBDEV_OP_FFT) + throughput_function = throughput_intr_lcore_fft; else throughput_function = throughput_intr_lcore_enc; @@ -3938,6 +4366,8 @@ throughput_test(struct active_device *ad, throughput_function = throughput_pmd_lcore_enc; else if (test_vector.op_type == RTE_BBDEV_OP_LDPC_ENC) throughput_function = throughput_pmd_lcore_ldpc_enc; + else if (test_vector.op_type == RTE_BBDEV_OP_FFT) + throughput_function = throughput_pmd_lcore_fft; else throughput_function = throughput_pmd_lcore_enc; } @@ -4327,6 +4757,74 @@ latency_test_ldpc_enc(struct rte_mempool *mempool, return i; } + +static int +latency_test_fft(struct rte_mempool *mempool, + struct test_buffers *bufs, struct rte_bbdev_fft_op *ref_op, + uint16_t dev_id, uint16_t queue_id, + const uint16_t num_to_process, uint16_t burst_sz, + uint64_t *total_time, uint64_t *min_time, uint64_t *max_time) +{ + int ret = TEST_SUCCESS; + uint16_t i, j, dequeued; + struct rte_bbdev_fft_op *ops_enq[MAX_BURST], *ops_deq[MAX_BURST]; + uint64_t start_time = 0, last_time = 0; + + for (i = 0, dequeued = 0; dequeued < num_to_process; ++i) { + uint16_t enq = 0, deq = 0; + bool first_time = true; + last_time = 0; + + if (unlikely(num_to_process - dequeued < burst_sz)) + burst_sz = num_to_process - dequeued; + + ret = rte_bbdev_fft_op_alloc_bulk(mempool, ops_enq, burst_sz); + TEST_ASSERT_SUCCESS(ret, + "rte_bbdev_fft_op_alloc_bulk() failed"); + if (test_vector.op_type != RTE_BBDEV_OP_NONE) + copy_reference_fft_op(ops_enq, burst_sz, dequeued, + bufs->inputs, + bufs->hard_outputs, bufs->soft_outputs, + ref_op); + + /* Set counter to validate the ordering */ + for (j = 0; j < burst_sz; ++j) + ops_enq[j]->opaque_data = (void *)(uintptr_t)j; + + start_time = rte_rdtsc_precise(); + + enq = rte_bbdev_enqueue_fft_ops(dev_id, queue_id, + &ops_enq[enq], burst_sz); + TEST_ASSERT(enq == burst_sz, + "Error enqueueing burst, expected %u, got %u", + burst_sz, enq); + + /* Dequeue */ + do { + deq += rte_bbdev_dequeue_fft_ops(dev_id, queue_id, + &ops_deq[deq], burst_sz - deq); + if (likely(first_time && (deq > 0))) { + last_time += rte_rdtsc_precise() - start_time; + first_time = false; + } + } while (unlikely(burst_sz != deq)); + + *max_time = RTE_MAX(*max_time, last_time); + *min_time = RTE_MIN(*min_time, last_time); + *total_time += last_time; + + if (test_vector.op_type != RTE_BBDEV_OP_NONE) { + ret = validate_fft_op(ops_deq, burst_sz, ref_op); + TEST_ASSERT_SUCCESS(ret, "Validation failed!"); + } + + rte_bbdev_fft_op_free_bulk(ops_enq, deq); + dequeued += deq; + } + + return i; +} + /* Common function for running validation and latency test cases */ static int validation_latency_test(struct active_device *ad, @@ -4378,6 +4876,12 @@ validation_latency_test(struct active_device *ad, ad->dev_id, queue_id, num_to_process, burst_sz, &total_time, &min_time, &max_time, latency_flag); + else if (op_type == RTE_BBDEV_OP_FFT) + iter = latency_test_fft(op_params->mp, bufs, + op_params->ref_fft_op, + ad->dev_id, queue_id, + num_to_process, burst_sz, &total_time, + &min_time, &max_time); else /* RTE_BBDEV_OP_TURBO_ENC */ iter = latency_test_enc(op_params->mp, bufs, op_params->ref_enc_op, @@ -4837,6 +5341,10 @@ offload_cost_test(struct active_device *ad, iter = offload_latency_test_ldpc_dec(op_params->mp, bufs, op_params->ref_dec_op, ad->dev_id, queue_id, num_to_process, burst_sz, &time_st); + else if (op_type == RTE_BBDEV_OP_FFT) + iter = offload_latency_test_fft(op_params->mp, bufs, + op_params->ref_fft_op, ad->dev_id, queue_id, + num_to_process, burst_sz, &time_st); else iter = offload_latency_test_enc(op_params->mp, bufs, op_params->ref_enc_op, ad->dev_id, queue_id, diff --git a/app/test-bbdev/test_bbdev_vector.c b/app/test-bbdev/test_bbdev_vector.c index f1c1fe09eb..1125395dbf 100644 --- a/app/test-bbdev/test_bbdev_vector.c +++ b/app/test-bbdev/test_bbdev_vector.c @@ -15,6 +15,7 @@ #define VALUE_DELIMITER "," #define ENTRY_DELIMITER "=" +#define FFT_WIN_SIZE 12 const char *op_data_prefixes[] = { "input", @@ -214,6 +215,35 @@ op_ldpc_decoder_flag_strtoul(char *token, uint32_t *op_flag_value) return 0; } + +/* Convert FFT flag from string to unsigned long int. */ +static int +op_fft_flag_strtoul(char *token, uint32_t *op_flag_value) +{ + if (!strcmp(token, "RTE_BBDEV_FFT_WINDOWING")) + *op_flag_value = RTE_BBDEV_FFT_WINDOWING; + else if (!strcmp(token, "RTE_BBDEV_FFT_CS_ADJUSTMENT")) + *op_flag_value = RTE_BBDEV_FFT_CS_ADJUSTMENT; + else if (!strcmp(token, "RTE_BBDEV_FFT_DFT_BYPASS")) + *op_flag_value = RTE_BBDEV_FFT_DFT_BYPASS; + else if (!strcmp(token, "RTE_BBDEV_FFT_IDFT_BYPASS")) + *op_flag_value = RTE_BBDEV_FFT_IDFT_BYPASS; + else if (!strcmp(token, "RTE_BBDEV_FFT_WINDOWING_BYPASS")) + *op_flag_value = RTE_BBDEV_FFT_WINDOWING_BYPASS; + else if (!strcmp(token, "RTE_BBDEV_FFT_POWER_MEAS")) + *op_flag_value = RTE_BBDEV_FFT_POWER_MEAS; + else if (!strcmp(token, "RTE_BBDEV_FFT_FP16_INPUT")) + *op_flag_value = RTE_BBDEV_FFT_FP16_INPUT; + else if (!strcmp(token, "RTE_BBDEV_FFT_FP16_OUTPUT")) + *op_flag_value = RTE_BBDEV_FFT_FP16_OUTPUT; + else { + printf("The given value is not a FFT flag\n"); + return -1; + } + + return 0; +} + /* convert turbo encoder flag from string to unsigned long int*/ static int op_encoder_flag_strtoul(char *token, uint32_t *op_flag_value) @@ -290,6 +320,10 @@ parse_turbo_flags(char *tokens, uint32_t *op_flags, if (op_ldpc_decoder_flag_strtoul(tok, &op_flag_value) == -1) return -1; + } else if (op_type == RTE_BBDEV_OP_FFT) { + if (op_fft_flag_strtoul(tok, &op_flag_value) + == -1) + return -1; } else { return -1; } @@ -317,6 +351,8 @@ op_turbo_type_strtol(char *token, enum rte_bbdev_op_type *op_type) *op_type = RTE_BBDEV_OP_LDPC_ENC; else if (!strcmp(token, "RTE_BBDEV_OP_LDPC_DEC")) *op_type = RTE_BBDEV_OP_LDPC_DEC; + else if (!strcmp(token, "RTE_BBDEV_OP_FFT")) + *op_type = RTE_BBDEV_OP_FFT; else if (!strcmp(token, "RTE_BBDEV_OP_NONE")) *op_type = RTE_BBDEV_OP_NONE; else { @@ -857,6 +893,111 @@ parse_ldpc_decoder_params(const char *key_token, char *token, return 0; } + +/* Parse FFT parameters and assigns to global variable. */ +static int +parse_fft_params(const char *key_token, char *token, + struct test_bbdev_vector *vector) +{ + int ret = 0, status = 0, i, shift; + uint32_t op_flags = 0; + char *tok, *err = NULL; + + struct rte_bbdev_op_fft *fft = &vector->fft; + + if (starts_with(key_token, op_data_prefixes[DATA_INPUT])) { + ret = parse_data_entry(key_token, token, vector, + DATA_INPUT, + op_data_prefixes[DATA_INPUT]); + } else if (starts_with(key_token, "output")) { + ret = parse_data_entry(key_token, token, vector, + DATA_HARD_OUTPUT, + "output"); + } else if (starts_with(key_token, "power_output")) { + ret = parse_data_entry(key_token, token, vector, + DATA_SOFT_OUTPUT, + "power_output"); + } else if (!strcmp(key_token, "in_sequence_size")) { + fft->input_sequence_size = (uint32_t) strtoul(token, &err, 0); + ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; + } else if (!strcmp(key_token, "in_leading_padding")) { + fft->input_leading_padding = (uint32_t) strtoul(token, &err, 0); + ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; + } else if (!strcmp(key_token, "out_sequence_size")) { + fft->output_sequence_size = (uint32_t) strtoul(token, &err, 0); + ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; + } else if (!strcmp(key_token, "out_leading_depadding")) { + fft->output_leading_depadding = (uint32_t) strtoul(token, &err, 0); + ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; + } else if (!strcmp(key_token, "window_index")) { + tok = strtok(token, VALUE_DELIMITER); + if (tok == NULL) + return -1; + for (i = 0; i < FFT_WIN_SIZE; i++) { + shift = (i % 2) ? 4 : 0; + fft->window_index[i / 2] |= (uint32_t) strtoul(tok, &err, 0) + << shift; + if (i < (FFT_WIN_SIZE - 1)) { + tok = strtok(NULL, VALUE_DELIMITER); + if (tok == NULL) + return -1; + } + } + ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; + } else if (!strcmp(key_token, "cs_bitmap")) { + fft->cs_bitmap = (uint32_t) strtoul(token, &err, 0); + ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; + } else if (!strcmp(key_token, "num_antennas_log2")) { + fft->num_antennas_log2 = (uint32_t) strtoul(token, &err, 0); + ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; + } else if (!strcmp(key_token, "ifft_log2")) { + fft->idft_log2 = (uint32_t) strtoul(token, &err, 0); + ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; + } else if (!strcmp(key_token, "fft_log2")) { + fft->dft_log2 = (uint32_t) strtoul(token, &err, 0); + ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; + } else if (!strcmp(key_token, "cs_time_adjustment")) { + fft->cs_time_adjustment = (uint32_t) strtoul(token, &err, 0); + ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; + } else if (!strcmp(key_token, "ifft_shift")) { + fft->idft_shift = (uint32_t) strtoul(token, &err, 0); + ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; + } else if (!strcmp(key_token, "fft_shift")) { + fft->dft_shift = (uint32_t) strtoul(token, &err, 0); + ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; + } else if (!strcmp(key_token, "ncs_reciprocal")) { + fft->ncs_reciprocal = (uint32_t) strtoul(token, &err, 0); + ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; + } else if (!strcmp(key_token, "power_shift")) { + fft->power_shift = (uint32_t) strtoul(token, &err, 0); + ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; + } else if (!strcmp(key_token, "fp16_exponent_adjust")) { + fft->fp16_exp_adjust = (uint32_t) strtoul(token, &err, 0); + printf("%d\n", fft->fp16_exp_adjust); + ret = ((err == NULL) || (*err != '\0')) ? -1 : 0; + } else if (!strcmp(key_token, "op_flags")) { + vector->mask |= TEST_BBDEV_VF_OP_FLAGS; + ret = parse_turbo_flags(token, &op_flags, vector->op_type); + if (!ret) + fft->op_flags = op_flags; + } else if (!strcmp(key_token, "expected_status")) { + vector->mask |= TEST_BBDEV_VF_EXPECTED_STATUS; + ret = parse_expected_status(token, &status, vector->op_type); + if (!ret) + vector->expected_status = status; + } else { + printf("Not valid fft key: '%s'\n", key_token); + return -1; + } + + if (ret != 0) { + printf("Failed with convert '%s\t%s'\n", key_token, token); + return -1; + } + + return 0; +} + /* checks the type of key and assigns data */ static int parse_entry(char *entry, struct test_bbdev_vector *vector) @@ -908,6 +1049,9 @@ parse_entry(char *entry, struct test_bbdev_vector *vector) } else if (vector->op_type == RTE_BBDEV_OP_LDPC_DEC) { if (parse_ldpc_decoder_params(key_token, token, vector) == -1) return -1; + } else if (vector->op_type == RTE_BBDEV_OP_FFT) { + if (parse_fft_params(key_token, token, vector) == -1) + return -1; } return 0; @@ -979,6 +1123,21 @@ check_ldpc_decoder_segments(struct test_bbdev_vector *vector) return 0; } +static int +check_fft_segments(struct test_bbdev_vector *vector) +{ + unsigned char i; + + for (i = 0; i < vector->entries[DATA_INPUT].nb_segments; i++) + if (vector->entries[DATA_INPUT].segments[i].addr == NULL) + return -1; + + for (i = 0; i < vector->entries[DATA_HARD_OUTPUT].nb_segments; i++) + if (vector->entries[DATA_HARD_OUTPUT].segments[i].addr == NULL) + return -1; + return 0; +} + static int check_decoder_llr_spec(struct test_bbdev_vector *vector) { @@ -1192,6 +1351,26 @@ check_ldpc_decoder(struct test_bbdev_vector *vector) return 0; } +/* Checks fft parameters. */ +static int +check_fft(struct test_bbdev_vector *vector) +{ + const int mask = vector->mask; + + if (check_fft_segments(vector) < 0) + return -1; + + /* Check which params were set. */ + if (!(mask & TEST_BBDEV_VF_OP_FLAGS)) { + printf( + "WARNING: op_flags was not specified in vector file and capabilities will not be validated\n"); + } + if (!(mask & TEST_BBDEV_VF_EXPECTED_STATUS)) + printf( + "WARNING: expected_status was not specified in vector file and will be set to 0\n"); + return 0; +} + /* checks encoder parameters */ static int check_encoder(struct test_bbdev_vector *vector) @@ -1350,6 +1529,9 @@ bbdev_check_vector(struct test_bbdev_vector *vector) } else if (vector->op_type == RTE_BBDEV_OP_LDPC_DEC) { if (check_ldpc_decoder(vector) == -1) return -1; + } else if (vector->op_type == RTE_BBDEV_OP_FFT) { + if (check_fft(vector) == -1) + return -1; } else if (vector->op_type != RTE_BBDEV_OP_NONE) { printf("Vector was not filled\n"); return -1; diff --git a/app/test-bbdev/test_bbdev_vector.h b/app/test-bbdev/test_bbdev_vector.h index 4e5dbf5d50..4c53e8f137 100644 --- a/app/test-bbdev/test_bbdev_vector.h +++ b/app/test-bbdev/test_bbdev_vector.h @@ -65,6 +65,7 @@ struct test_bbdev_vector { struct rte_bbdev_op_turbo_enc turbo_enc; struct rte_bbdev_op_ldpc_dec ldpc_dec; struct rte_bbdev_op_ldpc_enc ldpc_enc; + struct rte_bbdev_op_fft fft; }; /* Additional storage for op data entries */ struct op_data_entries entries[DATA_NUM_TYPES]; diff --git a/app/test-bbdev/test_vectors/fft_150.data b/app/test-bbdev/test_vectors/fft_150.data new file mode 100644 index 0000000000..27425ffd95 --- /dev/null +++ b/app/test-bbdev/test_vectors/fft_150.data @@ -0,0 +1,475 @@ +# SPDX-License-Identifier: BSD-3-Clause +# Copyright(c) 2021 Intel Corporation +op_type = +RTE_BBDEV_OP_FFT + +input0 = +0x0045F880, 0xECCCF23C, 0xFD67F739, 0x09A6FA7B, 0xF8B2EF62, 0xFC74F9DC, 0x01A6F7EE, 0xFE7CE87A, +0x04B1FC1C, 0x0DB00A15, 0xFFD1F5DC, 0xF13AFFCF, 0x03D6FB71, 0xFD7AF000, 0x0EF1F7C4, 0x02C515F8, +0x0060F277, 0xF71AF467, 0x030BF7CF, 0x050EE88F, 0x0CA105EE, 0xFB0C1403, 0x02E3FC82, 0xFD8FF668, +0xFDCFFB0C, 0x0B5FED2F, 0x0BC5FF03, 0xF10A138C, 0x0687F859, 0xF819FA87, 0x03B2EFFA, 0x149AFD2D, +0x10820F4B, 0xE4CD0412, 0x0B4DFD23, 0xF902F2DD, 0x0FD2FB46, 0x0CAEFEC6, 0x00291412, 0xEF93F2F1, +0x0561FD59, 0x03A3EED9, 0x0F100022, 0x055BFB6E, 0xF73D0F24, 0xFE62F189, 0x0EE3FF31, 0x0D6CF9AE, +0x0A6B0B3B, 0x16BDFAAE, 0xECFBFBD0, 0x0C53FC19, 0x0C03050D, 0x075703E7, 0x01340C31, 0x1C5104D2, +0x07D6F986, 0x042008BF, 0x0F050CEF, 0xFE650849, 0x05DB00B8, 0xFF8EF7BB, 0x09D40B9B, 0xFD240127, +0x0C670A29, 0x03410652, 0x088204FA, 0x0B0CFA8E, 0x01A10AAA, 0xFA9403DD, 0xFEBD0A5C, 0xFD800534, +0x03EC03FF, 0x01B2FEC4, 0xFC19106B, 0xFA13FAB7, 0xFC70FAC0, 0xF6E60396, 0x0610FCAF, 0x0D47F9BB, +0xE91009D2, 0x03F8F6C0, 0x0556EFCF, 0xF8B3FA78, 0x031301F4, 0x1171F830, 0xE975FA29, 0x061A0002, +0x0EBBF9E5, 0x06F9FBC2, 0x0921F949, 0x13A5093E, 0xEEEAF7C3, 0x0297088B, 0x107200BF, 0x0813059D, +0x03D00AC7, 0x077F0A23, 0xF9DDEDDD, 0xF3310C41, 0x0E6B0474, 0x09A60B0C, 0xFAEE0BFF, 0x059B0363, +0xFF60F717, 0xF2D301E1, 0x0A6B0F45, 0xF9A61062, 0xF05702EC, 0xFD0B0096, 0xFCAFFE58, 0xF380FFCA, +0xFBA70D93, 0xF7590DB0, 0xFD7EF9F2, 0x0212FA7F, 0xF48CF927, 0xF9BFFA04, 0xF5180873, 0xECAB0BDD, +0x0392FDE3, 0xF49C0178, 0xFBE10480, 0xFCD005DE, 0xF77AFC6C, 0x04D21B68, 0x06E8FB97, 0xF97D0589, +0x0073038E, 0xFAAC0CFA, 0xFAD2F735, 0xF711143A, 0x03A80070, 0xEF16F5BC, 0x08D10142, 0xF898FFC1, +0x0F3600DD, 0xF71F0F80, 0x060002F9, 0x00E0F2DC, 0x001510D9, 0xF7091034, 0x00B10E23, 0xF0930ADA, +0xF94BFDC0, 0x0D01FF7F, 0xFD300AB9, 0xEC71F9C4, 0xEFE90A6B, 0xFB54077D, 0x0242FFCA, 0xFC040764, +0xF6520853, 0xEFCBF9B0, 0xF078F591, 0xEFDC075F, 0xFB90FE11, 0xF6720114, 0xF46B01E9, 0xF910EE5C, +0xFCEEF607, 0xFC1C0747, 0xF45A0747, 0xFEC0F536, 0xF499FC22, 0xF8BDF5B9, 0x0008F819, 0xF2EA06D3, +0xECC0F5F8, 0xFF6A019A, 0xF768FB84, 0xFA6AEEF7, 0xFC76ED5D, 0xF2DAFE6F, 0xF8CDEE7B, 0xFBF9F582, +0xFBA5FF70, 0x102CEFFB, 0x11D6F605, 0xF2D8FF30, 0x16B80258, 0x1B5C0A90, 0x0254F00A, 0x0D01FE59, +0xF3F606B2, 0xEE7DF945, 0x01F70813, 0x0C6F0FD1, 0x0E19F73D, 0x0C6E0B28, 0xF3DBF44E, 0xF5FAFBA7, +0xFF17FB8B, 0x001711CE, 0x1150FFBF, 0xFAB813C9, 0xFFB9F052, 0xFDCBFD40, 0xFEDEF439, 0xF6F506C1, +0x0D3F0B92, 0xF653082C, 0x0FD3EED4, 0xF35C0C40, 0x0D03F532, 0xF8BEF6F4, 0x089E0AF2, 0xF5CDFE92, +0x0D4D0066, 0xDE0BFC57, 0x0313FFBD, 0x0A1CF617, 0xFCB50B2D, 0xF716F3F2, 0x05750B36, 0xE317EBF4, +0x0575FA3F, 0x198FF7EE, 0xF7D7FD10, 0x055AF424, 0xF3E1066B, 0xEF07E1FE, 0x06AE05DC, 0x1E6A144F, +0x03AAF657, 0x0BAAFC47, 0xEF79FC2B, 0x04DEE328, 0x004307F4, 0xFFE62BC2, 0x066FF912, 0x0C0B08BE, +0xF214F1CF, 0x1098E4D4, 0xF646075D, 0xDDEE1B37, 0x0A2003E8, 0xFB220C15, 0xFD97EB2D, 0x22DFF4E4, +0xFFE103BA, 0x06B90018, 0xE8D0FD9B, 0x079C042D, 0x0461140A, 0xF128E902, 0x00A703D7, 0xFDA60314, +0xF867E630, 0x02D0016A, 0xFA93016D, 0xFACDED5D, 0xFE20F99B, 0x0668FF2F, 0x103EF130, 0x076B0C07, +0x03FDFE6B, 0xFF2DEF7B, 0x0EA00057, 0xFC3B03C5, 0x0C60F638, 0xF6F60CFF, 0x02B30292, 0x0352F4D6, +0x0471098C, 0x08F60577, 0x0D1EF980, 0xF7940796, 0x06ED05A2, 0x020EF43D, 0xFDF80AD0, 0xFD990A58, +0x07F7F963, 0xF5FE083C, 0x0557094E, 0x01D1F697, 0xF35AFB3F, 0xFF5C06BE, 0x095AFFC8, 0xF80009C9, +0x02A710FF, 0x0048F8AA, 0x0704FF0F, 0xFA6A073F, 0xFB9EFE56, 0xF1D705E4, 0xEDE00D22, 0x0157F415, +0xFB9405ED, 0xF243FD80, 0xFF25F4F8, 0xFA5E009C, 0xF27DF61C, 0x00E3F77E, 0xFA05FD5F, 0xFA09FD6E, +0x0864EC8B, 0xF97B02CC, 0xFC3EF436, 0x03FEF382, 0xF6F2E9CE, 0x01980635, 0x0700F5C5, 0x0501FE82, +0x07D4179D, 0x0C60FAF3, 0x067EF432, 0xFC4A11B2, 0x0333FFBF, 0x078AFE72, 0xFE0E04E8, 0x0037FC38, +0xFE76F88D, 0xE4D901F7, 0xFF89FC59, 0x00E4042C, 0xFE28FE54, 0x001EFC87, 0x0648F601, 0xF619F4BA, +0xFBAFFB71, 0xFE63FC4B, 0x06BEFC69, 0x005EF4B2, 0x0B3BFA0F, 0xF908ED66, 0x06C8FCC1, 0xFC02FB29, +0x096300E4, 0xFE90F883, 0x0CD3FABD, 0x0837F910, 0x04F104EE, 0xFB89F2FA, 0x1465F676, 0x040AECD2, +0x0DEBFC4F, 0x02A1FEA2, 0x03AD06FD, 0xFF75F312, 0x20B214D2, 0x12F4EEEB, 0x177BF940, 0x06150C7C, +0x06E10440, 0x045CF3F2, 0x07A11E82, 0x1B3D0354, 0x1CBD0781, 0xF94A0E30, 0x05E30ABE, 0x0F2FFE27, +0xECEA1667, 0x14B61272, 0x0FED10D4, 0xF55B09D8, 0xFECE0ED2, 0x05D505D1, 0xEB29FE95, 0xFC721777, +0x03FD113D, 0xFA2C0A5A, 0xED320FB3, 0xEC81F68C, 0xF9040DB4, 0x0BE20023, 0xFBEE11AE, 0xF13E0693, +0xEB83F95F, 0xE753E84B, 0xF473089F, 0x0F7513EE, 0xFACD0FD5, 0xF18405D6, 0xFDCAFB07, 0x00C0DCF9, +0xF8910062, 0xF5B61FDA, 0x00B30BA8, 0xEFDBF4D1, 0x01E3F964, 0x1022ED24, 0xFB2E00F2, 0xE2F2121B, +0xF648103C, 0xFC37F033, 0x01F008DA, 0x1ACA006D, 0x0149FAAF, 0xDA1102AF, 0xF7C0FB90, 0x0159F1C1, +0xFFA1F6A2, 0x0A670C88, 0xFBB8065E, 0xE2B0E7D7, 0x020CFDF1, 0x062BF33E, 0xF9BBFF96, 0x069F1006, +0xF5F90101, 0xF9C5E90C, 0x059A05A8, 0x0871FA77, 0xFD03F367, 0xF8C30AF3, 0xF01FFDC5, 0x032BEF57, +0xFC5006AF, 0x0AE6FAEB, 0xFBA1F53B, 0xF737FB17, 0xF606EDAC, 0x05A8FB9F, 0xF251FABF, 0xFEE7FE24, +0x002DED77, 0x078DF830, 0xFC05F432, 0xF97A0159, 0xF9FEFA95, 0x08750AE2, 0x00D207B6, 0xF20609CC, +0x022EFCEF, 0xF9F90548, 0x00B40448, 0xF8A1138D, 0xF4FD0970, 0xF78F00A9, 0x0FA708DF, 0xF956FF7D, +0xF6A3FB8F, 0xF17C1586, 0xF4B502D3, 0xFCB800D3, 0x04181149, 0xFA83FC1F, 0xFFF1FD34, 0xE32C0CA0, +0xEF5102A9, 0xF5E9066F, 0xF7710B39, 0x044BFAE8, 0xF9D0F411, 0xE272F450, 0xF4B70075, 0xE9D5F7B8, +0xFDD20A3D, 0x04BD0583, 0x0426F51B, 0xFE04E90D, 0xF6A0FE91, 0xF54BF1EE, 0xF31A1044, 0xFC7301C2, +0x0A47FA02, 0x0BFAFB7A, 0xFA1B02BE, 0xF9F1EDE8, 0xE6480785, 0x0036FA63, 0x0F16FD67, 0x02271162, +0xEF750160, 0xFFDCEDF6, 0xEAA6F638, 0x021FFD54, 0x09F90BFF, 0xEA51097B, 0xE748F88B, 0x1267EECF, +0xF67AF42C, 0xFF320402, 0x051A0BA4, 0xE993FB67, 0xEC16E90B, 0x159CFD51, 0xFC1BF3FC, 0xF59001F7 + +output0 = +0xFDD80630, 0xFBC50489, 0xFA60025A, 0xF9C2FFF1, 0xF9E2FD94, 0xFAA8FB79, 0xFBECF9C9, 0xFD89F89A, +0xFF52F7FF, 0x011AF7FD, 0x02ACF88E, 0x03D3F995, 0x0467FADC, 0x0459FC1E, 0x03BFFD10, 0x02D6FD78, +0x01EEFD46, 0x015AFC93, 0x014FFBA5, 0x01D5FAD1, 0x02C3FA65, 0x03CDFA87, 0x049EFB2C, 0x04F8FC1E, +0x04C8FD0C, 0x042BFDAB, 0x0364FDD1, 0x02BCFD80, 0x026EFCE4, 0x028EFC40, 0x0307FBD0, 0x03A8FBB9, +0x0439FBFA, 0x0490FC76, 0x049DFD01, 0x046EFD75, 0x041EFDBD, 0x03C8FDDA, 0x037BFDDA, 0x0338FDCC, +0x02F5FDB2, 0x02ACFD82, 0x0266FD2B, 0x023AFCA4, 0x024CFBF5, 0x02B3FB3F, 0x0375FAB2, 0x0476FA7C, +0x0586FAB6, 0x0668FB59, 0x06F1FC3B, 0x0715FD23, 0x06EDFDDB, 0x06B0FE48, 0x0696FE78, 0x06C4FEA0, +0x0739FEFE, 0x07C4FFCD, 0x081A011C, 0x07E902CF, 0xFE86FEB1, 0xFF03FE27, 0xFFA2FDBC, 0x005EFD78, +0x012DFD63, 0x0204FD81, 0x02D5FDD2, 0x0393FE53, 0x0436FEFC, 0x04B6FFC5, 0x051000A4, 0x05440193, +0x0552028D, 0x0538038E, 0x04F40492, 0x04810593, 0x03DD0687, 0x03070762, 0x02030815, 0x00DE0894, +0xFFA508D7, 0xFE6C08DB, 0xFD4608A9, 0xFC3D084D, 0xFB5707D8, 0xFA8F075A, 0xF9D806DD, 0xF9250663, +0xF86705E2, 0xF797054A, 0xF6BA0488, 0xF5DE038A, 0xF51A0246, 0xF48D00BF, 0xF44FFF02, 0xF476FD29, +0xF50AFB54, 0xF606F9A3, 0xF75BF833, 0xF8F3F718, 0xFAB3F65A, 0xFC84F5FB, 0xFE4FF5F7, 0x0007F645, +0x019FF6DC, 0x030EF7B6, 0x044AF8CB, 0x0548FA14, 0x05FCFB87, 0x065BFD11, 0x065EFE9F, 0x06050017, +0x05590160, 0x046B0265, 0x03520318, 0x022A0373, 0x010C037B, 0x000D033A, 0xFF3C02C3, 0xFE9F0227, +0x0027FD69, 0x009DFDA4, 0x0114FDDC, 0x0188FE10, 0x01F5FE3E, 0x0257FE65, 0x02AEFE85, 0x02F9FEA1, +0x033AFEBA, 0x0374FED3, 0x03A8FEF0, 0x03DCFF14, 0x0412FF44, 0x044CFF83, 0x048CFFD4, 0x04D00039, +0x051700B4, 0x055B0143, 0x059901E5, 0x05C70297, 0x05E00353, 0x05DA0414, 0x05B104D3, 0x055C0588, +0x04DA062D, 0x042806BA, 0x034A0728, 0x02410773, 0x01180797, 0xFFD60791, 0xFE890761, 0xFD3C0707, +0xFBFD0688, 0xFADA05E6, 0xF9DD0529, 0xF9120457, 0xF87E0377, 0xF8260290, 0xF80A01AA, 0xF82800CB, +0xF87BFFF9, 0xF8FBFF39, 0xF99CFE8E, 0xFA54FDF8, 0xFB17FD7A, 0xFBD9FD12, 0xFC90FCBF, 0xFD33FC7E, +0xFDBCFC4D, 0xFE27FC29, 0xFE74FC0F, 0xFEA2FBFF, 0xFEB7FBF5, 0xFEB7FBF2, 0xFEAAFBF4, 0xFE96FBFC, +0xFE85FC0A, 0xFE7BFC20, 0xFE80FC3C, 0xFE97FC60, 0x00A6FF39, 0x0142FE82, 0x01BCFDFB, 0x020CFDAE, +0x022EFDA0, 0x0223FDCE, 0x01F2FE35, 0x01A6FECC, 0x014DFF84, 0x00F5004F, 0x00AC011B, 0x007C01DA, +0x006B027D, 0x007A02FA, 0x00A6034C, 0x00E60372, 0x01310370, 0x0178034E, 0x01AD0318, 0x01C402DA, +0x01B4029F, 0x01750274, 0x0105025D, 0x0067025D, 0xFFA10270, 0xFEBE028F, 0xFDC902B0, 0xFCD202C3, +0xFBE602BC, 0xFB15028D, 0xFA6A022D, 0xF9F10196, 0xF9B100C9, 0xF9B0FFCC, 0xF9F1FEAA, 0xFA72FD75, +0xFB30FC40, 0xFC24FB1F, 0xFD45FA28, 0xFE86F96C, 0xFFDBF8FA, 0x0133F8DA, 0x027EF910, 0x03A9F999, +0x04A6FA6E, 0x0565FB82, 0x05DCFCC4, 0x0604FE24, 0x05DCFF8E, 0x056600F0, 0x04AC0239, 0x03BD035A, +0x02AC0448, 0x018D04FA, 0x0078056A, 0xFF810597, 0xFEBB0580, 0xFE32052B, 0xFDEE049D, 0xFDF103E0, +0xFDBE04AC, 0xFD860450, 0xFD5703F6, 0xFD28039D, 0xFCF40343, 0xFCB002E6, 0xFC5B0283, 0xFBF1021A, +0xFB7501A5, 0xFAEE0124, 0xFA650094, 0xF9E6FFF4, 0xF97DFF44, 0xF939FE85, 0xF925FDB9, 0xF949FCE5, +0xF9ABFC0F, 0xFA4CFB3E, 0xFB27FA7D, 0xFC33F9D5, 0xFD65F953, 0xFEAEF8FF, 0xFFFEF8E4, 0x0145F907, +0x0273F96A, 0x037CFA0D, 0x0457FAEA, 0x04FCFBF5, 0x0568FD20, 0x059DFE5A, 0x059EFF8F, 0x057100AC, +0x051D01A0, 0x04AC025B, 0x042502D5, 0x0394030A, 0x030002FB, 0x027202B0, 0x01F20236, 0x0186019E, +0x013300FB, 0x00FC0060, 0x00E4FFDF, 0x00EAFF88, 0x010CFF64, 0x0146FF7A, 0x0193FFC8, 0x01E9004B, +0x024100F8, 0x029101C3, 0x02CF029E, 0x02F40378, 0x02FA0446, 0x02DD04FB, 0x029C058F, 0x023A05FC, +0x01BC0641, 0x012A065F, 0x008D065A, 0xFFF00638, 0x005C01BF, 0x001901E6, 0xFFB501EC, 0xFF4F01C0, +0xFF090169, 0xFEF90105, 0xFF1C00B5, 0xFF5A0093, 0xFF9100A3, 0xFFA600D2, 0xFF910101, 0xFF610116, +0xFF310108, 0xFF1D00E1, 0xFF3000C2, 0xFF6100C8, 0xFF8B0108, 0xFF86017A, 0xFF3401FC, 0xFE8C025D, +0xFDA9026E, 0xFCB80215, 0xFBF40153, 0xFB88004C, 0xFB8BFF33, 0xFBF2FE3B, 0xFC9DFD88, 0xFD62FD28, +0xFE1BFD10, 0xFEB2FD28, 0xFF25FD57, 0xFF79FD8D, 0xFFBBFDC4, 0xFFEFFDFD, 0x0014FE3D, 0x0024FE7F, +0x001EFEBB, 0x0003FEE6, 0xFFE2FEF7, 0xFFC9FEF3, 0xFFC3FEE6, 0xFFCDFEE2, 0xFFD7FEF1, 0xFFCCFF11, +0xFF99FF2B, 0xFF42FF20, 0xFEDFFED0, 0xFE9FFE31, 0xFEB3FD56, 0xFF41FC71, 0x004AFBC7, 0x01AAFB99, +0x0319FC0C, 0x0446FD19, 0x04EBFE90, 0x04E80020, 0x044B0176, 0x034B0257, 0x023302AC, 0x0148028E, +0xFCA6FDD9, 0xFDA9FCEF, 0xFF0FFC63, 0x00A8FC61, 0x0230FCF4, 0x036AFE08, 0x042BFF6D, 0x046600EA, +0x0428024B, 0x03920370, 0x02C7044D, 0x01E104E6, 0x00EF0548, 0xFFF50578, 0xFEF10577, 0xFDE80539, +0xFCEA04B7, 0xFC1003EC, 0xFB7402E5, 0xFB2A01BC, 0xFB380093, 0xFB92FF88, 0xFC1DFEB0, 0xFCBDFE0C, +0xFD5EFD8F, 0xFDF7FD23, 0xFE96FCB6, 0xFF4EFC45, 0x0035FBDC, 0x0156FB98, 0x02A8FB9C, 0x040FFC03, +0x0560FCD9, 0x066EFE15, 0x0714FF95, 0x073F012E, 0x06F202AE, 0x064603EE, 0x055F04D3, 0x04680557, +0x03870589, 0x02D90580, 0x02680561, 0x0230054E, 0x021E0562, 0x021005AE, 0x01E4062E, 0x017906CF, +0x00BC076D, 0xFFAE07DC, 0xFE6707F4, 0xFD10079C, 0xFBDF06D3, 0xFB0205B2, 0xFA960469, 0xFA9C032F, +0xFAF90232, 0xFB7B018B, 0xFBF10134, 0xFC33010A, 0xFE97FE54, 0xFF28FE55, 0xFFB0FE80, 0x0022FECF, +0x0074FF36, 0x00A4FFA9, 0x00B4001E, 0x00A9008D, 0x008600F4, 0x00500151, 0x000801A2, 0xFFAE01E6, +0xFF430217, 0xFECB0233, 0xFE490235, 0xFDC4021B, 0xFD4001E4, 0xFCC4018F, 0xFC56011E, 0xFBFB0090, +0xFBBDFFE9, 0xFBA3FF2E, 0xFBB7FE69, 0xFBFCFDA9, 0xFC70FCFF, 0xFD0AFC7A, 0xFDB7FC23, 0xFE64FBFD, +0xFF00FBFC, 0xFF81FC11, 0xFFE9FC29, 0x0041FC36, 0x009DFC33, 0x010CFC27, 0x0199FC22, 0x0243FC39, +0x02FDFC7B, 0x03B6FCF3, 0x0456FD9D, 0x04CFFE6F, 0x0517FF58, 0x052E0049, 0x05180137, 0x04DB021E, +0x047A02F9, 0x03F203C8, 0x03410482, 0x0265051D, 0x01620586, 0x004605AF, 0xFF29058E, 0xFE240526, +0xFD4D0483, 0xFCB503BD, 0xFC5C02EC, 0xFC3B0226, 0xFC420179, 0xFC5F00E7, 0xFC860069, 0xFCB4FFF7, +0x0222FC61, 0x01C3FD5D, 0x0145FE80, 0x00BDFFB9, 0x003B00F2, 0xFFD00218, 0xFF830314, 0xFF5803D6, +0xFF490453, 0xFF4D0486, 0xFF560473, 0xFF550422, 0xFF3D03A5, 0xFF01030F, 0xFE9B0275, 0xFE0C01EA, +0xFD58017C, 0xFC8A0135, 0xFBB10116, 0xFADC0118, 0xFA1A012E, 0xF97A0149, 0xF9030153, 0xF8BC013D, +0xF8A300F8, 0xF8B5007C, 0xF8EBFFCA, 0xF93CFEE9, 0xF99FFDE9, 0xFA0CFCDF, 0xFA80FBE3, 0xFAF6FB0D, +0xFB70FA74, 0xFBEFFA27, 0xFC75FA30, 0xFD03FA8E, 0xFD97FB39, 0xFE2DFC21, 0xFEBFFD31, 0xFF42FE51, +0xFFA9FF69, 0xFFE90061, 0xFFF6012A, 0xFFCA01B6, 0xFF650200, 0xFEC9020A, 0xFE0301DA, 0xFD240179, +0xFC4200F3, 0xFB750054, 0xFAD3FFA7, 0xFA70FEF5, 0xFA5CFE43, 0xFA9BFD97, 0xFB2BFCF2, 0xFC01FC58, +0xFD0AFBCD, 0xFE30FB53, 0xFF56FAF2, 0x0064FAB2, 0x00890181, 0x00D30200, 0x011A0274, 0x015102DA, +0x016D0331, 0x01650378, 0x013403AE, 0x00D703D4, 0x005303EA, 0xFFAE03EE, 0xFEF503E0, 0xFE3703BC, +0xFD830380, 0xFCE90329, 0xFC7702B5, 0xFC370224, 0xFC300178, 0xFC6400B6, 0xFCD1FFE5, 0xFD6FFF10, +0xFE36FE44, 0xFF17FD8E, 0x0005FCFD, 0x00F3FC9D, 0x01D4FC77, 0x029CFC92, 0x0342FCEE, 0x03C1FD87, +0x0412FE54, 0x0435FF48, 0x042A0052, 0x03F1015F, 0x038F025D, 0x0307033C, 0x026003EE, 0x01A1046A, +0x00D304AC, 0xFFFE04B2, 0xFF2C0483, 0xFE690426, 0xFDBE03A6, 0xFD33030E, 0xFCD10269, 0xFC9C01C3, +0xFC960124, 0xFCBC0090, 0xFD0B000D, 0xFD78FF9A, 0xFDFBFF39, 0xFE87FEE7, 0xFF0FFEA4, 0xFF88FE6E, +0xFFEBFE46, 0x0030FE2B, 0x0057FE21, 0x0060FE27, 0x0053FE42, 0x0038FE71, 0x0017FEB6, 0xFFFCFF0F, +0x0125006D, 0x0124009C, 0x011900C4, 0x010500E1, 0x00E900F2, 0x00C400F7, 0x009400EF, 0x005700DF, +0x000D00C7, 0xFFB400AA, 0xFF4E008B, 0xFEDB006B, 0xFE610047, 0xFDE4001C, 0xFD6CFFE8, 0xFCFEFFA4, +0xFCA3FF4B, 0xFC60FED7, 0xFC3DFE44, 0xFC3DFD93, 0xFC63FCC4, 0xFCB0FBDE, 0xFD24FAEA, 0xFDBEF9F5, +0xFE79F90E, 0xFF52F845, 0x0042F7AC, 0x0146F751, 0x0255F740, 0x0368F782, 0x0478F819, 0x057BF903, +0x0668FA38, 0x0737FBAC, 0x07DDFD4D, 0x0853FF09, 0x089100CA, 0x0893027C, 0x0854040D, 0x07D7056D, +0x0720068E, 0x0635076A, 0x052307FD, 0x03F50846, 0x02BD084A, 0x018A0810, 0x006B07A0, 0xFF6F0705, +0xFEA0064B, 0xFE07057C, 0xFDA504A2, 0xFD7C03C8, 0xFD8602F6, 0xFDBC0234, 0xFE130188, 0xFE8100F5, +0xFEFA0080, 0xFF73002A, 0xFFE5FFF2, 0x0048FFD7, 0x009B0546, 0xFF380441, 0xFE78030A, 0xFE3E01F7, +0xFE4A0134, 0xFE5600BD, 0xFE390065, 0xFDF4FFF3, 0xFDB0FF42, 0xFDA7FE52, 0xFE06FD4F, 0xFED5FC7C, +0xFFF0FC16, 0x0111FC3A, 0x01EFFCD6, 0x0256FDB0, 0x0241FE7E, 0x01D6FF02, 0x0154FF22, 0x00FBFEF1, +0x00F0FEA2, 0x012DFE73, 0x0189FE8E, 0x01C8FEFA, 0x01B8FF95, 0x01450027, 0x00810078, 0xFF9C0063, +0xFECFFFE6, 0xFE49FF21, 0xFE1CFE41, 0xFE3EFD74, 0xFE91FCD4, 0xFEF3FC61, 0xFF51FC0E, 0xFFA7FBC4, +0x0001FB78, 0x006DFB2D, 0x00F4FAF2, 0x018FFAD7, 0x022DFAE5, 0x02BAFB17, 0x032DFB5E, 0x0387FBA8, +0x03D8FBED, 0x042EFC35, 0x048BFC92, 0x04E0FD16, 0x050EFDC4, 0x04F4FE87, 0x0484FF2F, 0x03D0FF87, +0x030EFF69, 0x0288FED5, 0x0286FDF8, 0x0327FD29, 0x0458FCCA, 0x05CCFD26, 0x0713FE54, 0x07BF0029, +0x03FDFFC6, 0x02AB010C, 0x01510192, 0x00470181, 0xFFBC0127, 0xFFB200D7, 0x000100D4, 0x00640140, +0x00940211, 0x0058031C, 0xFF97041C, 0xFE6104C5, 0xFCEA04E0, 0xFB7F044F, 0xFA770323, 0xFA1A0195, +0xFA8F0000, 0xFBCBFECD, 0xFD92FE58, 0xFF7BFED7, 0x010C0046, 0x01D90265, 0x019F04C4, 0x005F06DC, +0xFE5C083C, 0xFC0A08A0, 0xF9ED080D, 0xF87406CC, 0xF7D1054F, 0xF7EF0413, 0xF87E036D, 0xF90B0378, +0xF92D0407, 0xF8A904BC, 0xF7830526, 0xF60104F0, 0xF48B03FA, 0xF3890262, 0xF33E007B, 0xF3B6FEAD, +0xF4C2FD51, 0xF612FC94, 0xF74DFC73, 0xF835FCBD, 0xF8B2FD32, 0xF8D3FD97, 0xF8BEFDCD, 0xF898FDD4, +0xF875FDBF, 0xF852FD9F, 0xF81CFD76, 0xF7C4FD2E, 0xF751FCA1, 0xF6E9FBAD, 0xF6CCFA4A, 0xF740F897, +0xF876F6DF, 0xFA72F585, 0xFD02F4E8, 0xFFC5F545, 0xFD8100F8, 0xFD990087, 0xFDC70027, 0xFE02FFDA, +0xFE44FF9F, 0xFE86FF74, 0xFEC7FF54, 0xFF06FF3C, 0xFF41FF2A, 0xFF7CFF1A, 0xFFB9FF0B, 0xFFFAFEFD, +0x0045FEF2, 0x009EFEEC, 0x0107FEF4, 0x017FFF14, 0x0201FF58, 0x0281FFC8, 0x02ED0069, 0x03310138, +0x03390229, 0x02F40328, 0x025D0418, 0x017804DC, 0x00540559, 0xFF0C057A, 0xFDC10535, 0xFC94048E, +0xFBA50395, 0xFB090262, 0xFACC0115, 0xFAEDFFCC, 0xFB62FEA2, 0xFC18FDAA, 0xFCFCFCEE, 0xFDFAFC72, +0xFF04FC32, 0x000DFC2C, 0x010EFC5C, 0x0200FCC0, 0x02D8FD58, 0x038AFE20, 0x0407FF10, 0x0443001C, +0x0433012D, 0x03D70229, 0x033A02F8, 0x02710384, 0x019803C5, 0x00CF03BD, 0x002D037E, 0xFFC30321, +0xFF9002C2, 0xFF880279, 0xFF970254, 0xFFA50256, 0xFF9D0274, 0xFF74029C, 0xFF2902B8, 0xFEC602BA, +0x001AFB7E, 0x0038FC3B, 0x004BFD08, 0x005AFDDF, 0x006EFEBA, 0x008DFF91, 0x00BB005E, 0x00FA011D, +0x014701C8, 0x019E025D, 0x01F702DA, 0x02470341, 0x02840392, 0x02A203D2, 0x02980403, 0x0260042B, +0x01F6044C, 0x015C0469, 0x00950482, 0xFFAD0498, 0xFEAD04A8, 0xFDA504AE, 0xFCA304A5, 0xFBB7048A, +0xFAED0456, 0xFA4F0408, 0xF9E5039D, 0xF9B20318, 0xF9B3027D, 0xF9E501D2, 0xFA3E011F, 0xFAB5006F, +0xFB3EFFCE, 0xFBCDFF43, 0xFC55FEDA, 0xFCCCFE96, 0xFD2AFE7B, 0xFD68FE87, 0xFD82FEB7, 0xFD78FF02, +0xFD4AFF5E, 0xFCFCFFC0, 0xFC94001A, 0xFC190061, 0xFB93008B, 0xFB0C0090, 0xFA8C006C, 0xFA1C001F, +0xF9C5FFAA, 0xF98EFF12, 0xF97BFE61, 0xF990FD9F, 0xF9CDFCD5, 0xFA30FC11, 0xFAB4FB59, 0xFB53FAB9, +0xFC04FA37, 0xFCBDF9D7, 0xFD74F99F, 0xFE20F98F, 0x01DEFFC3, 0x0279FF40, 0x0319FEBF, 0x03BCFE4C, +0x045DFDF1, 0x04F7FDB5, 0x0582FD9F, 0x05F4FDB2, 0x0644FDF1, 0x0668FE5C, 0x065AFEEF, 0x0613FFA6, +0x0595007C, 0x04E10167, 0x0400025C, 0x02FE0351, 0x01E90437, 0x00D20501, 0xFFC805A0, 0xFEDC0608, +0xFE1A062F, 0xFD89060F, 0xFD2C05A4, 0xFD0304F4, 0xFD070407, 0xFD2F02EB, 0xFD7001B3, 0xFDBE0075, +0xFE0EFF47, 0xFE57FE41, 0xFE94FD74, 0xFEC0FCEF, 0xFEDFFCBA, 0xFEF2FCD5, 0xFEFFFD3A, 0xFF0CFDDA, +0xFF1EFEA4, 0xFF3AFF81, 0xFF5F005B, 0xFF8E011B, 0xFFC301B0, 0xFFF8020D, 0x0027022D, 0x00490210, +0x005701BF, 0x00500146, 0x003000B6, 0xFFFB0022, 0xFFB4FF9A, 0xFF62FF2F, 0xFF0DFEEA, 0xFEBDFED1, +0xFE7BFEE5, 0xFE4DFF20, 0xFE37FF78, 0xFE3DFFE1, 0xFE5D004B, 0xFE9700A9, 0xFEE600F0, 0xFF490116, +0x0337013F, 0x02E7020D, 0x026502EB, 0x01B403CD, 0x00D604A6, 0xFFD60568, 0xFEC00605, 0xFDA20672, +0xFC8C06A4, 0xFB8F0695, 0xFAB80643, 0xFA1405AE, 0xF9AA04DE, 0xF97E03DD, 0xF99002B8, 0xF9DA0182, +0xFA54004C, 0xFAF2FF2B, 0xFBA8FE2E, 0xFC68FD67, 0xFD23FCDF, 0xFDD0FC9C, 0xFE64FC9F, 0xFED8FCE2, +0xFF29FD5B, 0xFF55FDFA, 0xFF5FFEAE, 0xFF4AFF63, 0xFF1C0008, 0xFEDC008C, 0xFE9000E1, 0xFE410101, +0xFDF600E9, 0xFDB4009C, 0xFD820024, 0xFD65FF8B, 0xFD5EFEE3, 0xFD70FE39, 0xFD9BFDA0, 0xFDDDFD23, +0xFE33FCCE, 0xFE9AFCA7, 0xFF0BFCAF, 0xFF81FCE3, 0xFFF6FD3C, 0x0063FDB0, 0x00C4FE33, 0x0115FEB7, +0x0154FF32, 0x0181FF9A, 0x019DFFE6, 0x01AE0012, 0x01B8001F, 0x01C00010, 0x01CEFFEA, 0x01E4FFB7, +0x0208FF80, 0x0239FF4F, 0x0274FF31, 0x02B7FF2C, 0xFD78FF08, 0xFDDFFF8A, 0xFDBC0021, 0xFD1C0070, +0xFC420037, 0xFB8BFF67, 0xFB4EFE2F, 0xFBB6FCE4, 0xFCB4FBE5, 0xFE05FB77, 0xFF4EFBAC, 0x003EFC5F, +0x00A9FD47, 0x0096FE16, 0x0035FE96, 0xFFC5FEBB, 0xFF77FE9E, 0xFF5CFE6D, 0xFF63FE4E, 0xFF68FE4E, +0xFF49FE57, 0xFF01FE43, 0xFEA9FDEB, 0xFE73FD42, 0xFE94FC61, 0xFF29FB7E, 0x002BFAD9, 0x016CFAA4, +0x02ACFAEF, 0x03AEFBA2, 0x0453FC89, 0x049DFD6E, 0x04AFFE2D, 0x04B2FEC1, 0x04C4FF42, 0x04E6FFD5, +0x04FC0092, 0x04DE0175, 0x046A025C, 0x03A10311, 0x02A30364, 0x01AF0343, 0x010302C4, 0x00C9021E, +0x0100019A, 0x017E0171, 0x020101B9, 0x0246025D, 0x02280328, 0x01A603DA, 0x00E70446, 0x001D0462, +0xFF750442, 0xFEFA0411, 0xFE9D03F1, 0xFE3803ED, 0xFDA903EE, 0xFCE903C9, 0xFC140353, 0xFB61027E, +0x040BFA07, 0x05E7FB13, 0x072FFCC8, 0x07AAFED1, 0x074F00C8, 0x06470253, 0x04E00339, 0x03710374, +0x02470324, 0x018C0289, 0x014501E9, 0x01510179, 0x01810152, 0x01A20170, 0x019501B4, 0x015001F9, +0x00E00221, 0x005D0218, 0xFFE401DE, 0xFF890181, 0xFF570114, 0xFF4D00A8, 0xFF64004E, 0xFF91000D, +0xFFCBFFEB, 0x0005FFEC, 0x0032000E, 0x0045004D, 0x002E009E, 0xFFE400F0, 0xFF660129, 0xFEBF0131, +0xFE0400F6, 0xFD550071, 0xFCCEFFAB, 0xFC87FEB9, 0xFC8AFDB4, 0xFCD6FCB8, 0xFD5FFBD9, 0xFE16FB23, +0xFEEDFA9B, 0xFFDBFA43, 0x00D9FA1D, 0x01DEFA2F, 0x02DEFA7D, 0x03C8FB09, 0x0487FBCE, 0x050BFCBE, +0x0548FDC2, 0x053DFEC3, 0x04F5FFAD, 0x047D0074, 0x03E10116, 0x03270192, 0x025001E5, 0x015A0202, +0x004D01D6, 0xFF400148, 0xFE5C004D, 0xFDD7FEEC, 0x049F061F, 0x037F0651, 0x0277062F, 0x01A505CA, +0x01200540, 0x00ED04B8, 0x00FF0455, 0x01380431, 0x01750453, 0x019404B0, 0x017E0532, 0x012905BB, +0x009B062E, 0xFFE5067A, 0xFF1A0693, 0xFE4C067A, 0xFD890634, 0xFCDA05C8, 0xFC48053B, 0xFBD80494, +0xFB9203DA, 0xFB7E0319, 0xFB9E0263, 0xFBF001CB, 0xFC660163, 0xFCEA0138, 0xFD63014C, 0xFDB70195, +0xFDD301FD, 0xFDB0026D, 0xFD5302C9, 0xFCC90300, 0xFC240304, 0xFB7802D6, 0xFAD3027A, 0xFA3D01F6, +0xF9BC0151, 0xF951008F, 0xF900FFB1, 0xF8CEFEB7, 0xF8C3FDA4, 0xF8EAFC7D, 0xF94AFB4B, 0xF9EBFA1D, +0xFACEF902, 0xFBF2F80C, 0xFD4EF74C, 0xFED5F6D1, 0x0077F6A6, 0x021FF6D2, 0x03B5F753, 0x0523F823, +0x0658F931, 0x0747FA69, 0x07F0FBB6, 0x0857FD03, 0x0888FE44, 0x0891FF76, 0x087A009C, 0x084301B9, +0xFCB307D8, 0xFB7E0505, 0xFA8A0208, 0xF9E2FF11, 0xF98CFC51, 0xF991F9ED, 0xF9F2F807, 0xFAADF6B3, +0xFBBBF5F9, 0xFD0EF5D5, 0xFE91F63C, 0x002CF718, 0x01C3F84F, 0x0339F9C6, 0x0473FB61, 0x055AFD08, +0x05DDFEA6, 0x05F3002B, 0x059D018C, 0x04E402C1, 0x03D903C6, 0x02900498, 0x01250534, 0xFFB00599, +0xFE4705C5, 0xFCFF05B3, 0xFBE30564, 0xFAF904D5, 0xFA410409, 0xF9B70305, 0xF95101CF, 0xF9070072, +0xF8D1FEFD, 0xF8ACFD7D, 0xF897FC03, 0xF898FA9D, 0xF8B9F957, 0xF907F83B, 0xF98DF74E, 0xFA5BF694, +0xFB77F60C, 0xFCE4F5B5, 0xFE9FF58D, 0x009CF594, 0x02C7F5CB, 0x0507F634, 0x0741F6D7, 0x0955F7BA, +0x0B28F8E5, 0x0CA1FA5D, 0x0DADFC23, 0x0E40FE33, 0x0E580082, 0x0DF802FB, 0x0D2C0583, 0x0C0207FA, +0x0A8D0A39, 0x08E10C1A, 0x07120D7B, 0x05310E3E, 0xFE5BFC58, 0xFE3DFC9D, 0xFE0EFCEB, 0xFDE0FD36, +0xFDC6FD76, 0xFDD3FDA5, 0xFE14FDC0, 0xFE93FDC8, 0xFF52FDC3, 0x004EFDBB, 0x0179FDBD, 0x02C3FDD7, +0x0414FE16, 0x0552FE88, 0x0665FF35, 0x07320020, 0x07A70146, 0x07B4029E, 0x07520417, 0x0680059B, +0x0545070D, 0x03B10854, 0x01D80951, 0xFFD409EC, 0xFDC10A12, 0xFBBD09B7, 0xF9E608D9, 0xF8570781, +0xF72605C0, 0xF66503B0, 0xF6200172, 0xF659FF2A, 0xF70DFCFE, 0xF832FB12, 0xF9B5F983, 0xFB7EF86B, +0xFD71F7D6, 0xFF70F7CA, 0x0159F841, 0x0310F92D, 0x0478FA78, 0x057DFC06, 0x060FFDBA, 0x0629FF73, +0x05CE0115, 0x05060285, 0x03E703B0, 0x02880486, 0x01050500, 0xFF7D051D, 0xFE0D04E2, 0xFCCF045A, +0xFBD40393, 0xFB2B029E, 0xFAD7018E, 0xFAD50074, 0xFB17FF63, 0xFB8FFE6A, 0xFC26FD94, 0xFCC7FCEB, +0xFBFDFC7B, 0xFCA7FC9D, 0xFD4CFCAE, 0xFDE4FCAA, 0xFE6AFC93, 0xFEDBFC6D, 0xFF36FC45, 0xFF7CFC25, +0xFFB3FC1B, 0xFFE0FC31, 0x0008FC6F, 0x0032FCD7, 0x0061FD64, 0x0095FE10, 0x00CDFECC, 0x0101FF88, +0x01290035, 0x013D00C0, 0x0133011E, 0x01030144, 0x00AA0130, 0x002A00E4, 0xFF8A0065, 0xFED6FFBF, +0xFE20FF00, 0xFD7DFE37, 0xFD01FD72, 0xFCC3FCBF, 0xFCD1FC28, 0xFD36FBB7, 0xFDF5FB6E, 0xFF06FB53, +0x005CFB64, 0x01E0FBA3, 0x0376FC0C, 0x0501FC9E, 0x0661FD59, 0x077DFE38, 0x083EFF38, 0x08970055, +0x08810186, 0x07FF02C0, 0x071C03F9, 0x05EA051F, 0x047D0623, 0x02ED06F4, 0x01530783, 0xFFC107C3, +0xFE4A07AD, 0xFCFA0740, 0xFBD90680, 0xFAE90579, 0xFA2C043B, 0xF99D02DD, 0xF9390175, 0xF8FD001A, +0xF8E4FEE2, 0xF8EBFDDC, 0xF912FD12, 0xF955FC89, 0xFE01F827, 0xFEFEF875, 0xFFD8F86F, 0x00EAF822, +0x0271F7D2, 0x0472F7E0, 0x06B2F89E, 0x08CFFA2D, 0x0A60FC74, 0x0B1BFF21, 0x0AEE01CA, 0x09FC040F, +0x089505B8, 0x070D06BD, 0x05A70742, 0x047F0780, 0x038B07A9, 0x02AA07D7, 0x01B80805, 0x00A30816, +0xFF7307E6, 0xFE450760, 0xFD42067F, 0xFC8F0559, 0xFC430411, 0xFC6002CF, 0xFCD901B5, 0xFD9700DD, +0xFE800052, 0xFF7A001D, 0x0067003C, 0x012B00A4, 0x01AB0141, 0x01D801ED, 0x01B2027C, 0x015602C6, +0x00F602B3, 0x00CE024C, 0x011001BB, 0x01D20149, 0x02FC0142, 0x044C01DE, 0x0567032B, 0x05F60501, +0x05C20710, 0x04C808F8, 0x03380A67, 0x01600B38, 0xFF8F0B75, 0xFDF60B51, 0xFC990B09, 0xFB530AC5, +0xF9EC0A84, 0xF83E0A14, 0xF64E092E, 0xF4580791, 0xF2BC0529, 0xF1E5021D, 0xF219FED2, 0xF362FBC5, +0x02A8FC39, 0x02CAFDBB, 0x025CFF25, 0x01770040, 0x004900EA, 0xFF00011C, 0xFDC700DF, 0xFCB50047, +0xFBDAFF64, 0xFB40FE43, 0xFAF8FCEE, 0xFB16FB74, 0xFBB2F9F4, 0xFCD7F89D, 0xFE77F7A8, 0x006AF74A, +0x026DF79F, 0x0431F8A4, 0x0571FA2D, 0x0605FBF0, 0x05EEFD9D, 0x0554FEED, 0x047CFFBB, 0x03AB000C, +0x031B0003, 0x02E4FFD8, 0x02FDFFC5, 0x0344FFEF, 0x038B0063, 0x03A80113, 0x038101E1, 0x031002A7, +0x02600347, 0x018703AB, 0x00A003C7, 0xFFC7039D, 0xFF150336, 0xFEA002A5, 0xFE790207, 0xFEA2017F, +0xFF0D0133, 0xFF990145, 0x001301C4, 0x004202A3, 0xFFF403B8, 0xFF1304C1, 0xFDA90573, 0xFBE90593, +0xFA1D0501, 0xF89703CB, 0xF7960222, 0xF735004D, 0xF76BFE94, 0xF80CFD2A, 0xF8E2FC1F, 0xF9BCFB65, +0xFA86FADB, 0xFB43FA5F, 0xFC0FF9E4, 0xFD04F976, 0x00FAFFEB, 0x00DB0015, 0x00B30026, 0x0092001B, +0x0086FFFE, 0x0096FFD9, 0x00C3FFBD, 0x0105FFB4, 0x0156FFC5, 0x01A9FFF6, 0x01F60045, 0x023400B1, +0x025B0138, 0x026101D4, 0x023C027E, 0x01E50328, 0x015903BF, 0x009E042F, 0xFFC20468, 0xFEDD045E, +0xFE080412, 0xFD590391, 0xFCDF02EE, 0xFC9C0242, 0xFC8A01A0, 0xFC9A0113, 0xFCBE00A0, 0xFCEA0040, +0xFD1CFFEC, 0xFD57FFA2, 0xFDA1FF61, 0xFDFBFF34, 0xFE62FF25, 0xFEC8FF3D, 0xFF1BFF7F, 0xFF47FFE0, +0xFF3F004E, 0xFEFE00AF, 0xFE8F00EA, 0xFE0500ED, 0xFD7C00B2, 0xFD0E003D, 0xFCCFFF9E, 0xFCCBFEED, +0xFD04FE42, 0xFD71FDAF, 0xFE06FD46, 0xFEB0FD10, 0xFF5CFD0F, 0xFFFAFD3F, 0x0079FD98, 0x00CFFE0A, +0x00F7FE83, 0x00F3FEF1, 0x00CDFF45, 0x0098FF74, 0x0065FF7D, 0x0046FF6A, 0x0044FF4A, 0x0061FF31, +0xFF4D0493, 0xFEA302A0, 0xFDEF007D, 0xFD36FE4A, 0xFC83FC2A, 0xFBE3FA3C, 0xFB67F899, 0xFB1EF754, +0xFB16F676, 0xFB5BF600, 0xFBF1F5EA, 0xFCD5F626, 0xFDFEF69F, 0xFF5BF742, 0x00D6F7FB, 0x0258F8BA, +0x03C7F971, 0x050DFA1B, 0x0618FAB6, 0x06DBFB45, 0x0752FBCF, 0x0780FC59, 0x076DFCEB, 0x0727FD87, +0x06BFFE2E, 0x0645FEDD, 0x05C8FF8C, 0x05530033, 0x04EE00C7, 0x0499013F, 0x04520193, 0x041501C0, +0x03DA01C4, 0x039A01A4, 0x03510168, 0x02FD0119, 0x02A200C2, 0x0245006E, 0x01EF0025, 0x01ADFFED, +0x0187FFC9, 0x0188FFBA, 0x01B4FFBC, 0x020DFFCD, 0x028DFFE7, 0x032B000A, 0x03D90034, 0x04880068, +0x052700AB, 0x05A60103, 0x05FB0177, 0x061E020D, 0x060D02C7, 0x05CB03A4, 0x0560049D, 0x04D505A4, +0x043706A6, 0x0390078E, 0x02E90842, 0x024708AC, 0xFD38FDC0, 0xFC6FFE33, 0xFBC9FEC5, 0xFB58FF6B, +0xFB270014, 0xFB3A00B1, 0xFB910133, 0xFC21018E, 0xFCDD01BC, 0xFDB101BF, 0xFE8A019C, 0xFF540160, +0xFFFF0119, 0x007D00D9, 0x00CB00B0, 0x00E600AA, 0x00D400D0, 0x009E0123, 0x004E019D, 0xFFF10234, +0xFF8F02D6, 0xFF320370, 0xFEDE03F1, 0xFE920445, 0xFE4F0462, 0xFE100440, 0xFDCF03E0, 0xFD8B0349, +0xFD420287, 0xFCF401AC, 0xFCA700C9, 0xFC61FFF1, 0xFC2BFF34, 0xFC0EFE9C, 0xFC12FE31, 0xFC3DFDF2, +0xFC8FFDDC, 0xFD05FDE5, 0xFD99FE05, 0xFE3FFE2F, 0xFEEAFE5B, 0xFF8CFE81, 0x0019FE9D, 0x0085FEAE, +0x00CCFEB8, 0x00EDFEBE, 0x00EBFEC4, 0x00CFFED0, 0x00A5FEE3, 0x0079FEFD, 0x0057FF1B, 0x0046FF39, +0x004BFF4F, 0x0066FF56, 0x0090FF48, 0x00BFFF24, 0x00E6FEE8, 0x00F8FE9A, 0x00E7FE41, 0x00AAFDE8, +0xFC9B0078, 0xFCB9FF79, 0xFCF1FE5A, 0xFD43FD2D, 0xFDB0FC05, 0xFE37FAF5, 0xFED4FA0B, 0xFF84F955, +0x0042F8DB, 0x0105F89F, 0x01C7F8A1, 0x0280F8DC, 0x0327F947, 0x03B6F9D7, 0x0428FA82, 0x047CFB3D, +0x04B2FBFC, 0x04CDFCB9, 0x04D3FD6D, 0x04CCFE13, 0x04C2FEAC, 0x04BDFF37, 0x04C5FFB7, 0x04E1002F, +0x051300A2, 0x05580115, 0x05AE018C, 0x060C020B, 0x06660294, 0x06B00329, 0x06DD03C9, 0x06E20475, +0x06B70529, 0x065405E2, 0x05BB0698, 0x04EE0745, 0x03F707E0, 0x02E0085F, 0x01B808B9, 0x009108E6, +0xFF7708DF, 0xFE7B08A1, 0xFDA6082A, 0xFD01077E, 0xFC8E06A5, 0xFC4C05AA, 0xFC38049B, 0xFC480388, +0xFC730283, 0xFCAF019C, 0xFCF100E1, 0xFD30005D, 0xFD640015, 0xFD890008, 0xFD9A0032, 0xFD990086, +0xFD8700F5, 0xFD67016C, 0xFD3D01D9, 0xFD0F0228, 0xFE69004C, 0xFEBBFFE6, 0xFF24FFCF, 0xFF700000, +0xFF760059, 0xFF2C00A4, 0xFEA800AE, 0xFE1A005C, 0xFDBEFFB1, 0xFDC4FED2, 0xFE41FDFD, 0xFF24FD71, +0x003EFD5E, 0x014CFDD2, 0x020BFEBB, 0x024DFFE6, 0x02010110, 0x013701F7, 0x001E0269, 0xFEF20251, +0xFDF501B8, 0xFD5A00C1, 0xFD40FFA3, 0xFDA7FE9C, 0xFE76FDE2, 0xFF80FD9B, 0x0089FDD1, 0x015CFE75, +0x01CEFF60, 0x01CE005D, 0x01660138, 0x00B701CB, 0xFFEF0205, 0xFF3801F0, 0xFEAE01AA, 0xFE560156, +0xFE1F0110, 0xFDEB00E0, 0xFDA000B7, 0xFD350075, 0xFCBBFFF8, 0xFC58FF2D, 0xFC40FE1E, 0xFC9CFCF0, +0xFD79FBE3, 0xFEC3FB36, 0x0042FB18, 0x01AEFB95, 0x02C1FC8F, 0x0350FDCC, 0x0354FF03, 0x02EFFFF9, +0x0257008F, 0x01C600CC, 0x016500D1, 0x013B00CF, 0x013200EB, 0x01240132, 0x00ED0195, 0x007A01EF, +0xF92B02B0, 0xF9D40009, 0xFB53FDCF, 0xFD70FC4F, 0xFFD5FBB9, 0x0221FC13, 0x03FAFD3B, 0x0520FEEF, +0x057100D9, 0x04F602A4, 0x03D30409, 0x024404D7, 0x008E04FE, 0xFEF20486, 0xFDA20391, 0xFCBD024B, +0xFC4B00E7, 0xFC41FF8F, 0xFC84FE61, 0xFCF5FD69, 0xFD76FCA3, 0xFDF5FBFF, 0xFE6EFB68, 0xFEECFAD0, +0xFF80FA33, 0x0039F99D, 0x011DF924, 0x0222F8E0, 0x0330F8E3, 0x0423F92D, 0x04DDF9AA, 0x054BFA39, +0x0571FAAD, 0x0569FAE6, 0x055DFAD3, 0x0579FA7B, 0x05E2F9FE, 0x06A4F988, 0x07B5F944, 0x08F7F954, +0x0A43F9C2, 0x0B73FA87, 0x0C70FB8C, 0x0D32FCB7, 0x0DBDFDF4, 0x0E1CFF3A, 0x0E56008A, 0x0E6D01E7, +0x0E560357, 0x0E0604D1, 0x0D73064A, 0x0C9B07AC, 0x0B8608E7, 0x0A4509EF, 0x08E40AC4, 0x076B0B6B, +0x05D90BE9, 0x04240C3A, 0x02430C4E, 0x00380C04, 0x00E4FF53, 0x013FFEFC, 0x01B4FED6, 0x022DFEE9, +0x028FFF31, 0x02C3FF9F, 0x02BE001A, 0x027F0086, 0x021600C9, 0x019900D6, 0x012600AA, 0x00D50053, +0x00B6FFE5, 0x00CCFF7C, 0x010CFF2F, 0x0164FF0F, 0x01BAFF1E, 0x01F8FF54, 0x0211FFA0, 0x0201FFED, +0x01D00027, 0x018F0043, 0x014E0041, 0x011C002A, 0x0100000E, 0x00F5FFFB, 0x00ECFFFD, 0x00D40011, +0x009F002C, 0x00450039, 0xFFCD0022, 0xFF4AFFD3, 0xFED8FF47, 0xFE93FE85, 0xFE94FDA5, 0xFEE4FCC5, +0xFF7DFC07, 0x004AFB85, 0x012EFB4B, 0x020AFB58, 0x02C6FB9D, 0x0356FC02, 0x03BAFC70, 0x03FEFCD7, +0x0430FD32, 0x045EFD83, 0x048EFDD4, 0x04BFFE2F, 0x04E9FE9B, 0x0500FF18, 0x04FBFF9F, 0x04D50026, +0x0492009F, 0x04360103, 0x03CC014D, 0x035B017F, 0x02E70199, 0x0274019E, 0x0201018E, 0x01920165, +0xFD5C025E, 0xFC270172, 0xFB360075, 0xFA92FF71, 0xFA40FE72, 0xFA3CFD7E, 0xFA80FCA0, 0xFB01FBDB, +0xFBB0FB38, 0xFC7FFAB9, 0xFD5FFA61, 0xFE40FA32, 0xFF19FA2B, 0xFFE1FA4A, 0x0091FA8C, 0x0128FAE9, +0x01A6FB5D, 0x020CFBE0, 0x025DFC6A, 0x0299FCF3, 0x02C4FD77, 0x02DCFDF1, 0x02E2FE5E, 0x02D3FEBE, +0x02AFFF12, 0x0271FF5C, 0x021AFF9E, 0x01AAFFDA, 0x01210013, 0x00840047, 0xFFD90073, 0xFF260093, +0xFE7300A2, 0xFDCB0096, 0xFD34006A, 0xFCB80017, 0xFC5DFF99, 0xFC29FEF0, 0xFC1FFE1E, 0xFC42FD2C, +0xFC91FC26, 0xFD0DFB1B, 0xFDB3FA1D, 0xFE7EF93F, 0xFF6CF892, 0x0076F826, 0x0195F807, 0x02C1F83B, +0x03F0F8C3, 0x0515F999, 0x0625FAB1, 0x0712FBFC, 0x07CFFD67, 0x084FFEDC, 0x08880046, 0x08710192, +0x080802AE, 0x074D038E, 0x06460429, 0x04FF047C, 0xFE1DFC68, 0xFE51FBC1, 0xFE9CFB53, 0xFEF6FB26, +0xFF5BFB38, 0xFFC3FB87, 0x0028FC0C, 0x0086FCBF, 0x00D8FD94, 0x011CFE7E, 0x0151FF70, 0x0175005C, +0x018A0137, 0x019001F4, 0x0188028D, 0x017102FB, 0x014B033B, 0x0116034D, 0x00CE0334, 0x007402F5, +0x00040299, 0xFF7F0226, 0xFEE501A6, 0xFE390121, 0xFD81009D, 0xFCC30020, 0xFC07FFAD, 0xFB58FF41, +0xFAC0FEDB, 0xFA4AFE77, 0xFA00FE0E, 0xF9E8FD9B, 0xFA08FD18, 0xFA62FC83, 0xFAF3FBDA, 0xFBB6FB21, +0xFCA3FA5D, 0xFDB0F998, 0xFED1F8DF, 0xFFF7F83F, 0x0118F7C7, 0x0226F783, 0x0318F780, 0x03E4F7C4, +0x0487F851, 0x04FAF924, 0x053EFA37, 0x0553FB7A, 0x053BFCDD, 0x04FAFE4C, 0x0496FFB1, 0x041400F7, +0x0379020A, 0x02CD02DB, 0x0217035F, 0x015D0391, 0x00A80370, 0xFFFD0302, 0xFF630252, 0xFEE1016E, +0x07A9FC16, 0x084FFD8A, 0x08CBFED9, 0x0918FFF6, 0x093100DD, 0x0914018F, 0x08C10210, 0x083A026C, +0x078702AF, 0x06AF02E3, 0x05BD0312, 0x04BC0342, 0x03B90376, 0x02BC03AC, 0x01CE03DD, 0x00F50401, +0x00320410, 0xFF8603FE, 0xFEF203C7, 0xFE710365, 0xFE0402DB, 0xFDA9022C, 0xFD620161, 0xFD310088, +0xFD1BFFAD, 0xFD24FEE0, 0xFD51FE2F, 0xFDA5FDA5, 0xFE20FD4B, 0xFEBFFD26, 0xFF79FD37, 0x0044FD7C, +0x010FFDEF, 0x01C9FE8A, 0x025FFF43, 0x02BE0010, 0x02D900E7, 0x02A701BF, 0x0223028D, 0x01510348, +0x003D03E4, 0xFEF70459, 0xFD94049D, 0xFC2D04A6, 0xFADB046D, 0xF9B403EC, 0xF8CC0321, 0xF832020C, +0xF7EE00B5, 0xF800FF27, 0xF865FD72, 0xF913FBAB, 0xF9FEF9EB, 0xFB18F84B, 0xFC51F6E4, 0xFD9CF5CD, +0xFEEEF516, 0x003EF4CB, 0x0184F4EE, 0x02BDF57B, 0x01B603F0, 0x010E0487, 0x00150506, 0xFED20535, +0xFD7304E6, 0xFC3E040A, 0xFB7F02BE, 0xFB680148, 0xFC010004, 0xFD1CFF4A, 0xFE61FF50, 0xFF640011, +0xFFC90152, 0xFF6402AD, 0xFE4203B5, 0xFCAA0413, 0xFB0303A5, 0xF9B50282, 0xF90A00F4, 0xF917FF5E, +0xF9BCFE18, 0xFAB0FD57, 0xFBA1FD21, 0xFC4BFD4D, 0xFC92FD9A, 0xFC83FDC5, 0xFC4EFDA2, 0xFC31FD2C, +0xFC61FC83, 0xFCF9FBE0, 0xFDEBFB82, 0xFF0CFB98, 0x001AFC35, 0x00D2FD46, 0x0101FE9C, 0x0090FFF2, +0xFF8A00FF, 0xFE1B0187, 0xFC810167, 0xFB08009A, 0xF9F2FF3C, 0xF973FD81, 0xF9A0FBAD, 0xFA71FA06, +0xFBC2F8C3, 0xFD5BF807, 0xFF02F7D7, 0x0084F81E, 0x01C2F8B7, 0x02B5F979, 0x0368FA45, 0x03F2FB0A, +0x0466FBCB, 0x04CEFC94, 0x0524FD75, 0x0556FE6F, 0x0552FF79, 0x0510007A, 0x04960158, 0x03FC0201, +0x0498FFB4, 0x046A0205, 0x03730430, 0x01D305E9, 0xFFC606FA, 0xFD980751, 0xFB8E06FB, 0xF9DD061D, +0xF8A204E8, 0xF7E40391, 0xF798023F, 0xF7A90113, 0xF7FD001F, 0xF87AFF6C, 0xF907FEFB, 0xF98DFEC8, +0xF9F8FEC3, 0xFA3CFED9, 0xFA58FEF2, 0xFA57FEFA, 0xFA4DFEE7, 0xFA4FFEBA, 0xFA6FFE84, 0xFAB0FE5D, +0xFB05FE5C, 0xFB54FE8D, 0xFB80FEE9, 0xFB70FF5A, 0xFB1DFFBB, 0xFA94FFEC, 0xF9F5FFD5, 0xF965FF73, +0xF907FED7, 0xF8ECFE1F, 0xF916FD6F, 0xF975FCDF, 0xF9F0FC7D, 0xFA71FC47, 0xFAEBFC31, 0xFB5AFC30, +0xFBC3FC3D, 0xFC28FC5B, 0xFC89FC90, 0xFCDBFCE1, 0xFD0EFD4B, 0xFD15FDC0, 0xFCEBFE29, 0xFC97FE71, +0xFC30FE87, 0xFBCDFE67, 0xFB86FE1E, 0xFB65FDBF, 0xFB67FD5E, 0xFB81FD03, 0xFBA7FCAD, 0xFBD5FC50, +0xFC18FBDE, 0xFC87FB57, 0xFD3FFACC, 0xFE51FA64, 0xFC4F0162, 0xFBD10151, 0xFB2D0135, 0xFA6400F2, +0xF985006F, 0xF8AAFF9C, 0xF7F6FE78, 0xF785FD0F, 0xF76FFB7B, 0xF7BBF9D7, 0xF86BF840, 0xF976F6CD, +0xFAD0F590, 0xFC6BF497, 0xFE3AF3EA, 0x0031F396, 0x023EF3A3, 0x0450F418, 0x064EF4F9, 0x0820F643, +0x09ACF7EC, 0x0ADCF9E0, 0x0BA2FC09, 0x0BF5FE4A, 0x0BD60089, 0x0B4D02AD, 0x0A6604A5, 0x09320661, +0x07BE07DA, 0x0619090B, 0x044E09EF, 0x02670A85, 0x006F0AC8, 0xFE710AB3, 0xFC7C0A42, 0xFAA20972, +0xF8FA0846, 0xF79C06C8, 0xF69D050B, 0xF60F032C, 0xF5F6014B, 0xF649FF8A, 0xF6F6FE04, 0xF7E1FCCB, +0xF8EDFBE3, 0xFA01FB44, 0xFB10FAE0, 0xFC13FAA8, 0xFD0EFA93, 0xFE09FAA0, 0xFF04FAD9, 0xFFFAFB49, +0x00D6FBF7, 0x0181FCE3, 0x01E2FDFD, 0x01E7FF27, 0x018E003F, 0x00E70122, 0x001001BB, 0xFF2A0203, +0x00E2FEE4, 0x00F1FE76, 0x00DDFE3C, 0x00ABFE38, 0x0064FE67, 0x0013FEC0, 0xFFC3FF38, 0xFF7EFFC0, +0xFF4C0048, 0xFF3100C2, 0xFF2D0121, 0xFF3B015E, 0xFF540175, 0xFF710167, 0xFF88013C, 0xFF9200FD, +0xFF8700B6, 0xFF670071, 0xFF30003A, 0xFEE70014, 0xFE910005, 0xFE350008, 0xFDDC0018, 0xFD8C002B, +0xFD4C0034, 0xFD220029, 0xFD0EFFFF, 0xFD14FFB1, 0xFD32FF3C, 0xFD69FEA3, 0xFDB8FDEE, 0xFE1EFD2A, +0xFE9CFC65, 0xFF33FBB0, 0xFFE4FB1B, 0x00AEFAB2, 0x0192FA81, 0x028AFA8B, 0x0391FAD2, 0x049DFB51, +0x05A1FC00, 0x068FFCD5, 0x0757FDC3, 0x07E9FEBE, 0x0839FFBB, 0x083D00B0, 0x07F30196, 0x075B0268, +0x06800322, 0x056F03C1, 0x043D0445, 0x02FE04AB, 0x01CB04F1, 0x00B70514, 0xFFD60512, 0xFF3304E7, +0xFED40494, 0xFEB60418, 0xFED30378, 0xFF1C02BA, 0xFD45FFD2, 0xFD5B008D, 0xFD680152, 0xFD680210, +0xFD5A02B5, 0xFD3B0334, 0xFD0C0382, 0xFCCE039A, 0xFC84037D, 0xFC340332, 0xFBE202C0, 0xFB980234, +0xFB5D019C, 0xFB380105, 0xFB300079, 0xFB470001, 0xFB7DFFA3, 0xFBCFFF5E, 0xFC36FF32, 0xFCAAFF1A, +0xFD1FFF10, 0xFD8BFF0F, 0xFDE1FF0F, 0xFE1BFF0C, 0xFE35FF01, 0xFE2DFEEE, 0xFE08FED2, 0xFDCEFEAD, +0xFD8CFE83, 0xFD4FFE55, 0xFD25FE26, 0xFD1AFDFA, 0xFD39FDD3, 0xFD87FDB2, 0xFE05FD9B, 0xFEACFD90, +0xFF72FD93, 0x004BFDA7, 0x0125FDCF, 0x01EFFE0E, 0x0299FE66, 0x0315FED6, 0x035AFF5F, 0x0362FFFC, +0x032F00A7, 0x02C50157, 0x022F0202, 0x0178029C, 0x00AE0318, 0xFFDF036D, 0xFF190390, 0xFE64037E, +0xFDCA0335, 0xFD4E02BC, 0xFCF2021B, 0xFCB40160, 0xFC92009C, 0xFC87FFE1, 0xFC8EFF41, 0xFCA2FECC, +0xFEB4FF4A, 0xFF00FF36, 0xFF88FF41, 0x0047FF69, 0x0131FFAA, 0x02330004, 0x03380073, 0x042600F9, +0x04E40195, 0x055C0247, 0x057F030C, 0x054203E2, 0x04A404BF, 0x03AC059A, 0x02670661, 0x00E80704, +0xFF47076E, 0xFD9B078D, 0xFBFD0751, 0xFA8306AD, 0xF93E059E, 0xF83E0427, 0xF78B0254, 0xF72C003C, +0xF723FDFA, 0xF76DFBB0, 0xF809F981, 0xF8F0F790, 0xFA1CF5FC, 0xFB85F4DA, 0xFD20F43A, 0xFEE2F420, +0x00BAF486, 0x0299F55D, 0x046BF690, 0x061DF804, 0x079AF99B, 0x08CFFB3D, 0x09AEFCD1, 0x0A2CFE45, +0x0A44FF8D, 0x09F900A5, 0x0955018C, 0x08670247, 0x074402DF, 0x0604035A, 0x04BF03C1, 0x038D0419, +0x02800463, 0x01A4049E, 0x010104C8, 0x009504DC, 0x005804D4, 0x003F04AB, 0x00390461, 0x003703F6, +0x002D036E, 0x001002D1, 0xFFDD0228, 0xFF97017D, 0xFE3C0116, 0xFE260096, 0xFE2A0022, 0xFE39FFC9, +0xFE3DFF8D, 0xFE1CFF5D, 0xFDC7FF18, 0xFD49FE92, 0xFCC9FDA5, 0xFC87FC44, 0xFCC8FA8C, 0xFDC0F8BF, +0xFF7AF73A, 0x01CBF659, 0x045CF65B, 0x06BEF745, 0x088DF8E4, 0x0991FAD7, 0x09CDFCB2, 0x097FFE1D, +0x090AFEF8, 0x08CBFF60, 0x08F9FFA4, 0x09900026, 0x0A4E012F, 0x0ACF02D6, 0x0AB004EE, 0x09B60717, +0x07E608DD, 0x058409DD, 0x02FD09EA, 0x00C80917, 0xFF3807AE, 0xFE6C0618, 0xFE4804B3, 0xFE8403BB, +0xFECE0338, 0xFEE60301, 0xFEB202D7, 0xFE47027C, 0xFDD501D0, 0xFD9800D5, 0xFDBEFFB1, 0xFE56FE9C, +0xFF4FFDCC, 0x0080FD65, 0x01B7FD72, 0x02C6FDE4, 0x0391FE9D, 0x040BFF7B, 0x04380061, 0x04220139, +0x03D801F5, 0x0366028F, 0x02D70302, 0x0238034A, 0x01950369, 0x00F70363, 0x0066033F, 0xFFE60306, +0x0105FD0C, 0x01CBFE73, 0x020D0001, 0x01CE017C, 0x012E02B3, 0x005E0393, 0xFF890422, 0xFEC9047B, +0xFE2304BC, 0xFD8A04F7, 0xFCEA052E, 0xFC3A0553, 0xFB800553, 0xFAD10525, 0xFA4804D0, 0xF9F60471, +0xF9D90429, 0xF9D80418, 0xF9CA044A, 0xF98204AD, 0xF8E3051B, 0xF7E9055F, 0xF6AD0549, 0xF55F04BC, +0xF43703B6, 0xF3640250, 0xF30600B6, 0xF320FF16, 0xF3A8FD9A, 0xF482FC5E, 0xF594FB6F, 0xF6C3FAD1, +0xF7FBFA83, 0xF928FA7F, 0xFA3AFAC0, 0xFB1EFB39, 0xFBC7FBD7, 0xFC31FC82, 0xFC60FD21, 0xFC68FDA1, +0xFC60FDFE, 0xFC5EFE41, 0xFC6CFE7D, 0xFC83FEC8, 0xFC8FFF2E, 0xFC78FFA9, 0xFC2A0021, 0xFBA70079, +0xFB000090, 0xFA5B005A, 0xF9DDFFDF, 0xF9A2FF3D, 0xF9B1FE9A, 0xF9F6FE19, 0xFA52FDC8, 0xFAA3FD9E, +0xFAD8FD7F, 0xFAF9FD4B, 0xFB23FCEC, 0xFB7EFC68, 0xFD2B023A, 0xFDE401D0, 0xFE8001DF, 0xFECD0242, +0xFEAD02C4, 0xFE220327, 0xFD4C0339, 0xFC5E02DF, 0xFB8E0219, 0xFB0E0102, 0xFAF6FFC7, 0xFB49FE9A, +0xFBF0FDA3, 0xFCCBFCFA, 0xFDB3FCA4, 0xFE88FC93, 0xFF39FCB4, 0xFFC0FCED, 0x0021FD2C, 0x0067FD66, +0x009DFD96, 0x00CBFDBE, 0x00F5FDDF, 0x0120FDFE, 0x014CFE1E, 0x017BFE40, 0x01ABFE6A, 0x01DCFEA0, +0x0209FEE6, 0x0228FF40, 0x0230FFAC, 0x02150023, 0x01CF0097, 0x015D00F9, 0x00C10135, 0x0008013D, +0xFF440103, 0xFE8A0081, 0xFDF2FFB9, 0xFD94FEB3, 0xFD86FD81, 0xFDD8FC3A, 0xFE95FAFD, 0xFFBAF9EC, +0x013AF92B, 0x02FEF8D5, 0x04E1F901, 0x06BCF9B6, 0x0865FAED, 0x09B7FC94, 0x0A95FE8E, 0x0AEC00B7, +0x0AB602E9, 0x09F404FD, 0x08B306D1, 0x07080843, 0x050F0937, 0x02F1099A, 0x00DC0964, 0xFF03089E, +0x0378005E, 0x025F00EB, 0x015A0198, 0x006C0251, 0xFF9502FE, 0xFED20387, 0xFE1D03D8, 0xFD7003E1, +0xFCC9039A, 0xFC240303, 0xFB850224, 0xFAF1010A, 0xFA73FFC8, 0xFA15FE74, 0xF9E6FD24, 0xF9F0FBED, +0xFA3CFAE1, 0xFACEFA0E, 0xFBA0F97B, 0xFCAAF92C, 0xFDD9F922, 0xFF18F958, 0x004DF9C7, 0x015EFA68, +0x0234FB30, 0x02BCFC15, 0x02EBFD0D, 0x02BDFE0D, 0x0239FF07, 0x016EFFEE, 0x007100B6, 0xFF5C0150, +0xFE4901AF, 0xFD5301C9, 0xFC910196, 0xFC130113, 0xFBE20045, 0xFC01FF34, 0xFC6BFDF1, 0xFD15FC92, +0xFDF2FB32, 0xFEF2F9EB, 0x0005F8D9, 0x011FF814, 0x0236F7AF, 0x0343F7B2, 0x0442F81D, 0x0532F8E8, +0x0615F9FF, 0x06EAFB4A, 0x07B1FCAB, 0x0867FE04, 0x0907FF39, 0x098B0033, 0x09EA00E4, 0x0A1C0146, +0x0A19015D, 0x09DE0137, 0x096900E7, 0x08BD0086, 0xFE1BFD26, 0xFEB9FD53, 0xFF6CFD9E, 0x002CFDFD, +0x00EDFE68, 0x01A4FED6, 0x0247FF45, 0x02CCFFAF, 0x032C0017, 0x0362007B, 0x036F00DF, 0x03530144, +0x031401AB, 0x02B80213, 0x02480279, 0x01CA02D8, 0x0147032A, 0x00C30369, 0x0041038C, 0xFFC4038E, +0xFF4D036B, 0xFEDA0322, 0xFE6D02B3, 0xFE060224, 0xFDA7017A, 0xFD5400BE, 0xFD12FFFB, 0xFCE7FF39, +0xFCDAFE82, 0xFCF2FDDD, 0xFD34FD50, 0xFDA1FCDE, 0xFE39FC88, 0xFEF6FC50, 0xFFD1FC34, 0x00BEFC34, +0x01AEFC4F, 0x0293FC84, 0x035EFCD5, 0x0403FD41, 0x0477FDC8, 0x04B4FE6A, 0x04B8FF25, 0x0485FFF4, +0x042300D0, 0x039901B0, 0x02F30289, 0x023C034D, 0x017E03F1, 0x00C30467, 0x001204A7, 0xFF6F04AA, +0xFEDE046F, 0xFE5D03F8, 0xFDEF034D, 0xFD91027A, 0xFD43018D, 0xFD060098, 0xFCDDFFAA, 0xFCCAFED3, +0x062F01CE, 0x053F0146, 0x04380089, 0x032AFFAE, 0x022AFED0, 0x014BFE09, 0x00A1FD6E, 0x003BFD0D, +0x0024FCF0, 0x005DFD17, 0x00DFFD79, 0x019CFE0C, 0x027EFEBF, 0x0369FF82, 0x04410046, 0x04E800FE, +0x054701A3, 0x054E022F, 0x04F502A4, 0x043D0304, 0x03350354, 0x01F2039A, 0x008F03D9, 0xFF2A0410, +0xFDE10440, 0xFCCD0463, 0xFBFF0473, 0xFB81046A, 0xFB530442, 0xFB6903F7, 0xFBB3038A, 0xFC1A02FE, +0xFC85025A, 0xFCDF01AA, 0xFD1400F7, 0xFD190050, 0xFCEBFFBB, 0xFC8EFF41, 0xFC0FFEE3, 0xFB80FE9D, +0xFAF5FE69, 0xFA85FE3B, 0xFA43FE07, 0xFA3EFDC2, 0xFA7FFD63, 0xFB07FCE5, 0xFBD3FC4B, 0xFCD9FB9D, +0xFE0BFAE9, 0xFF59FA41, 0x00B2F9B9, 0x0207F965, 0x034CF954, 0x0477F992, 0x0580FA20, 0x0662FAF9, +0x071CFC0C, 0x07AAFD45, 0x080AFE89, 0x083AFFBC, 0xFEEB01D4, 0xFECA0170, 0xFEDE010F, 0xFF1E00C9, +0xFF7800AF, 0xFFD700C4, 0x002B0107, 0x00660170, 0x007D01F8, 0x00670293, 0x001E0338, 0xFF9903D2, +0xFEDD044E, 0xFDF20496, 0xFCF0049B, 0xFBF10456, 0xFB1203D4, 0xFA640329, 0xF9EB0272, 0xF99A01C8, +0xF9590135, 0xF90E00B3, 0xF8A8002A, 0xF829FF7E, 0xF7A3FE95, 0xF73AFD60, 0xF712FBE8, 0xF74AFA46, +0xF7F3F8A0, 0xF909F71D, 0xFA7BF5DE, 0xFC2FF4F9, 0xFE08F474, 0xFFEFF452, 0x01D2F48F, 0x039EF528, +0x0542F619, 0x06A9F75A, 0x07BFF8DB, 0x0873FA82, 0x08BFFC31, 0x08ADFDC8, 0x0850FF2D, 0x07C60056, +0x07280148, 0x06870212, 0x05E402C6, 0x0534036F, 0x04680408, 0x03750480, 0x026104BE, 0x014404AD, +0x00410446, 0xFF7F0399, 0xFF1702C7, 0xFF100200, 0xFF55016D, 0xFFC10128, 0x00260133, 0x005E0179 + + +in_sequence_size = +60 + +in_leading_padding = +4 + +out_sequence_size = +60 + +out_leading_depadding = +0 + +window_index = +2, 5, 8, 11, 14, 2, 5, 8, 11, 14, 2, 5 + +cs_bitmap = +63 + +num_antennas_log2 = +3 + +ifft_log2 = +6 + +fft_log2 = +6 + +cs_time_adjustment = +0 + +ifft_shift = +3 + +fft_shift = +3 + +ncs_reciprocal = +5461 + +op_flags = +RTE_BBDEV_FFT_CS_ADJUSTMENT, RTE_BBDEV_FFT_WINDOWING + +expected_status = +OK + diff --git a/app/test-bbdev/test_vectors/fft_byp_28.data b/app/test-bbdev/test_vectors/fft_byp_28.data new file mode 100644 index 0000000000..41d8607a60 --- /dev/null +++ b/app/test-bbdev/test_vectors/fft_byp_28.data @@ -0,0 +1,103 @@ +# SPDX-License-Identifier: BSD-3-Clause +# Copyright(c) 2021 Intel Corporation +op_type = +RTE_BBDEV_OP_FFT + +input0 = +0x07F7F9F1, 0xF788FA5C, 0xEFD00A45, 0xF01E0175, 0xFDEC06E6, 0x0270FBED, 0x0F91EEF8, 0xFBDDFA1C, +0x0465EFCF, 0xF597FB63, 0xE9C7029A, 0xF7B4FBB6, 0xFCE808C3, 0xFB3EF579, 0x1255F4C8, 0xF6FDFC84, +0x0EE3F2D7, 0xF5C0F227, 0xECF20039, 0xF2AB0099, 0xF4C0064D, 0x070CF1A3, 0x0F92FC3E, 0xF874F8FD, +0xE6421887, 0xF32001CB, 0x04F8ECEE, 0xF9A5F737, 0x07DC07BC, 0xFC2AFCFC, 0x0AC01797, 0xFD750933, +0xE27B1122, 0xF33C0479, 0x00BAEA5C, 0xFE51FD33, 0x04EA01FD, 0xFD95FB94, 0x0B3E16F7, 0xFD690791, +0xDF4B09A5, 0xF64FF865, 0x0C4AEF1A, 0xFB97F847, 0x0081034D, 0xFE34FE2F, 0x05A51C39, 0xFCFF073F, +0x0ED50134, 0xFBE30144, 0x0ACF02B9, 0xFA9109FD, 0xEEE00B94, 0x040618CC, 0xEC31F6E7, 0xFEB3F427, +0x0CEE09A6, 0xF2190263, 0x0EC60A12, 0xF72B0937, 0xF2FFFE41, 0xFEE31A1C, 0xF04DF3F8, 0x021DFBDD, +0xFED10D65, 0xEEF0FBB8, 0x0668071F, 0xF2F40629, 0xFA3BFEBE, 0xFD3610B2, 0xF38BEE76, 0xFE6CF72A, +0x073110AB, 0x12DC0736, 0x0130FA1B, 0xF79B0D4D, 0x06771042, 0xFADF0173, 0x08091C2C, 0x09B2F7EA, +0x049A0CE4, 0x1027104B, 0xFF38FCA9, 0xF3090A8D, 0xF7261A8C, 0xFF37FE66, 0x028E244D, 0x0AE9F82A, +0x041B0D97, 0x08A91347, 0x026BF9F1, 0xF1730B62, 0xF43A0B10, 0x013400EE, 0xFA5A1D0B, 0x084BFA86, +0x0275017E, 0x07A1EA5C, 0x00AE0651, 0xFD46EF1E, 0xFBC90402, 0x0965FB03, 0x09BE00A9, 0xFCF60E6E, +0xFE94F9F2, 0x09B2F14B, 0x00EC0AF5, 0x0085ED34, 0x015BFCCD, 0x0BF90476, 0x0A3F007F, 0xF82C1166, +0x030DF562, 0x0B01F284, 0xF6AE0526, 0x0990EA6E, 0x03D0FEDC, 0x02E2066A, 0x09240362, 0xF3D90FA7, +0x0ACDF551, 0x0133FE9E, 0x0FF01027, 0xFA56FE3B, 0xF4E408A0, 0xFDAAF68F, 0xFFBB06F4, 0xE7B303DA, +0x0584FB91, 0xFFD9F899, 0x0C4110D5, 0xFAC6FB3F, 0xFAB809AE, 0xFD6F0630, 0x03190631, 0xE366FE26, +0x056AF5BA, 0x0119F986, 0x074116E7, 0xFC09F525, 0xF6F60856, 0xF88E0574, 0x002F0ABE, 0xE30CF4FE, +0x22E70169, 0xF66AFF56, 0xF23B09F8, 0x03DBF777, 0xFE43F915, 0x035AF8D4, 0xF9DF0DC7, 0x05190B31, +0x23361014, 0xF5C5F8B1, 0xF4F90174, 0xFF82EFEE, 0xFAB7F917, 0x06F5FA3B, 0x03BC0D3B, 0xF9A80A56, +0x1CA4110D, 0x01FCFA9B, 0xF3000243, 0x0807FC82, 0xFCF7F668, 0x080CFC0B, 0xF84D13A6, 0xFC2004A5, +0xFED30132, 0xFD80EF38, 0x0A661297, 0x0CAB0996, 0x051303FD, 0xFDE3F4B1, 0xF68E0003, 0xFA840095, +0xFF840586, 0x0260ECB6, 0x06AB166E, 0x08910C99, 0x03B40831, 0xFEAEFB0C, 0xFA5AF5E0, 0x038403C4, +0xF7B50127, 0x0C83E9D9, 0x046B181F, 0x08B612A4, 0x024E0B91, 0x01000207, 0xFC97F83A, 0xF8B40DD4 + +output0 = +0xFFF0FE8A, 0x01B3FE2F, 0x020EFFF3, 0x000C005A, 0x0040012B, 0xFF70015F, 0xFF40FD66, 0x0120FCAD, +0x01DAFE8E, 0xFF05FFC8, 0x00EE0080, 0x00350269, 0x0094FCA0, 0x0398FD13, 0x03240016, 0xFF7AFEFE, +0x006401AB, 0xFDB70295, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, +0xFB2C034A, 0xFC8F0175, 0xFE6402D8, 0x00810097, 0x015C007D, 0x01760158, 0xFAB702B3, 0xFBC0008C, +0xFDE80195, 0x0050FFB2, 0x012BFFF2, 0x00EB00CD, 0xFAB30041, 0xFCDDFFFF, 0xFD200228, 0xFFD70030, +0x004A0030, 0x004A00A4, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, +0x0157004F, 0x01B2FFA3, 0x025EFFFE, 0xFE5D048C, 0xFAC301F3, 0xFD5BFE59, 0xFFE10181, 0x0151FF78, +0x035B00E8, 0xFE3C030C, 0xFB1CFFA5, 0xFE84FC85, 0xFDB80124, 0x0063FF8B, 0x01FC0236, 0xFEEE01EE, +0xFD31FF7F, 0xFFA1FDC2, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, +0x034202FC, 0xFFFF0471, 0xFE8B012F, 0x002B0237, 0x00A10164, 0x017301DA, 0x029803A6, 0xFE8A03A1, +0xFE8EFF93, 0xFECC031E, 0xFF180338, 0xFEFE0385, 0x0199041C, 0xFE1B02C8, 0xFF6EFF4A, 0xFEAE0180, +0xFE6A0189, 0xFE610144, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, +0x0143FD7B, 0x03030124, 0xFF5B02E4, 0x00A6FFE1, 0x001901AD, 0xFE4D0120, 0x0109FD68, 0x01A90075, +0xFE9C0115, 0x01AB0028, 0xFF9D0119, 0xFEACFF0B, 0x01C2FCFD, 0x0211000C, 0xFF02005C, 0x00D600A9, +0xFFAD0038, 0x001EFF0E, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, +0x0180FE7E, 0x0186FED1, 0x0133FED6, 0xFE52FFE6, 0xFFCB00C9, 0xFEE70242, 0x00ACFE85, 0x019DFF6D, +0x00B5005F, 0xFF0501FC, 0xFE9100E4, 0xFFA90070, 0x00D0FDE8, 0x017DFEDA, 0x008AFF87, 0xFDF101B9, +0xFE30001D, 0xFFCD005C, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, +0x032A0018, 0x0472FEFA, 0x05900042, 0x0034FE3D, 0x00AEFF8E, 0xFF5D0008, 0x031F0119, 0x055100BB, +0x05AE02EC, 0x0036FE6A, 0x00100002, 0xFE78FFDC, 0x03D40175, 0x04410261, 0x035502CE, 0x00A0FE4E, +0x001EFFCF, 0xFE9DFF4C, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, +0xFF8AFE0D, 0x01F3FFD6, 0x002A023F, 0x005FFF16, 0x020C003C, 0x00E601EA, 0x003DFE48, 0x025A00FD, +0xFFA5031A, 0x004C0068, 0x011500DC, 0x00A101A5, 0x0087FD60, 0x01BC01B5, 0xFD6602EA, 0x006A01B3, +0x00090192, 0x002A0131, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 + + +in_sequence_size = +24 + +in_leading_padding = +0 + +out_sequence_size = +3 + +out_leading_depadding = +0 + +window_index = +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + +cs_bitmap = +255 + +num_antennas_log2 = +3 + +ifft_log2 = +5 + +fft_log2 = +2 + +cs_time_adjustment = +0 + +ifft_shift = +2 + +fft_shift = +3 + +ncs_reciprocal = +4096 + +op_flags = +RTE_BBDEV_FFT_CS_ADJUSTMENT, RTE_BBDEV_FFT_WINDOWING, RTE_BBDEV_FFT_IDFT_BYPASS + +expected_status = +OK + -- 2.37.1