[PATCH v2 0/3] crypto/scheduler: add fail-over mode

[PATCH v2 0/3] crypto/scheduler: add fail-over mode

[Fan Zhang]

This patch adds fail-over mode for cryptodev scheduler PMD. Fail-over mode
works with 2 slaves, primary slave and secondary slave. In this mode, the
scheduler will enqueues the incoming crypto op burst to the primary slave.
When one or more crypto ops are failed to be enqueued, they then will be
enqueued to the secondary slave.

Fan Zhang (3):
  crypto/scheduler: add fail-over scheduling mode file
  crypto/scheduler: enable fail-over scheduling mode
  doc: update cryptodev scheduler PMD documentation

 doc/guides/cryptodevs/scheduler.rst                |   7 +
 drivers/crypto/scheduler/Makefile                  |   1 +
 drivers/crypto/scheduler/rte_cryptodev_scheduler.c |   7 +
 drivers/crypto/scheduler/rte_cryptodev_scheduler.h |   3 +
 drivers/crypto/scheduler/scheduler_failover.c      | 324 +++++++++++++++++++++
 5 files changed, 342 insertions(+)
 create mode 100644 drivers/crypto/scheduler/scheduler_failover.c

-- 
2.7.4

[PATCH v2 1/3] crypto/scheduler: add fail-over scheduling mode file

[Fan Zhang]

This patch adds the fail-over scheduling mode main source file.

Signed-off-by: Fan Zhang <roy.fan.zhang@intel.com>
---
 drivers/crypto/scheduler/scheduler_failover.c | 324 ++++++++++++++++++++++++++
 1 file changed, 324 insertions(+)
 create mode 100644 drivers/crypto/scheduler/scheduler_failover.c

