* [dpdk-dev] [PATCH v3 0/3] crypto/scheduler: add fail-over mode @ 2017-03-28 14:30 Fan Zhang 2017-03-28 14:30 ` [dpdk-dev] [PATCH v3 1/3] crypto/scheduler: add fail-over scheduling mode file Fan Zhang ` (3 more replies) 0 siblings, 4 replies; 22+ messages in thread From: Fan Zhang @ 2017-03-28 14:30 UTC (permalink / raw) To: dev; +Cc: pablo.de.lara.guarch, sergio.gonzalez.monroy, declan.doherty 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 | 285 +++++++++++++++++++++ 5 files changed, 303 insertions(+) create mode 100644 drivers/crypto/scheduler/scheduler_failover.c -- 2.7.4 ^ permalink raw reply [flat|nested] 22+ messages in thread
* [dpdk-dev] [PATCH v3 1/3] crypto/scheduler: add fail-over scheduling mode file 2017-03-28 14:30 [dpdk-dev] [PATCH v3 0/3] crypto/scheduler: add fail-over mode Fan Zhang @ 2017-03-28 14:30 ` Fan Zhang 2017-03-28 23:09 ` De Lara Guarch, Pablo 2017-03-28 14:30 ` [dpdk-dev] [PATCH v3 2/3] crypto/scheduler: enable fail-over scheduling mode Fan Zhang ` (2 subsequent siblings) 3 siblings, 1 reply; 22+ messages in thread From: Fan Zhang @ 2017-03-28 14:30 UTC (permalink / raw) To: dev; +Cc: pablo.de.lara.guarch, sergio.gonzalez.monroy, declan.doherty This patch adds the fail-over scheduling mode main source file. 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. Signed-off-by: Fan Zhang <roy.fan.zhang@intel.com> --- v3. A few changes: * More detailed commit messages. * Removed device flush. * Updated dequeue_ordering function v2. Update with new reorder method drivers/crypto/scheduler/scheduler_failover.c | 285 ++++++++++++++++++++++++++ 1 file changed, 285 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..6359f04 --- /dev/null +++ b/drivers/crypto/scheduler/scheduler_failover.c @@ -0,0 +1,285 @@ +/*- + * 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; + } + + 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; + } + + 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; + + schedule_dequeue(qp, ops, nb_ops); + + 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 ^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [dpdk-dev] [PATCH v3 1/3] crypto/scheduler: add fail-over scheduling mode file 2017-03-28 14:30 ` [dpdk-dev] [PATCH v3 1/3] crypto/scheduler: add fail-over scheduling mode file Fan Zhang @ 2017-03-28 23:09 ` De Lara Guarch, Pablo 0 siblings, 0 replies; 22+ messages in thread From: De Lara Guarch, Pablo @ 2017-03-28 23:09 UTC (permalink / raw) To: Zhang, Roy Fan, dev; +Cc: Gonzalez Monroy, Sergio, Doherty, Declan Hi Fan, > -----Original Message----- > From: Zhang, Roy Fan > Sent: Tuesday, March 28, 2017 3:31 PM > To: dev@dpdk.org > Cc: De Lara Guarch, Pablo; Gonzalez Monroy, Sergio; Doherty, Declan > Subject: [PATCH v3 1/3] crypto/scheduler: add fail-over scheduling mode > file > > This patch adds the fail-over scheduling mode main source file. 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. > > Signed-off-by: Fan Zhang <roy.fan.zhang@intel.com> Could you update release notes doc? Also for the packet size based scheduling mode. Thanks, Pablo ^ permalink raw reply [flat|nested] 22+ messages in thread
* [dpdk-dev] [PATCH v3 2/3] crypto/scheduler: enable fail-over scheduling mode 2017-03-28 14:30 [dpdk-dev] [PATCH v3 0/3] crypto/scheduler: add fail-over mode Fan Zhang 2017-03-28 14:30 ` [dpdk-dev] [PATCH v3 1/3] crypto/scheduler: add fail-over scheduling mode file Fan Zhang @ 2017-03-28 14:30 ` Fan Zhang 2017-03-28 14:30 ` [dpdk-dev] [PATCH v3 3/3] doc: update cryptodev scheduler PMD documentation Fan Zhang 2017-03-29 8:24 ` [dpdk-dev] [PATCH v4 0/3] crypto/scheduler: add fail-over mode Fan Zhang 3 siblings, 0 replies; 22+ messages in thread From: Fan Zhang @ 2017-03-28 14:30 UTC (permalink / raw) To: dev; +Cc: pablo.de.lara.guarch, sergio.gonzalez.monroy, declan.doherty 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 ^ permalink raw reply [flat|nested] 22+ messages in thread
* [dpdk-dev] [PATCH v3 3/3] doc: update cryptodev scheduler PMD documentation 2017-03-28 14:30 [dpdk-dev] [PATCH v3 0/3] crypto/scheduler: add fail-over mode Fan Zhang 2017-03-28 14:30 ` [dpdk-dev] [PATCH v3 1/3] crypto/scheduler: add fail-over scheduling mode file Fan Zhang 2017-03-28 14:30 ` [dpdk-dev] [PATCH v3 2/3] crypto/scheduler: enable fail-over scheduling mode Fan Zhang @ 2017-03-28 14:30 ` Fan Zhang 2017-03-29 8:24 ` [dpdk-dev] [PATCH v4 0/3] crypto/scheduler: add fail-over mode Fan Zhang 3 siblings, 0 replies; 22+ messages in thread From: Fan Zhang @ 2017-03-28 14:30 UTC (permalink / raw) To: dev; +Cc: pablo.de.lara.guarch, sergio.gonzalez.monroy, declan.doherty 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 ^ permalink raw reply [flat|nested] 22+ messages in thread
* [dpdk-dev] [PATCH v4 0/3] crypto/scheduler: add fail-over mode 2017-03-28 14:30 [dpdk-dev] [PATCH v3 0/3] crypto/scheduler: add fail-over mode Fan Zhang ` (2 preceding siblings ...) 2017-03-28 14:30 ` [dpdk-dev] [PATCH v3 3/3] doc: update cryptodev scheduler PMD documentation Fan Zhang @ 2017-03-29 8:24 ` Fan Zhang 2017-03-29 8:24 ` [dpdk-dev] [PATCH v4 1/3] crypto/scheduler: add fail-over scheduling mode file Fan Zhang ` (4 more replies) 3 siblings, 5 replies; 22+ messages in thread From: Fan Zhang @ 2017-03-29 8:24 UTC (permalink / raw) To: dev; +Cc: pablo.de.lara.guarch, sergio.gonzalez.monroy, declan.doherty This patch adds fail-over mode for cryptodev scheduler PMD. Fail-over mode works with 2 slaves, the primary slave and the secondary slave. In this mode, the scheduler will enqueues the incoming crypto operation burst to the primary slave. When one or more crypto operations fail to be enqueued, then they will be enqueued to the secondary slave. v4: - Polished documentation. - Fixed documentation grammer errors. v3: - More detailed commit messages. - Removed device flush. - Updated dequeue_ordering function v2: - Update with new reorder method 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 | 8 + 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 | 285 +++++++++++++++++++++ 5 files changed, 304 insertions(+) create mode 100644 drivers/crypto/scheduler/scheduler_failover.c -- 2.7.4 ^ permalink raw reply [flat|nested] 22+ messages in thread
* [dpdk-dev] [PATCH v4 1/3] crypto/scheduler: add fail-over scheduling mode file 2017-03-29 8:24 ` [dpdk-dev] [PATCH v4 0/3] crypto/scheduler: add fail-over mode Fan Zhang @ 2017-03-29 8:24 ` Fan Zhang 2017-03-29 8:24 ` [dpdk-dev] [PATCH v4 2/3] crypto/scheduler: enable fail-over scheduling mode Fan Zhang ` (3 subsequent siblings) 4 siblings, 0 replies; 22+ messages in thread From: Fan Zhang @ 2017-03-29 8:24 UTC (permalink / raw) To: dev; +Cc: pablo.de.lara.guarch, sergio.gonzalez.monroy, declan.doherty This patch adds the fail-over scheduling mode main source file. Fail-over mode works with 2 slaves, the primary slave and the secondary slave. In this mode, the scheduler will enqueues the incoming crypto operation burst to the primary slave. When one or more crypto operations fail to be enqueued, then they will be enqueued to the secondary slave. Signed-off-by: Fan Zhang <roy.fan.zhang@intel.com> --- drivers/crypto/scheduler/scheduler_failover.c | 285 ++++++++++++++++++++++++++ 1 file changed, 285 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..6359f04 --- /dev/null +++ b/drivers/crypto/scheduler/scheduler_failover.c @@ -0,0 +1,285 @@ +/*- + * 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; + } + + 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; + } + + 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; + + schedule_dequeue(qp, ops, nb_ops); + + 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 ^ permalink raw reply [flat|nested] 22+ messages in thread
* [dpdk-dev] [PATCH v4 2/3] crypto/scheduler: enable fail-over scheduling mode 2017-03-29 8:24 ` [dpdk-dev] [PATCH v4 0/3] crypto/scheduler: add fail-over mode Fan Zhang 2017-03-29 8:24 ` [dpdk-dev] [PATCH v4 1/3] crypto/scheduler: add fail-over scheduling mode file Fan Zhang @ 2017-03-29 8:24 ` Fan Zhang 2017-03-29 8:24 ` [dpdk-dev] [PATCH v4 3/3] doc: update cryptodev scheduler PMD documentation Fan Zhang ` (2 subsequent siblings) 4 siblings, 0 replies; 22+ messages in thread From: Fan Zhang @ 2017-03-29 8:24 UTC (permalink / raw) To: dev; +Cc: pablo.de.lara.guarch, sergio.gonzalez.monroy, declan.doherty 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 ^ permalink raw reply [flat|nested] 22+ messages in thread
* [dpdk-dev] [PATCH v4 3/3] doc: update cryptodev scheduler PMD documentation 2017-03-29 8:24 ` [dpdk-dev] [PATCH v4 0/3] crypto/scheduler: add fail-over mode Fan Zhang 2017-03-29 8:24 ` [dpdk-dev] [PATCH v4 1/3] crypto/scheduler: add fail-over scheduling mode file Fan Zhang 2017-03-29 8:24 ` [dpdk-dev] [PATCH v4 2/3] crypto/scheduler: enable fail-over scheduling mode Fan Zhang @ 2017-03-29 8:24 ` Fan Zhang 2017-03-29 9:52 ` Mcnamara, John 2017-03-29 11:29 ` [dpdk-dev] [PATCH v4 0/3] crypto/scheduler: add fail-over mode De Lara Guarch, Pablo 2017-03-29 16:31 ` [dpdk-dev] [PATCH v5 " Fan Zhang 4 siblings, 1 reply; 22+ messages in thread From: Fan Zhang @ 2017-03-29 8:24 UTC (permalink / raw) To: dev; +Cc: pablo.de.lara.guarch, sergio.gonzalez.monroy, declan.doherty This patch updates fail-over scheduling mode description. Signed-off-by: Fan Zhang <roy.fan.zhang@intel.com> --- v4: - Fixed grammer errors in documentation - Polished documentation doc/guides/cryptodevs/scheduler.rst | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/doc/guides/cryptodevs/scheduler.rst b/doc/guides/cryptodevs/scheduler.rst index 70fb62e..9f6c477 100644 --- a/doc/guides/cryptodevs/scheduler.rst +++ b/doc/guides/cryptodevs/scheduler.rst @@ -126,3 +126,11 @@ 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, the primary slave and the + secondary slave. In this mode, the scheduler will enqueue the incoming + crypto operation burst to the primary slave. When one or more crypto + operations fail to be enqueued, then they will be enqueued to the secondary + slave. -- 2.7.4 ^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [dpdk-dev] [PATCH v4 3/3] doc: update cryptodev scheduler PMD documentation 2017-03-29 8:24 ` [dpdk-dev] [PATCH v4 3/3] doc: update cryptodev scheduler PMD documentation Fan Zhang @ 2017-03-29 9:52 ` Mcnamara, John 0 siblings, 0 replies; 22+ messages in thread From: Mcnamara, John @ 2017-03-29 9:52 UTC (permalink / raw) To: Zhang, Roy Fan, dev Cc: De Lara Guarch, Pablo, Gonzalez Monroy, Sergio, Doherty, Declan > -----Original Message----- > From: dev [mailto:dev-bounces@dpdk.org] On Behalf Of Fan Zhang > Sent: Wednesday, March 29, 2017 9:24 AM > To: dev@dpdk.org > Cc: De Lara Guarch, Pablo <pablo.de.lara.guarch@intel.com>; Gonzalez > Monroy, Sergio <sergio.gonzalez.monroy@intel.com>; Doherty, Declan > <declan.doherty@intel.com> > Subject: [dpdk-dev] [PATCH v4 3/3] doc: update cryptodev scheduler PMD > documentation > > This patch updates fail-over scheduling mode description. > > Signed-off-by: Fan Zhang <roy.fan.zhang@intel.com> Acked-by: John McNamara <john.mcnamara@intel.com> ^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [dpdk-dev] [PATCH v4 0/3] crypto/scheduler: add fail-over mode 2017-03-29 8:24 ` [dpdk-dev] [PATCH v4 0/3] crypto/scheduler: add fail-over mode Fan Zhang ` (2 preceding siblings ...) 2017-03-29 8:24 ` [dpdk-dev] [PATCH v4 3/3] doc: update cryptodev scheduler PMD documentation Fan Zhang @ 2017-03-29 11:29 ` De Lara Guarch, Pablo 2017-03-29 12:46 ` Bruce Richardson 2017-03-29 16:31 ` [dpdk-dev] [PATCH v5 " Fan Zhang 4 siblings, 1 reply; 22+ messages in thread From: De Lara Guarch, Pablo @ 2017-03-29 11:29 UTC (permalink / raw) To: Zhang, Roy Fan, dev; +Cc: Gonzalez Monroy, Sergio, Doherty, Declan > -----Original Message----- > From: Zhang, Roy Fan > Sent: Wednesday, March 29, 2017 9:24 AM > To: dev@dpdk.org > Cc: De Lara Guarch, Pablo; Gonzalez Monroy, Sergio; Doherty, Declan > Subject: [PATCH v4 0/3] crypto/scheduler: add fail-over mode > > This patch adds fail-over mode for cryptodev scheduler PMD. Fail-over > mode > works with 2 slaves, the primary slave and the secondary slave. In this > mode, the scheduler will enqueues the incoming crypto operation burst to > the > primary slave. When one or more crypto operations fail to be enqueued, > then > they will be enqueued to the secondary slave. > > v4: > - Polished documentation. > - Fixed documentation grammer errors. > > v3: > - More detailed commit messages. > - Removed device flush. > - Updated dequeue_ordering function > > v2: > - Update with new reorder method > > 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 | 8 + > 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 | 285 > +++++++++++++++++++++ > 5 files changed, 304 insertions(+) > create mode 100644 drivers/crypto/scheduler/scheduler_failover.c > > -- > 2.7.4 Series-acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> ^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [dpdk-dev] [PATCH v4 0/3] crypto/scheduler: add fail-over mode 2017-03-29 11:29 ` [dpdk-dev] [PATCH v4 0/3] crypto/scheduler: add fail-over mode De Lara Guarch, Pablo @ 2017-03-29 12:46 ` Bruce Richardson 0 siblings, 0 replies; 22+ messages in thread From: Bruce Richardson @ 2017-03-29 12:46 UTC (permalink / raw) To: De Lara Guarch, Pablo Cc: Zhang, Roy Fan, dev, Gonzalez Monroy, Sergio, Doherty, Declan On Wed, Mar 29, 2017 at 11:29:31AM +0000, De Lara Guarch, Pablo wrote: > > > > -----Original Message----- > > From: Zhang, Roy Fan > > Sent: Wednesday, March 29, 2017 9:24 AM > > To: dev@dpdk.org > > Cc: De Lara Guarch, Pablo; Gonzalez Monroy, Sergio; Doherty, Declan > > Subject: [PATCH v4 0/3] crypto/scheduler: add fail-over mode > > > > This patch adds fail-over mode for cryptodev scheduler PMD. Fail-over > > mode > > works with 2 slaves, the primary slave and the secondary slave. In this > > mode, the scheduler will enqueues the incoming crypto operation burst to > > the > > primary slave. When one or more crypto operations fail to be enqueued, > > then > > they will be enqueued to the secondary slave. > > > > v4: > > - Polished documentation. > > - Fixed documentation grammer errors. > > > > v3: > > - More detailed commit messages. > > - Removed device flush. > > - Updated dequeue_ordering function > > > > v2: > > - Update with new reorder method > > > > 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 | 8 + > > 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 | 285 > > +++++++++++++++++++++ > > 5 files changed, 304 insertions(+) > > create mode 100644 drivers/crypto/scheduler/scheduler_failover.c > > > > -- > > 2.7.4 > > Series-acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Can this driver be enabled by default in DPDK builds? It doesn't seem to have any external dependencies. /Bruce ^ permalink raw reply [flat|nested] 22+ messages in thread
* [dpdk-dev] [PATCH v5 0/3] crypto/scheduler: add fail-over mode 2017-03-29 8:24 ` [dpdk-dev] [PATCH v4 0/3] crypto/scheduler: add fail-over mode Fan Zhang ` (3 preceding siblings ...) 2017-03-29 11:29 ` [dpdk-dev] [PATCH v4 0/3] crypto/scheduler: add fail-over mode De Lara Guarch, Pablo @ 2017-03-29 16:31 ` Fan Zhang 2017-03-29 16:31 ` [dpdk-dev] [PATCH v5 1/3] crypto/scheduler: add fail-over scheduling mode file Fan Zhang ` (3 more replies) 4 siblings, 4 replies; 22+ messages in thread From: Fan Zhang @ 2017-03-29 16:31 UTC (permalink / raw) To: dev; +Cc: pablo.de.lara.guarch, sergio.gonzalez.monroy, declan.doherty This patch adds fail-over mode for cryptodev scheduler PMD. Fail-over mode works with 2 slaves, the primary slave and the secondary slave. In this mode, the scheduler will enqueues the incoming crypto operation burst to the primary slave. When one or more crypto operations fail to be enqueued, then they will be enqueued to the secondary slave. v5: - Updated release note. v4: - Polished documentation. - Fixed documentation grammer errors. v3: - More detailed commit messages. - Removed device flush. - Updated dequeue_ordering function v2: - Update with new reorder method 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 | 8 + doc/guides/rel_notes/release_17_05.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 | 285 +++++++++++++++++++++ 6 files changed, 311 insertions(+) create mode 100644 drivers/crypto/scheduler/scheduler_failover.c -- 2.7.4 ^ permalink raw reply [flat|nested] 22+ messages in thread
* [dpdk-dev] [PATCH v5 1/3] crypto/scheduler: add fail-over scheduling mode file 2017-03-29 16:31 ` [dpdk-dev] [PATCH v5 " Fan Zhang @ 2017-03-29 16:31 ` Fan Zhang 2017-03-30 7:43 ` Declan Doherty 2017-03-29 16:31 ` [dpdk-dev] [PATCH v5 2/3] crypto/scheduler: enable fail-over scheduling mode Fan Zhang ` (2 subsequent siblings) 3 siblings, 1 reply; 22+ messages in thread From: Fan Zhang @ 2017-03-29 16:31 UTC (permalink / raw) To: dev; +Cc: pablo.de.lara.guarch, sergio.gonzalez.monroy, declan.doherty This patch adds the fail-over scheduling mode main source file. 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. Signed-off-by: Fan Zhang <roy.fan.zhang@intel.com> Series-acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> --- drivers/crypto/scheduler/scheduler_failover.c | 285 ++++++++++++++++++++++++++ 1 file changed, 285 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..6359f04 --- /dev/null +++ b/drivers/crypto/scheduler/scheduler_failover.c @@ -0,0 +1,285 @@ +/*- + * 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; + } + + 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; + } + + 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; + + schedule_dequeue(qp, ops, nb_ops); + + 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 ^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [dpdk-dev] [PATCH v5 1/3] crypto/scheduler: add fail-over scheduling mode file 2017-03-29 16:31 ` [dpdk-dev] [PATCH v5 1/3] crypto/scheduler: add fail-over scheduling mode file Fan Zhang @ 2017-03-30 7:43 ` Declan Doherty 0 siblings, 0 replies; 22+ messages in thread From: Declan Doherty @ 2017-03-30 7:43 UTC (permalink / raw) To: Fan Zhang, dev; +Cc: pablo.de.lara.guarch, sergio.gonzalez.monroy On 29/03/2017 5:31 PM, Fan Zhang wrote: > This patch adds the fail-over scheduling mode main source file. 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. > > Signed-off-by: Fan Zhang <roy.fan.zhang@intel.com> > Series-acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> > --- ... > Acked-by: Declan Doherty <declan.doherty@intel.com> ^ permalink raw reply [flat|nested] 22+ messages in thread
* [dpdk-dev] [PATCH v5 2/3] crypto/scheduler: enable fail-over scheduling mode 2017-03-29 16:31 ` [dpdk-dev] [PATCH v5 " Fan Zhang 2017-03-29 16:31 ` [dpdk-dev] [PATCH v5 1/3] crypto/scheduler: add fail-over scheduling mode file Fan Zhang @ 2017-03-29 16:31 ` Fan Zhang 2017-03-30 7:48 ` Declan Doherty 2017-03-29 16:31 ` [dpdk-dev] [PATCH v5 3/3] doc: update cryptodev scheduler PMD documentation Fan Zhang 2017-03-30 12:33 ` [dpdk-dev] [PATCH v5 0/3] crypto/scheduler: add fail-over mode De Lara Guarch, Pablo 3 siblings, 1 reply; 22+ messages in thread From: Fan Zhang @ 2017-03-29 16:31 UTC (permalink / raw) To: dev; +Cc: pablo.de.lara.guarch, sergio.gonzalez.monroy, declan.doherty 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 ^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [dpdk-dev] [PATCH v5 2/3] crypto/scheduler: enable fail-over scheduling mode 2017-03-29 16:31 ` [dpdk-dev] [PATCH v5 2/3] crypto/scheduler: enable fail-over scheduling mode Fan Zhang @ 2017-03-30 7:48 ` Declan Doherty 0 siblings, 0 replies; 22+ messages in thread From: Declan Doherty @ 2017-03-30 7:48 UTC (permalink / raw) To: Fan Zhang, dev; +Cc: pablo.de.lara.guarch, sergio.gonzalez.monroy On 29/03/2017 5:31 PM, Fan Zhang wrote: > This patch enables the fail-over mode in scheduler PMD. > > Signed-off-by: Fan Zhang <roy.fan.zhang@intel.com> > --- .... > Acked-by: Declan Doherty <declan.doherty@intel.com> ^ permalink raw reply [flat|nested] 22+ messages in thread
* [dpdk-dev] [PATCH v5 3/3] doc: update cryptodev scheduler PMD documentation 2017-03-29 16:31 ` [dpdk-dev] [PATCH v5 " Fan Zhang 2017-03-29 16:31 ` [dpdk-dev] [PATCH v5 1/3] crypto/scheduler: add fail-over scheduling mode file Fan Zhang 2017-03-29 16:31 ` [dpdk-dev] [PATCH v5 2/3] crypto/scheduler: enable fail-over scheduling mode Fan Zhang @ 2017-03-29 16:31 ` Fan Zhang 2017-03-30 7:48 ` Declan Doherty 2017-03-30 12:33 ` [dpdk-dev] [PATCH v5 0/3] crypto/scheduler: add fail-over mode De Lara Guarch, Pablo 3 siblings, 1 reply; 22+ messages in thread From: Fan Zhang @ 2017-03-29 16:31 UTC (permalink / raw) To: dev; +Cc: pablo.de.lara.guarch, sergio.gonzalez.monroy, declan.doherty This patch updates fail-over scheduling mode description. Signed-off-by: Fan Zhang <roy.fan.zhang@intel.com> --- doc/guides/cryptodevs/scheduler.rst | 8 ++++++++ doc/guides/rel_notes/release_17_05.rst | 7 +++++++ 2 files changed, 15 insertions(+) diff --git a/doc/guides/cryptodevs/scheduler.rst b/doc/guides/cryptodevs/scheduler.rst index 70fb62e..9f6c477 100644 --- a/doc/guides/cryptodevs/scheduler.rst +++ b/doc/guides/cryptodevs/scheduler.rst @@ -126,3 +126,11 @@ 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, the primary slave and the + secondary slave. In this mode, the scheduler will enqueue the incoming + crypto operation burst to the primary slave. When one or more crypto + operations fail to be enqueued, then they will be enqueued to the secondary + slave. diff --git a/doc/guides/rel_notes/release_17_05.rst b/doc/guides/rel_notes/release_17_05.rst index 918f483..741f37c 100644 --- a/doc/guides/rel_notes/release_17_05.rst +++ b/doc/guides/rel_notes/release_17_05.rst @@ -49,6 +49,13 @@ New Features sPAPR IOMMU based pci probing enabled for vfio-pci devices. +* **Added fail-over mode to Cryptodev Scheduler PMD.** + + Fail-over mode is a scheduling mode that works with 2 slaves.In this mode, + the scheduler will enqueue the incoming crypto operation burst to the + primary slave. When one or more crypto operations fail to be enqueued, + then they will be enqueued to the secondary slave. + Resolved Issues --------------- -- 2.7.4 ^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [dpdk-dev] [PATCH v5 3/3] doc: update cryptodev scheduler PMD documentation 2017-03-29 16:31 ` [dpdk-dev] [PATCH v5 3/3] doc: update cryptodev scheduler PMD documentation Fan Zhang @ 2017-03-30 7:48 ` Declan Doherty 0 siblings, 0 replies; 22+ messages in thread From: Declan Doherty @ 2017-03-30 7:48 UTC (permalink / raw) To: Fan Zhang, dev; +Cc: pablo.de.lara.guarch, sergio.gonzalez.monroy On 29/03/2017 5:31 PM, Fan Zhang wrote: > This patch updates fail-over scheduling mode description. > > Signed-off-by: Fan Zhang <roy.fan.zhang@intel.com> > --- ... > Acked-by: Declan Doherty <declan.doherty@intel.com> ^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [dpdk-dev] [PATCH v5 0/3] crypto/scheduler: add fail-over mode 2017-03-29 16:31 ` [dpdk-dev] [PATCH v5 " Fan Zhang ` (2 preceding siblings ...) 2017-03-29 16:31 ` [dpdk-dev] [PATCH v5 3/3] doc: update cryptodev scheduler PMD documentation Fan Zhang @ 2017-03-30 12:33 ` De Lara Guarch, Pablo 3 siblings, 0 replies; 22+ messages in thread From: De Lara Guarch, Pablo @ 2017-03-30 12:33 UTC (permalink / raw) To: Zhang, Roy Fan, dev; +Cc: Gonzalez Monroy, Sergio, Doherty, Declan > -----Original Message----- > From: Zhang, Roy Fan > Sent: Wednesday, March 29, 2017 5:32 PM > To: dev@dpdk.org > Cc: De Lara Guarch, Pablo; Gonzalez Monroy, Sergio; Doherty, Declan > Subject: [PATCH v5 0/3] crypto/scheduler: add fail-over mode > > This patch adds fail-over mode for cryptodev scheduler PMD. Fail-over > mode > works with 2 slaves, the primary slave and the secondary slave. In this > mode, the scheduler will enqueues the incoming crypto operation burst to > the > primary slave. When one or more crypto operations fail to be enqueued, > then > they will be enqueued to the secondary slave. ... > 2.7.4 Applied to dpdk-next-crypto as a single patch. Thanks, Pablo ^ permalink raw reply [flat|nested] 22+ messages in thread
* [dpdk-dev] [PATCH v3 0/3] crypto/scheduler: add packet-base scheduling mode @ 2017-03-28 14:09 Fan Zhang 2017-03-29 8:25 ` [dpdk-dev] [PATCH v4 " Fan Zhang 0 siblings, 1 reply; 22+ messages in thread From: Fan Zhang @ 2017-03-28 14:09 UTC (permalink / raw) To: dev; +Cc: pablo.de.lara.guarch, sergio.gonzalez.monroy, declan.doherty Packet-size based distribution mode, which works with 2 slaves, primary slave and secondary slave, and distribute the enqueued crypto ops to them based on their data lengths. A crypto op will be distributed to the primary slave if its data length equals or bigger than the designated threshold, otherwise it will be handled by the secondary slave. Fan Zhang (3): crypto/scheduler: add packet size based mode code crypto/scheduler: enable packet size based scheduling mode doc: update cryptodev scheduler PMD documentation doc/guides/cryptodevs/scheduler.rst | 14 + drivers/crypto/scheduler/Makefile | 1 + drivers/crypto/scheduler/rte_cryptodev_scheduler.c | 7 + drivers/crypto/scheduler/rte_cryptodev_scheduler.h | 3 + .../crypto/scheduler/scheduler_pkt_size_distr.c | 400 +++++++++++++++++++++ 5 files changed, 425 insertions(+) create mode 100644 drivers/crypto/scheduler/scheduler_pkt_size_distr.c -- 2.7.4 ^ permalink raw reply [flat|nested] 22+ messages in thread
* [dpdk-dev] [PATCH v4 0/3] crypto/scheduler: add packet-base scheduling mode 2017-03-28 14:09 [dpdk-dev] [PATCH v3 0/3] crypto/scheduler: add packet-base scheduling mode Fan Zhang @ 2017-03-29 8:25 ` Fan Zhang 2017-03-29 8:25 ` [dpdk-dev] [PATCH v4 3/3] doc: update cryptodev scheduler PMD documentation Fan Zhang 0 siblings, 1 reply; 22+ messages in thread From: Fan Zhang @ 2017-03-29 8:25 UTC (permalink / raw) To: dev; +Cc: pablo.de.lara.guarch, sergio.gonzalez.monroy, declan.doherty Packet-size based distribution mode is a scheduling mode that works with 2 slaves, the primary slave and the secondary slave, and distributes the enqueued crypto operations to them based on their data lengths. A crypto operation will be distributed to the primary slave if its data length is equal to or bigger than the designated threshold, otherwise it will be handled by the secondary slave. v4: - Polished documentation. - Fixed documentation grammer errors. v3: - Uses 2 sched_ops array instead of one. - Copy the failed-to-enqueue crypto ops back to the end of ops array. - Dequeue_ordering will directly use schedule_dequeue function instead of excessive dequeue. v2: - Update with new reorder method. Fan Zhang (3): crypto/scheduler: add packet size based mode code crypto/scheduler: enable packet size based scheduling mode doc: update cryptodev scheduler PMD documentation doc/guides/cryptodevs/scheduler.rst | 15 + drivers/crypto/scheduler/Makefile | 1 + drivers/crypto/scheduler/rte_cryptodev_scheduler.c | 7 + drivers/crypto/scheduler/rte_cryptodev_scheduler.h | 3 + .../crypto/scheduler/scheduler_pkt_size_distr.c | 400 +++++++++++++++++++++ 5 files changed, 426 insertions(+) create mode 100644 drivers/crypto/scheduler/scheduler_pkt_size_distr.c -- 2.7.4 ^ permalink raw reply [flat|nested] 22+ messages in thread
* [dpdk-dev] [PATCH v4 3/3] doc: update cryptodev scheduler PMD documentation 2017-03-29 8:25 ` [dpdk-dev] [PATCH v4 " Fan Zhang @ 2017-03-29 8:25 ` Fan Zhang 2017-03-29 9:57 ` Mcnamara, John 0 siblings, 1 reply; 22+ messages in thread From: Fan Zhang @ 2017-03-29 8:25 UTC (permalink / raw) To: dev; +Cc: pablo.de.lara.guarch, sergio.gonzalez.monroy, declan.doherty This patch updates packet size based scheduling mode description. Signed-off-by: Fan Zhang <roy.fan.zhang@intel.com> --- v4: - Fixed grammer errors in documentation - Polished documentation doc/guides/cryptodevs/scheduler.rst | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/doc/guides/cryptodevs/scheduler.rst b/doc/guides/cryptodevs/scheduler.rst index 70fb62e..af54daf 100644 --- a/doc/guides/cryptodevs/scheduler.rst +++ b/doc/guides/cryptodevs/scheduler.rst @@ -126,3 +126,18 @@ 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_PKT_SIZE_DISTR:** + + Packet-size based distribution mode, which works with 2 slaves, the primary + slave and the secondary slave, and distributes the enqueued crypto + operations to them based on their data lengths. A crypto operation will be + distributed to the primary slave if its data length is equal to or bigger + than the designated threshold, otherwise it will be handled by the secondary + slave. + + A typical usecase in this mode is with the QAT cryptodev as the primary and + a software cryptodev as the secondary slave. This may help applications to + process additional crypto workload than what the QAT cryptodev can handle on + its own, by making use of the available CPU cycles to deal with smaller + crypto workloads. -- 2.7.4 ^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [dpdk-dev] [PATCH v4 3/3] doc: update cryptodev scheduler PMD documentation 2017-03-29 8:25 ` [dpdk-dev] [PATCH v4 3/3] doc: update cryptodev scheduler PMD documentation Fan Zhang @ 2017-03-29 9:57 ` Mcnamara, John 0 siblings, 0 replies; 22+ messages in thread From: Mcnamara, John @ 2017-03-29 9:57 UTC (permalink / raw) To: Zhang, Roy Fan, dev Cc: De Lara Guarch, Pablo, Gonzalez Monroy, Sergio, Doherty, Declan > -----Original Message----- > From: dev [mailto:dev-bounces@dpdk.org] On Behalf Of Fan Zhang > Sent: Wednesday, March 29, 2017 9:26 AM > To: dev@dpdk.org > Cc: De Lara Guarch, Pablo <pablo.de.lara.guarch@intel.com>; Gonzalez > Monroy, Sergio <sergio.gonzalez.monroy@intel.com>; Doherty, Declan > <declan.doherty@intel.com> > Subject: [dpdk-dev] [PATCH v4 3/3] doc: update cryptodev scheduler PMD > documentation > > This patch updates packet size based scheduling mode description. > > Signed-off-by: Fan Zhang <roy.fan.zhang@intel.com> Acked-by: John McNamara <john.mcnamara@intel.com> ^ permalink raw reply [flat|nested] 22+ messages in thread
end of thread, other threads:[~2017-03-30 12:35 UTC | newest] Thread overview: 22+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2017-03-28 14:30 [dpdk-dev] [PATCH v3 0/3] crypto/scheduler: add fail-over mode Fan Zhang 2017-03-28 14:30 ` [dpdk-dev] [PATCH v3 1/3] crypto/scheduler: add fail-over scheduling mode file Fan Zhang 2017-03-28 23:09 ` De Lara Guarch, Pablo 2017-03-28 14:30 ` [dpdk-dev] [PATCH v3 2/3] crypto/scheduler: enable fail-over scheduling mode Fan Zhang 2017-03-28 14:30 ` [dpdk-dev] [PATCH v3 3/3] doc: update cryptodev scheduler PMD documentation Fan Zhang 2017-03-29 8:24 ` [dpdk-dev] [PATCH v4 0/3] crypto/scheduler: add fail-over mode Fan Zhang 2017-03-29 8:24 ` [dpdk-dev] [PATCH v4 1/3] crypto/scheduler: add fail-over scheduling mode file Fan Zhang 2017-03-29 8:24 ` [dpdk-dev] [PATCH v4 2/3] crypto/scheduler: enable fail-over scheduling mode Fan Zhang 2017-03-29 8:24 ` [dpdk-dev] [PATCH v4 3/3] doc: update cryptodev scheduler PMD documentation Fan Zhang 2017-03-29 9:52 ` Mcnamara, John 2017-03-29 11:29 ` [dpdk-dev] [PATCH v4 0/3] crypto/scheduler: add fail-over mode De Lara Guarch, Pablo 2017-03-29 12:46 ` Bruce Richardson 2017-03-29 16:31 ` [dpdk-dev] [PATCH v5 " Fan Zhang 2017-03-29 16:31 ` [dpdk-dev] [PATCH v5 1/3] crypto/scheduler: add fail-over scheduling mode file Fan Zhang 2017-03-30 7:43 ` Declan Doherty 2017-03-29 16:31 ` [dpdk-dev] [PATCH v5 2/3] crypto/scheduler: enable fail-over scheduling mode Fan Zhang 2017-03-30 7:48 ` Declan Doherty 2017-03-29 16:31 ` [dpdk-dev] [PATCH v5 3/3] doc: update cryptodev scheduler PMD documentation Fan Zhang 2017-03-30 7:48 ` Declan Doherty 2017-03-30 12:33 ` [dpdk-dev] [PATCH v5 0/3] crypto/scheduler: add fail-over mode De Lara Guarch, Pablo -- strict thread matches above, loose matches on Subject: below -- 2017-03-28 14:09 [dpdk-dev] [PATCH v3 0/3] crypto/scheduler: add packet-base scheduling mode Fan Zhang 2017-03-29 8:25 ` [dpdk-dev] [PATCH v4 " Fan Zhang 2017-03-29 8:25 ` [dpdk-dev] [PATCH v4 3/3] doc: update cryptodev scheduler PMD documentation Fan Zhang 2017-03-29 9:57 ` Mcnamara, John
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).