From: Nicolas Chautru <nicolas.chautru@intel.com>
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 <nicolas.chautru@intel.com>
Subject: [PATCH v10 16/16] test-bbdev: unit test capability extension
Date: Tue, 11 Oct 2022 14:15:38 -0700 [thread overview]
Message-ID: <20221011211538.14106-17-nicolas.chautru@intel.com> (raw)
In-Reply-To: <20221011211538.14106-1-nicolas.chautru@intel.com>
From: Nic Chautru <nicolas.chautru@intel.com>
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 <nicolas.chautru@intel.com>
---
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
prev parent reply other threads:[~2022-10-11 21:17 UTC|newest]
Thread overview: 17+ messages / expand[flat|nested] mbox.gz Atom feed top
2022-10-11 21:15 [PATCH v10 00/16] bbdev ACC200 PMD Nicolas Chautru
2022-10-11 21:15 ` [PATCH v10 01/16] baseband/acc100: remove unused registers Nicolas Chautru
2022-10-11 21:15 ` [PATCH v10 02/16] baseband/acc100: refactor to segregate common code Nicolas Chautru
2022-10-11 21:15 ` [PATCH v10 03/16] baseband/acc: rename directory from acc100 to acc Nicolas Chautru
2022-10-11 21:15 ` [PATCH v10 04/16] baseband/acc: introduce PMD for ACC200 Nicolas Chautru
2022-10-11 21:15 ` [PATCH v10 05/16] baseband/acc: add HW register definitions " Nicolas Chautru
2022-10-11 21:15 ` [PATCH v10 06/16] baseband/acc: add info get function " Nicolas Chautru
2022-10-11 21:15 ` [PATCH v10 07/16] baseband/acc: add queue configuration " Nicolas Chautru
2022-10-11 21:15 ` [PATCH v10 08/16] baseband/acc: add LDPC processing functions Nicolas Chautru
2022-10-11 21:15 ` [PATCH v10 09/16] baseband/acc: add LTE " Nicolas Chautru
2022-10-11 21:15 ` [PATCH v10 10/16] baseband/acc: add support for FFT operations Nicolas Chautru
2022-10-11 21:15 ` [PATCH v10 11/16] baseband/acc: support interrupt Nicolas Chautru
2022-10-11 21:15 ` [PATCH v10 12/16] baseband/acc: add device status and vf2pf comms Nicolas Chautru
2022-10-11 21:15 ` [PATCH v10 13/16] baseband/acc: add PF configure companion function Nicolas Chautru
2022-10-11 21:15 ` [PATCH v10 14/16] baseband/acc: simplify meson dependency Nicolas Chautru
2022-10-11 21:15 ` [PATCH v10 15/16] baseband/acc: add helper function for descriptor index Nicolas Chautru
2022-10-11 21:15 ` Nicolas Chautru [this message]
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20221011211538.14106-17-nicolas.chautru@intel.com \
--to=nicolas.chautru@intel.com \
--cc=bruce.richardson@intel.com \
--cc=david.marchand@redhat.com \
--cc=dev@dpdk.org \
--cc=gakhil@marvell.com \
--cc=hemant.agrawal@nxp.com \
--cc=hernan.vargas@intel.com \
--cc=maxime.coquelin@redhat.com \
--cc=mdr@ashroe.eu \
--cc=stephen@networkplumber.org \
--cc=trix@redhat.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).