diff --git a/drivers/crypto/scheduler/scheduler_failover.c b/drivers/crypto/scheduler/scheduler_failover.c
new file mode 100644
index 0000000..58c8302
--- /dev/null
+++ b/drivers/crypto/scheduler/scheduler_failover.c
@@ -0,0 +1,324 @@
+/*-
+ *   BSD LICENSE
+ *
+ *   Copyright(c) 2017 Intel Corporation. All rights reserved.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following conditions
+ *   are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in
+ *       the documentation and/or other materials provided with the
+ *       distribution.
+ *     * Neither the name of Intel Corporation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <rte_cryptodev.h>
+#include <rte_malloc.h>
+
+#include "rte_cryptodev_scheduler_operations.h"
+#include "scheduler_pmd_private.h"
+
+#define PRIMARY_SLAVE_IDX	0
+#define SECONDARY_SLAVE_IDX	1
+#define NB_FAILOVER_SLAVES	2
+#define SLAVE_SWITCH_MASK	(0x01)
+
+struct fo_scheduler_qp_ctx {
+	struct scheduler_slave primary_slave;
+	struct scheduler_slave secondary_slave;
+
+	uint8_t deq_idx;
+};
+
+static inline uint16_t __attribute__((always_inline))
+failover_slave_enqueue(struct scheduler_slave *slave, uint8_t slave_idx,
+		struct rte_crypto_op **ops, uint16_t nb_ops)
+{
+	uint16_t i, processed_ops;
+	struct rte_cryptodev_sym_session *sessions[nb_ops];
+	struct scheduler_session *sess0, *sess1, *sess2, *sess3;
+
+	for (i = 0; i < nb_ops && i < 4; i++)
+		rte_prefetch0(ops[i]->sym->session);
+
+	for (i = 0; (i < (nb_ops - 8)) && (nb_ops > 8); i += 4) {
+		rte_prefetch0(ops[i + 4]->sym->session);
+		rte_prefetch0(ops[i + 5]->sym->session);
+		rte_prefetch0(ops[i + 6]->sym->session);
+		rte_prefetch0(ops[i + 7]->sym->session);
+
+		sess0 = (struct scheduler_session *)
+				ops[i]->sym->session->_private;
+		sess1 = (struct scheduler_session *)
+				ops[i+1]->sym->session->_private;
+		sess2 = (struct scheduler_session *)
+				ops[i+2]->sym->session->_private;
+		sess3 = (struct scheduler_session *)
+				ops[i+3]->sym->session->_private;
+
+		sessions[i] = ops[i]->sym->session;
+		sessions[i + 1] = ops[i + 1]->sym->session;
+		sessions[i + 2] = ops[i + 2]->sym->session;
+		sessions[i + 3] = ops[i + 3]->sym->session;
+
+		ops[i]->sym->session = sess0->sessions[slave_idx];
+		ops[i + 1]->sym->session = sess1->sessions[slave_idx];
+		ops[i + 2]->sym->session = sess2->sessions[slave_idx];
+		ops[i + 3]->sym->session = sess3->sessions[slave_idx];
+	}
+
+	for (; i < nb_ops; i++) {
+		sess0 = (struct scheduler_session *)
+				ops[i]->sym->session->_private;
+		sessions[i] = ops[i]->sym->session;
+		ops[i]->sym->session = sess0->sessions[slave_idx];
+	}
+
+	processed_ops = rte_cryptodev_enqueue_burst(slave->dev_id,
+			slave->qp_id, ops, nb_ops);
+	slave->nb_inflight_cops += processed_ops;
+
+	if (unlikely(processed_ops < nb_ops))
+		for (i = processed_ops; i < nb_ops; i++)
+			ops[i]->sym->session = sessions[i];
+
+	return processed_ops;
+}
+
+static uint16_t
+schedule_enqueue(void *qp, struct rte_crypto_op **ops, uint16_t nb_ops)
+{
+	struct fo_scheduler_qp_ctx *qp_ctx =
+			((struct scheduler_qp_ctx *)qp)->private_qp_ctx;
+	uint16_t enqueued_ops;
+
+	if (unlikely(nb_ops == 0))
+		return 0;
+
+	enqueued_ops = failover_slave_enqueue(&qp_ctx->primary_slave,
+			PRIMARY_SLAVE_IDX, ops, nb_ops);
+
+	if (enqueued_ops < nb_ops)
+		enqueued_ops += failover_slave_enqueue(&qp_ctx->secondary_slave,
+				SECONDARY_SLAVE_IDX, &ops[enqueued_ops],
+				nb_ops - enqueued_ops);
+
+	return enqueued_ops;
+}
+
+
+static uint16_t
+schedule_enqueue_ordering(void *qp, struct rte_crypto_op **ops,
+		uint16_t nb_ops)
+{
+	struct rte_ring *order_ring =
+			((struct scheduler_qp_ctx *)qp)->order_ring;
+	uint16_t nb_ops_to_enq = get_max_enqueue_order_count(order_ring,
+			nb_ops);
+	uint16_t nb_ops_enqd = schedule_enqueue(qp, ops,
+			nb_ops_to_enq);
+
+	scheduler_order_insert(order_ring, ops, nb_ops_enqd);
+
+	return nb_ops_enqd;
+}
+
+static uint16_t
+schedule_dequeue(void *qp, struct rte_crypto_op **ops, uint16_t nb_ops)
+{
+	struct fo_scheduler_qp_ctx *qp_ctx =
+			((struct scheduler_qp_ctx *)qp)->private_qp_ctx;
+	struct scheduler_slave *slaves[NB_FAILOVER_SLAVES] = {
+			&qp_ctx->primary_slave, &qp_ctx->secondary_slave};
+	struct scheduler_slave *slave = slaves[qp_ctx->deq_idx];
+	uint16_t nb_deq_ops = 0, nb_deq_ops2 = 0;
+
+	if (slave->nb_inflight_cops) {
+		nb_deq_ops = rte_cryptodev_dequeue_burst(slave->dev_id,
+			slave->qp_id, ops, nb_ops);
+		slave->nb_inflight_cops -= nb_deq_ops;
+
+		/* force a flush */
+		if (unlikely(nb_deq_ops == 0))
+			rte_cryptodev_enqueue_burst(slave->dev_id, slave->qp_id,
+					NULL, 0);
+	}
+
+	qp_ctx->deq_idx = (~qp_ctx->deq_idx) & SLAVE_SWITCH_MASK;
+
+	if (nb_deq_ops == nb_ops)
+		return nb_deq_ops;
+
+	slave = slaves[qp_ctx->deq_idx];
+
+	if (slave->nb_inflight_cops) {
+		nb_deq_ops2 = rte_cryptodev_dequeue_burst(slave->dev_id,
+			slave->qp_id, &ops[nb_deq_ops], nb_ops - nb_deq_ops);
+		slave->nb_inflight_cops -= nb_deq_ops2;
+
+		/* force a flush */
+		if (unlikely(nb_deq_ops == 0))
+			rte_cryptodev_enqueue_burst(slave->dev_id, slave->qp_id,
+					NULL, 0);
+	}
+
+	return nb_deq_ops + nb_deq_ops2;
+}
+
+static uint16_t
+schedule_dequeue_ordering(void *qp, struct rte_crypto_op **ops,
+		uint16_t nb_ops)
+{
+	struct rte_ring *order_ring =
+			((struct scheduler_qp_ctx *)qp)->order_ring;
+	struct fo_scheduler_qp_ctx *qp_ctx =
+			((struct scheduler_qp_ctx *)qp)->private_qp_ctx;
+	uint16_t nb_deq_ops = 0;
+
+	if (qp_ctx->primary_slave.nb_inflight_cops) {
+		nb_deq_ops = rte_cryptodev_dequeue_burst(
+				qp_ctx->primary_slave.dev_id,
+				qp_ctx->primary_slave.qp_id, ops, nb_ops);
+		qp_ctx->primary_slave.nb_inflight_cops -= nb_deq_ops;
+
+		/* force a flush */
+		if (unlikely(nb_deq_ops == 0))
+			rte_cryptodev_enqueue_burst(
+					qp_ctx->primary_slave.dev_id,
+					qp_ctx->primary_slave.qp_id,
+					NULL, 0);
+	}
+
+	if (qp_ctx->secondary_slave.nb_inflight_cops) {
+		nb_deq_ops = rte_cryptodev_dequeue_burst(
+				qp_ctx->secondary_slave.dev_id,
+				qp_ctx->secondary_slave.qp_id, ops, nb_ops);
+		qp_ctx->secondary_slave.nb_inflight_cops -= nb_deq_ops;
+
+		/* force a flush */
+		if (unlikely(nb_deq_ops == 0))
+			rte_cryptodev_enqueue_burst(
+					qp_ctx->secondary_slave.dev_id,
+					qp_ctx->secondary_slave.qp_id,
+					NULL, 0);
+	}
+
+	return scheduler_order_drain(order_ring, ops, nb_ops);
+}
+
+static int
+slave_attach(__rte_unused struct rte_cryptodev *dev,
+		__rte_unused uint8_t slave_id)
+{
+	return 0;
+}
+
+static int
+slave_detach(__rte_unused struct rte_cryptodev *dev,
+		__rte_unused uint8_t slave_id)
+{
+	return 0;
+}
+
+static int
+scheduler_start(struct rte_cryptodev *dev)
+{
+	struct scheduler_ctx *sched_ctx = dev->data->dev_private;
+	uint16_t i;
+
+	if (sched_ctx->nb_slaves < 2) {
+		CS_LOG_ERR("Number of slaves shall no less than 2");
+		return -ENOMEM;
+	}
+
+	if (sched_ctx->reordering_enabled) {
+		dev->enqueue_burst = schedule_enqueue_ordering;
+		dev->dequeue_burst = schedule_dequeue_ordering;
+	} else {
+		dev->enqueue_burst = schedule_enqueue;
+		dev->dequeue_burst = schedule_dequeue;
+	}
+
+	for (i = 0; i < dev->data->nb_queue_pairs; i++) {
+		struct fo_scheduler_qp_ctx *qp_ctx =
+			((struct scheduler_qp_ctx *)
+				dev->data->queue_pairs[i])->private_qp_ctx;
+
+		rte_memcpy(&qp_ctx->primary_slave,
+				&sched_ctx->slaves[PRIMARY_SLAVE_IDX],
+				sizeof(struct scheduler_slave));
+		rte_memcpy(&qp_ctx->secondary_slave,
+				&sched_ctx->slaves[SECONDARY_SLAVE_IDX],
+				sizeof(struct scheduler_slave));
+	}
+
+	return 0;
+}
+
+static int
+scheduler_stop(__rte_unused struct rte_cryptodev *dev)
+{
+	return 0;
+}
+
+static int
+scheduler_config_qp(struct rte_cryptodev *dev, uint16_t qp_id)
+{
+	struct scheduler_qp_ctx *qp_ctx = dev->data->queue_pairs[qp_id];
+	struct fo_scheduler_qp_ctx *fo_qp_ctx;
+
+	fo_qp_ctx = rte_zmalloc_socket(NULL, sizeof(*fo_qp_ctx), 0,
+			rte_socket_id());
+	if (!fo_qp_ctx) {
+		CS_LOG_ERR("failed allocate memory for private queue pair");
+		return -ENOMEM;
+	}
+
+	qp_ctx->private_qp_ctx = (void *)fo_qp_ctx;
+
+	return 0;
+}
+
+static int
+scheduler_create_private_ctx(__rte_unused struct rte_cryptodev *dev)
+{
+	return 0;
+}
+
+struct rte_cryptodev_scheduler_ops scheduler_fo_ops = {
+	slave_attach,
+	slave_detach,
+	scheduler_start,
+	scheduler_stop,
+	scheduler_config_qp,
+	scheduler_create_private_ctx,
+};
+
+struct rte_cryptodev_scheduler fo_scheduler = {
+		.name = "failover-scheduler",
+		.description = "scheduler which enqueues to the primary slave, "
+				"and only then enqueues to the secondary slave "
+				"upon failing on enqueuing to primary",
+		.mode = CDEV_SCHED_MODE_FAILOVER,
+		.ops = &scheduler_fo_ops
+};
+
+struct rte_cryptodev_scheduler *failover_scheduler = &fo_scheduler;
-- 
2.7.4

