Re: [PATCH v7 07/12] util/dsa: Implement DSA task asynchronous submission and wait for completion.

[Fabiano Rosas <farosas@suse.de>]

Yichen Wang <yichen.wang@bytedance.com> writes:

> From: Hao Xiang <hao.xiang@linux.dev>
>
> * Add a DSA task completion callback.
> * DSA completion thread will call the tasks's completion callback
> on every task/batch task completion.
> * DSA submission path to wait for completion.
> * Implement CPU fallback if DSA is not able to complete the task.
>
> Signed-off-by: Hao Xiang <hao.xiang@linux.dev>
> Signed-off-by: Bryan Zhang <bryan.zhang@bytedance.com>
> Signed-off-by: Yichen Wang <yichen.wang@bytedance.com>
> ---
>  include/qemu/dsa.h |  14 +++++
>  util/dsa.c         | 125 +++++++++++++++++++++++++++++++++++++++++++--
>  2 files changed, 135 insertions(+), 4 deletions(-)
>
> diff --git a/include/qemu/dsa.h b/include/qemu/dsa.h
> index cb407b8b49..8284804a32 100644
> --- a/include/qemu/dsa.h
> +++ b/include/qemu/dsa.h
> @@ -123,6 +123,20 @@ buffer_zero_batch_task_init(int batch_size);
>   */
>  void buffer_zero_batch_task_destroy(QemuDsaBatchTask *task);
>  
> +/**
> + * @brief Performs buffer zero comparison on a DSA batch task synchronously.
> + *
> + * @param batch_task A pointer to the batch task.
> + * @param buf An array of memory buffers.
> + * @param count The number of buffers in the array.
> + * @param len The buffer length.
> + *
> + * @return Zero if successful, otherwise non-zero.
> + */
> +int
> +buffer_is_zero_dsa_batch_sync(QemuDsaBatchTask *batch_task,
> +                              const void **buf, size_t count, size_t len);
> +
>  #else
>  
>  typedef struct QemuDsaBatchTask {} QemuDsaBatchTask;
> diff --git a/util/dsa.c b/util/dsa.c
> index 408c163195..50f53ec24b 100644
> --- a/util/dsa.c
> +++ b/util/dsa.c
> @@ -433,6 +433,42 @@ poll_completion(struct dsa_completion_record *completion,
>      return 0;
>  }
>  
> +/**
> + * @brief Helper function to use CPU to complete a single
> + *        zero page checking task.
> + *
> + * @param completion A pointer to a DSA task completion record.
> + * @param descriptor A pointer to a DSA task descriptor.
> + * @param result A pointer to the result of a zero page checking.
> + */
> +static void
> +task_cpu_fallback_int(struct dsa_completion_record *completion,
> +                      struct dsa_hw_desc *descriptor, bool *result)
> +{
> +    const uint8_t *buf;
> +    size_t len;
> +
> +    if (completion->status == DSA_COMP_SUCCESS) {
> +        return;
> +    }
> +
> +    /*
> +     * DSA was able to partially complete the operation. Check the
> +     * result. If we already know this is not a zero page, we can
> +     * return now.
> +     */
> +    if (completion->bytes_completed != 0 && completion->result != 0) {
> +        *result = false;
> +        return;
> +    }
> +
> +    /* Let's fallback to use CPU to complete it. */
> +    buf = (const uint8_t *)descriptor->src_addr;
> +    len = descriptor->xfer_size;
> +    *result = buffer_is_zero(buf + completion->bytes_completed,
> +                             len - completion->bytes_completed);
> +}
> +
>  /**
>   * @brief Complete a single DSA task in the batch task.
>   *
> @@ -561,7 +597,7 @@ dsa_completion_loop(void *opaque)
>          (QemuDsaCompletionThread *)opaque;
>      QemuDsaBatchTask *batch_task;
>      QemuDsaDeviceGroup *group = thread_context->group;
> -    int ret;
> +    int ret = 0;
>  
>      rcu_register_thread();
>  
> @@ -829,7 +865,6 @@ buffer_zero_batch_task_set(QemuDsaBatchTask *batch_task,
>   *
>   * @return int Zero if successful, otherwise an appropriate error code.
>   */
> -__attribute__((unused))
>  static int
>  buffer_zero_dsa_async(QemuDsaBatchTask *task,
>                        const void *buf, size_t len)
> @@ -848,7 +883,6 @@ buffer_zero_dsa_async(QemuDsaBatchTask *task,
>   * @param count The number of buffers.
>   * @param len The buffer length.
>   */
> -__attribute__((unused))
>  static int
>  buffer_zero_dsa_batch_async(QemuDsaBatchTask *batch_task,
>                              const void **buf, size_t count, size_t len)
> @@ -879,13 +913,61 @@ buffer_zero_dsa_completion(void *context)
>   *
>   * @param batch_task A pointer to the buffer zero comparison batch task.
>   */
> -__attribute__((unused))
>  static void
>  buffer_zero_dsa_wait(QemuDsaBatchTask *batch_task)
>  {
>      qemu_sem_wait(&batch_task->sem_task_complete);
>  }
>  
> +/**
> + * @brief Use CPU to complete the zero page checking task if DSA
> + *        is not able to complete it.
> + *
> + * @param batch_task A pointer to the batch task.
> + */
> +static void
> +buffer_zero_cpu_fallback(QemuDsaBatchTask *batch_task)
> +{
> +    if (batch_task->task_type == QEMU_DSA_TASK) {
> +        if (batch_task->completions[0].status == DSA_COMP_SUCCESS) {
> +            return;
> +        }
> +        task_cpu_fallback_int(&batch_task->completions[0],
> +                              &batch_task->descriptors[0],
> +                              &batch_task->results[0]);
> +    } else if (batch_task->task_type == QEMU_DSA_BATCH_TASK) {
> +        struct dsa_completion_record *batch_completion =
> +            &batch_task->batch_completion;
> +        struct dsa_completion_record *completion;
> +        uint8_t status;
> +        bool *results = batch_task->results;
> +        uint32_t count = batch_task->batch_descriptor.desc_count;
> +
> +        /* DSA is able to complete the entire batch task. */
> +        if (batch_completion->status == DSA_COMP_SUCCESS) {
> +            assert(count == batch_completion->bytes_completed);
> +            return;
> +        }
> +
> +        /*
> +         * DSA encounters some error and is not able to complete
> +         * the entire batch task. Use CPU fallback.
> +         */
> +        for (int i = 0; i < count; i++) {
> +
> +            completion = &batch_task->completions[i];
> +            status = completion->status;
> +
> +            assert(status == DSA_COMP_SUCCESS ||
> +                status == DSA_COMP_PAGE_FAULT_NOBOF);
> +
> +            task_cpu_fallback_int(completion,
> +                                  &batch_task->descriptors[i],
> +                                  &results[i]);
> +        }
> +    }
> +}
> +
>  /**
>   * @brief Initializes a buffer zero comparison DSA task.
>   *
> @@ -962,3 +1044,38 @@ buffer_zero_batch_task_destroy(QemuDsaBatchTask *task)
>      qemu_sem_destroy(&task->sem_task_complete);
>      qemu_vfree(task);
>  }
> +
> +/**
> + * @brief Performs buffer zero comparison on a DSA batch task synchronously.
> + *
> + * @param batch_task A pointer to the batch task.
> + * @param buf An array of memory buffers.
> + * @param count The number of buffers in the array.
> + * @param len The buffer length.
> + *
> + * @return Zero if successful, otherwise non-zero.
> + */
> +int
> +buffer_is_zero_dsa_batch_sync(QemuDsaBatchTask *batch_task,
> +                              const void **buf, size_t count, size_t len)
> +{
> +    if (count <= 0 || count > batch_task->batch_size) {
> +        return -1;
> +    }
> +
> +    assert(batch_task != NULL);

batch_task is already dereferenced above.

> +    assert(len != 0);
> +    assert(buf != NULL);
> +
> +    if (count == 1) {
> +        /* DSA doesn't take batch operation with only 1 task. */
> +        buffer_zero_dsa_async(batch_task, buf[0], len);
> +    } else {
> +        buffer_zero_dsa_batch_async(batch_task, buf, count, len);
> +    }
> +
> +    buffer_zero_dsa_wait(batch_task);
> +    buffer_zero_cpu_fallback(batch_task);
> +
> +    return 0;
> +}