[PATCH v2 2/3] crypto/scheduler: enable fail-over scheduling mode

[Fan Zhang]

This patch enables the fail-over mode in scheduler PMD.

Signed-off-by: Fan Zhang <roy.fan.zhang@intel.com>
---
 drivers/crypto/scheduler/Makefile                  | 1 +
 drivers/crypto/scheduler/rte_cryptodev_scheduler.c | 7 +++++++
 drivers/crypto/scheduler/rte_cryptodev_scheduler.h | 3 +++
 3 files changed, 11 insertions(+)

diff --git a/drivers/crypto/scheduler/Makefile b/drivers/crypto/scheduler/Makefile
index 0cce6f2..cb61c4f 100644
--- a/drivers/crypto/scheduler/Makefile
+++ b/drivers/crypto/scheduler/Makefile
@@ -54,6 +54,7 @@ SRCS-$(CONFIG_RTE_LIBRTE_PMD_CRYPTO_SCHEDULER) += scheduler_pmd.c
 SRCS-$(CONFIG_RTE_LIBRTE_PMD_CRYPTO_SCHEDULER) += scheduler_pmd_ops.c
 SRCS-$(CONFIG_RTE_LIBRTE_PMD_CRYPTO_SCHEDULER) += rte_cryptodev_scheduler.c
 SRCS-$(CONFIG_RTE_LIBRTE_PMD_CRYPTO_SCHEDULER) += scheduler_roundrobin.c
+SRCS-$(CONFIG_RTE_LIBRTE_PMD_CRYPTO_SCHEDULER) += scheduler_failover.c
 
 # library dependencies
 DEPDIRS-$(CONFIG_RTE_LIBRTE_PMD_CRYPTO_SCHEDULER) += lib/librte_cryptodev
diff --git a/drivers/crypto/scheduler/rte_cryptodev_scheduler.c b/drivers/crypto/scheduler/rte_cryptodev_scheduler.c
index 11e8143..934d3b7 100644
--- a/drivers/crypto/scheduler/rte_cryptodev_scheduler.c
+++ b/drivers/crypto/scheduler/rte_cryptodev_scheduler.c
@@ -336,6 +336,13 @@ rte_crpytodev_scheduler_mode_set(uint8_t scheduler_id,
 			return -1;
 		}
 		break;
+	case CDEV_SCHED_MODE_FAILOVER:
+		if (rte_cryptodev_scheduler_load_user_scheduler(scheduler_id,
+				failover_scheduler) < 0) {
+			CS_LOG_ERR("Failed to load scheduler");
+			return -1;
+		}
+		break;
 	default:
 		CS_LOG_ERR("Not yet supported");
 		return -ENOTSUP;
diff --git a/drivers/crypto/scheduler/rte_cryptodev_scheduler.h b/drivers/crypto/scheduler/rte_cryptodev_scheduler.h
index 7ef44e7..124d32f 100644
--- a/drivers/crypto/scheduler/rte_cryptodev_scheduler.h
+++ b/drivers/crypto/scheduler/rte_cryptodev_scheduler.h
@@ -47,6 +47,8 @@ enum rte_cryptodev_scheduler_mode {
 	CDEV_SCHED_MODE_NOT_SET = 0,
 	CDEV_SCHED_MODE_USERDEFINED,
 	CDEV_SCHED_MODE_ROUNDROBIN,
+	/** fail-over mode */
+	CDEV_SCHED_MODE_FAILOVER,
 
 	CDEV_SCHED_MODE_COUNT /* number of modes */
 };
@@ -158,6 +160,7 @@ struct rte_cryptodev_scheduler {
 };
 
 extern struct rte_cryptodev_scheduler *roundrobin_scheduler;
+extern struct rte_cryptodev_scheduler *failover_scheduler;
 
 #ifdef __cplusplus
 }
-- 
2.7.4

[PATCH v2 3/3] doc: update cryptodev scheduler PMD documentation

[Fan Zhang]

This patch updates fail-over scheduling mode description.

Signed-off-by: Fan Zhang <roy.fan.zhang@intel.com>
---
 doc/guides/cryptodevs/scheduler.rst | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/doc/guides/cryptodevs/scheduler.rst b/doc/guides/cryptodevs/scheduler.rst
index 70fb62e..da051ad 100644
--- a/doc/guides/cryptodevs/scheduler.rst
+++ b/doc/guides/cryptodevs/scheduler.rst
@@ -126,3 +126,10 @@ operation:
    among its slaves in a round-robin manner. This mode may help to fill
    the throughput gap between the physical core and the existing cryptodevs
    to increase the overall performance.
+
+*   **CDEV_SCHED_MODE_FAILOVER:**
+
+   Fail-over mode, which works with 2 slaves, primary slave and secondary
+   slave. In this mode, the scheduler will enqueues the incoming crypto op
+   burst to the primary slave. When one or more crypto ops are failed to
+   be enqueued, they then will be enqueued to the secondary slave.
-- 
2.7.4

Re: [PATCH v2 1/3] crypto/scheduler: add fail-over scheduling mode file

[Declan Doherty]

On 23/03/17 13:02, Fan Zhang wrote:
> This patch adds the fail-over scheduling mode main source file.
>

A little bit of detail on how the fail over scheduling will work would 
be good in the commit comment.


> Signed-off-by: Fan Zhang <roy.fan.zhang@intel.com>
> ---
>  drivers/crypto/scheduler/scheduler_failover.c | 324 ++++++++++++++++++++++++++
>  1 file changed, 324 insertions(+)
>  create mode 100644 drivers/crypto/scheduler/scheduler_failover.c
>
> diff --git a/drivers/crypto/scheduler/scheduler_failover.c b/drivers/crypto/scheduler/scheduler_failover.c
> new file mode 100644
> index 0000000..58c8302
> --- /dev/null
> +++ b/drivers/crypto/scheduler/scheduler_failover.c
> @@ -0,0 +1,324 @@
> +/*-
> + *   BSD LICENSE
> + *
> + *   Copyright(c) 2017 Intel Corporation. All rights reserved.
> + *
> + *   Redistribution and use in source and binary forms, with or without
> + *   modification, are permitted provided that the following conditions
> + *   are met:
> + *
> + *     * Redistributions of source code must retain the above copyright
> + *       notice, this list of conditions and the following disclaimer.
> + *     * Redistributions in binary form must reproduce the above copyright
> + *       notice, this list of conditions and the following disclaimer in
> + *       the documentation and/or other materials provided with the
> + *       distribution.
> + *     * Neither the name of Intel Corporation nor the names of its
> + *       contributors may be used to endorse or promote products derived
> + *       from this software without specific prior written permission.
> + *
> + *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
> + *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
> + *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
> + *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
> + *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
> + *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
> + *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
> + *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
> + *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
> + *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
> + *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> + */
> +
> +#include <rte_cryptodev.h>
> +#include <rte_malloc.h>
> +
> +#include "rte_cryptodev_scheduler_operations.h"
> +#include "scheduler_pmd_private.h"
> +
> +#define PRIMARY_SLAVE_IDX	0
> +#define SECONDARY_SLAVE_IDX	1
> +#define NB_FAILOVER_SLAVES	2
> +#define SLAVE_SWITCH_MASK	(0x01)
> +
> +struct fo_scheduler_qp_ctx {
> +	struct scheduler_slave primary_slave;
> +	struct scheduler_slave secondary_slave;
> +
> +	uint8_t deq_idx;
> +};
> +
> +static inline uint16_t __attribute__((always_inline))
> +failover_slave_enqueue(struct scheduler_slave *slave, uint8_t slave_idx,
> +		struct rte_crypto_op **ops, uint16_t nb_ops)
> +{
> +	uint16_t i, processed_ops;
> +	struct rte_cryptodev_sym_session *sessions[nb_ops];
> +	struct scheduler_session *sess0, *sess1, *sess2, *sess3;
> +
> +	for (i = 0; i < nb_ops && i < 4; i++)
> +		rte_prefetch0(ops[i]->sym->session);
> +
> +	for (i = 0; (i < (nb_ops - 8)) && (nb_ops > 8); i += 4) {
> +		rte_prefetch0(ops[i + 4]->sym->session);
> +		rte_prefetch0(ops[i + 5]->sym->session);
> +		rte_prefetch0(ops[i + 6]->sym->session);
> +		rte_prefetch0(ops[i + 7]->sym->session);
> +
> +		sess0 = (struct scheduler_session *)
> +				ops[i]->sym->session->_private;
> +		sess1 = (struct scheduler_session *)
> +				ops[i+1]->sym->session->_private;
> +		sess2 = (struct scheduler_session *)
> +				ops[i+2]->sym->session->_private;
> +		sess3 = (struct scheduler_session *)
> +				ops[i+3]->sym->session->_private;
> +
> +		sessions[i] = ops[i]->sym->session;
> +		sessions[i + 1] = ops[i + 1]->sym->session;
> +		sessions[i + 2] = ops[i + 2]->sym->session;
> +		sessions[i + 3] = ops[i + 3]->sym->session;
> +
> +		ops[i]->sym->session = sess0->sessions[slave_idx];
> +		ops[i + 1]->sym->session = sess1->sessions[slave_idx];
> +		ops[i + 2]->sym->session = sess2->sessions[slave_idx];
> +		ops[i + 3]->sym->session = sess3->sessions[slave_idx];
> +	}
> +
> +	for (; i < nb_ops; i++) {
> +		sess0 = (struct scheduler_session *)
> +				ops[i]->sym->session->_private;
> +		sessions[i] = ops[i]->sym->session;
> +		ops[i]->sym->session = sess0->sessions[slave_idx];
> +	}
> +
> +	processed_ops = rte_cryptodev_enqueue_burst(slave->dev_id,
> +			slave->qp_id, ops, nb_ops);
> +	slave->nb_inflight_cops += processed_ops;
> +
> +	if (unlikely(processed_ops < nb_ops))
> +		for (i = processed_ops; i < nb_ops; i++)
> +			ops[i]->sym->session = sessions[i];
> +
> +	return processed_ops;
> +}
> +
> +static uint16_t
> +schedule_enqueue(void *qp, struct rte_crypto_op **ops, uint16_t nb_ops)
> +{
> +	struct fo_scheduler_qp_ctx *qp_ctx =
> +			((struct scheduler_qp_ctx *)qp)->private_qp_ctx;
> +	uint16_t enqueued_ops;
> +
> +	if (unlikely(nb_ops == 0))
> +		return 0;
> +
> +	enqueued_ops = failover_slave_enqueue(&qp_ctx->primary_slave,
> +			PRIMARY_SLAVE_IDX, ops, nb_ops);
> +
> +	if (enqueued_ops < nb_ops)
> +		enqueued_ops += failover_slave_enqueue(&qp_ctx->secondary_slave,
> +				SECONDARY_SLAVE_IDX, &ops[enqueued_ops],
> +				nb_ops - enqueued_ops);
> +
> +	return enqueued_ops;
> +}
> +
> +
> +static uint16_t
> +schedule_enqueue_ordering(void *qp, struct rte_crypto_op **ops,
> +		uint16_t nb_ops)
> +{
> +	struct rte_ring *order_ring =
> +			((struct scheduler_qp_ctx *)qp)->order_ring;
> +	uint16_t nb_ops_to_enq = get_max_enqueue_order_count(order_ring,
> +			nb_ops);
> +	uint16_t nb_ops_enqd = schedule_enqueue(qp, ops,
> +			nb_ops_to_enq);
> +
> +	scheduler_order_insert(order_ring, ops, nb_ops_enqd);
> +
> +	return nb_ops_enqd;
> +}
> +
> +static uint16_t
> +schedule_dequeue(void *qp, struct rte_crypto_op **ops, uint16_t nb_ops)
> +{
> +	struct fo_scheduler_qp_ctx *qp_ctx =
> +			((struct scheduler_qp_ctx *)qp)->private_qp_ctx;
> +	struct scheduler_slave *slaves[NB_FAILOVER_SLAVES] = {
> +			&qp_ctx->primary_slave, &qp_ctx->secondary_slave};
> +	struct scheduler_slave *slave = slaves[qp_ctx->deq_idx];
> +	uint16_t nb_deq_ops = 0, nb_deq_ops2 = 0;
> +
> +	if (slave->nb_inflight_cops) {
> +		nb_deq_ops = rte_cryptodev_dequeue_burst(slave->dev_id,
> +			slave->qp_id, ops, nb_ops);
> +		slave->nb_inflight_cops -= nb_deq_ops;
> +
> +		/* force a flush */
> +		if (unlikely(nb_deq_ops == 0))
> +			rte_cryptodev_enqueue_burst(slave->dev_id, slave->qp_id,
> +					NULL, 0);

I don't think the flush logic should be within the scheduler, it should 
be left up to the application as whether it is needed is dependent on 
the PMDs being used.

> +	}
> +
> +	qp_ctx->deq_idx = (~qp_ctx->deq_idx) & SLAVE_SWITCH_MASK;
> +
> +	if (nb_deq_ops == nb_ops)
> +		return nb_deq_ops;
> +
> +	slave = slaves[qp_ctx->deq_idx];
> +
> +	if (slave->nb_inflight_cops) {
> +		nb_deq_ops2 = rte_cryptodev_dequeue_burst(slave->dev_id,
> +			slave->qp_id, &ops[nb_deq_ops], nb_ops - nb_deq_ops);
> +		slave->nb_inflight_cops -= nb_deq_ops2;
> +
> +		/* force a flush */
> +		if (unlikely(nb_deq_ops == 0))
> +			rte_cryptodev_enqueue_burst(slave->dev_id, slave->qp_id,
> +					NULL, 0);
> +	}
> +
> +	return nb_deq_ops + nb_deq_ops2;
> +}
> +
> +static uint16_t
> +schedule_dequeue_ordering(void *qp, struct rte_crypto_op **ops,
> +		uint16_t nb_ops)
> +{
> +	struct rte_ring *order_ring =
> +			((struct scheduler_qp_ctx *)qp)->order_ring;
> +	struct fo_scheduler_qp_ctx *qp_ctx =
> +			((struct scheduler_qp_ctx *)qp)->private_qp_ctx;
> +	uint16_t nb_deq_ops = 0;
> +
> +	if (qp_ctx->primary_slave.nb_inflight_cops) {
> +		nb_deq_ops = rte_cryptodev_dequeue_burst(
> +				qp_ctx->primary_slave.dev_id,
> +				qp_ctx->primary_slave.qp_id, ops, nb_ops);
> +		qp_ctx->primary_slave.nb_inflight_cops -= nb_deq_ops;
> +
> +		/* force a flush */
> +		if (unlikely(nb_deq_ops == 0))
> +			rte_cryptodev_enqueue_burst(
> +					qp_ctx->primary_slave.dev_id,
> +					qp_ctx->primary_slave.qp_id,
> +					NULL, 0);
> +	}
> +
> +	if (qp_ctx->secondary_slave.nb_inflight_cops) {
> +		nb_deq_ops = rte_cryptodev_dequeue_burst(
> +				qp_ctx->secondary_slave.dev_id,
> +				qp_ctx->secondary_slave.qp_id, ops, nb_ops);
> +		qp_ctx->secondary_slave.nb_inflight_cops -= nb_deq_ops;
> +
> +		/* force a flush */
> +		if (unlikely(nb_deq_ops == 0))
> +			rte_cryptodev_enqueue_burst(
> +					qp_ctx->secondary_slave.dev_id,
> +					qp_ctx->secondary_slave.qp_id,
> +					NULL, 0);
> +	}

I think we should just use the schedule_dequeue function above, I know 
it will limit the total operations dequeue from both slaves but this may 
be preferable behavior, as we could could be spending may more cycles 
that we need dequeuing extra operations in slaves than are needed in the 
reorder ring.

> +
> +	return scheduler_order_drain(order_ring, ops, nb_ops);
> +}
> +
> +static int
> +slave_attach(__rte_unused struct rte_cryptodev *dev,
> +		__rte_unused uint8_t slave_id)
> +{
> +	return 0;
> +}
> +
> +static int
> +slave_detach(__rte_unused struct rte_cryptodev *dev,
> +		__rte_unused uint8_t slave_id)
> +{
> +	return 0;
> +}
> +
> +static int
> +scheduler_start(struct rte_cryptodev *dev)
> +{
> +	struct scheduler_ctx *sched_ctx = dev->data->dev_private;
> +	uint16_t i;
> +
> +	if (sched_ctx->nb_slaves < 2) {
> +		CS_LOG_ERR("Number of slaves shall no less than 2");
> +		return -ENOMEM;
> +	}
> +
> +	if (sched_ctx->reordering_enabled) {
> +		dev->enqueue_burst = schedule_enqueue_ordering;
> +		dev->dequeue_burst = schedule_dequeue_ordering;
> +	} else {
> +		dev->enqueue_burst = schedule_enqueue;
> +		dev->dequeue_burst = schedule_dequeue;
> +	}
> +
> +	for (i = 0; i < dev->data->nb_queue_pairs; i++) {
> +		struct fo_scheduler_qp_ctx *qp_ctx =
> +			((struct scheduler_qp_ctx *)
> +				dev->data->queue_pairs[i])->private_qp_ctx;
> +
> +		rte_memcpy(&qp_ctx->primary_slave,
> +				&sched_ctx->slaves[PRIMARY_SLAVE_IDX],
> +				sizeof(struct scheduler_slave));
> +		rte_memcpy(&qp_ctx->secondary_slave,
> +				&sched_ctx->slaves[SECONDARY_SLAVE_IDX],
> +				sizeof(struct scheduler_slave));
> +	}
> +
> +	return 0;
> +}
> +
> +static int
> +scheduler_stop(__rte_unused struct rte_cryptodev *dev)
> +{
> +	return 0;
> +}
> +
> +static int
> +scheduler_config_qp(struct rte_cryptodev *dev, uint16_t qp_id)
> +{
> +	struct scheduler_qp_ctx *qp_ctx = dev->data->queue_pairs[qp_id];
> +	struct fo_scheduler_qp_ctx *fo_qp_ctx;
> +
> +	fo_qp_ctx = rte_zmalloc_socket(NULL, sizeof(*fo_qp_ctx), 0,
> +			rte_socket_id());
> +	if (!fo_qp_ctx) {
> +		CS_LOG_ERR("failed allocate memory for private queue pair");
> +		return -ENOMEM;
> +	}
> +
> +	qp_ctx->private_qp_ctx = (void *)fo_qp_ctx;
> +
> +	return 0;
> +}
> +
> +static int
> +scheduler_create_private_ctx(__rte_unused struct rte_cryptodev *dev)
> +{
> +	return 0;
> +}
> +
> +struct rte_cryptodev_scheduler_ops scheduler_fo_ops = {
> +	slave_attach,
> +	slave_detach,
> +	scheduler_start,
> +	scheduler_stop,
> +	scheduler_config_qp,
> +	scheduler_create_private_ctx,
> +};
> +
> +struct rte_cryptodev_scheduler fo_scheduler = {
> +		.name = "failover-scheduler",
> +		.description = "scheduler which enqueues to the primary slave, "
> +				"and only then enqueues to the secondary slave "
> +				"upon failing on enqueuing to primary",
> +		.mode = CDEV_SCHED_MODE_FAILOVER,
> +		.ops = &scheduler_fo_ops
> +};
> +
> +struct rte_cryptodev_scheduler *failover_scheduler = &fo_scheduler;
>