dpa_kernel_launch_sample.c

Go to the documentation of this file.

/*
 * Copyright (c) 2022 NVIDIA CORPORATION AND AFFILIATES.  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 the NVIDIA 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 NVIDIA CORPORATION 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 TOR (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 <pthread.h>
#include <stdlib.h>
#include <unistd.h>
 
#include <doca_error.h>
#include <doca_log.h>
 
#include "dpa_common.h"
 
DOCA_LOG_REGISTER(KERNEL_LAUNCH::SAMPLE);
 
/* Kernel function declaration */
extern doca_dpa_func_t hello_world;
 
/*
 * Waits for 5 seconds and then update a given event.
 * This function is made to be used by a pthread, hence it needs to return void*, and it will always return NULL.
 *
 * @event [in]: event to be updated
 * @return: NULL (dummy return)
 */
static void *wait_event_update_thread(void *event)
{
    doca_error_t result;
 
    sleep(5);
    result = doca_sync_event_update_set((struct doca_sync_event *)event, 5);
    if (result != DOCA_SUCCESS)
        DOCA_LOG_ERR("Failed to update DOCA sync event: %s", doca_error_get_descr(result));
 
    /* Dummy return */
    return NULL;
}
 
/*
 * Run kernel_launch sample
 *
 * @resources [in]: DOCA DPA resources that the DPA sample will use
 * @return: DOCA_SUCCESS on success and DOCA_ERROR otherwise
 */
doca_error_t kernel_launch(struct dpa_resources *resources)
{
    struct doca_sync_event *wait_event = NULL;
    struct doca_sync_event *comp_event = NULL;
    pthread_t tid = 0;
    uint64_t wait_thresh = 4;
    uint64_t comp_event_val = 10;
    const unsigned int num_dpa_threads = 1;
    doca_error_t result, tmp_result;
    int res = 0;
 
    result = create_doca_dpa_wait_sync_event(resources->pf_dpa_ctx, resources->pf_doca_device, &wait_event);
    if (result != DOCA_SUCCESS) {
        DOCA_LOG_ERR("Failed to create DOCA sync event for DPA kernel wait: %s", doca_error_get_descr(result));
        return result;
    }
 
    result = create_doca_dpa_completion_sync_event(resources->pf_dpa_ctx,
                               resources->pf_doca_device,
                               &comp_event,
                               NULL);
    if (result != DOCA_SUCCESS) {
        DOCA_LOG_ERR("Failed to create DOCA sync event for DPA kernel completion: %s",
                 doca_error_get_descr(result));
        goto destroy_wait_event;
    }
 
    result = doca_dpa_kernel_launch_update_set(resources->pf_dpa_ctx,
                           wait_event,
                           wait_thresh,
                           comp_event,
                           comp_event_val,
                           num_dpa_threads,
                           &hello_world);
    if (result != DOCA_SUCCESS) {
        DOCA_LOG_ERR("Failed to launch hello_world kernel: %s", doca_error_get_descr(result));
        goto destroy_comp_event;
    }
 
    res = pthread_create(&tid, NULL, wait_event_update_thread, (void *)wait_event);
    if (res != 0) {
        DOCA_LOG_ERR("Failed to create thread");
        result = DOCA_ERROR_OPERATING_SYSTEM;
        goto destroy_comp_event;
    }
 
    res = pthread_detach(tid);
    if (res != 0) {
        DOCA_LOG_ERR("pthread_detach() failed");
        result = DOCA_ERROR_OPERATING_SYSTEM;
        goto destroy_comp_event;
    }
 
    result = doca_sync_event_wait_gt(comp_event, comp_event_val - 1, SYNC_EVENT_MASK_FFS);
    if (result != DOCA_SUCCESS)
        DOCA_LOG_ERR("Failed to wait for host completion event: %s", doca_error_get_descr(result));
 
destroy_comp_event:
    /* Sleep 2 seconds before destroying the events*/
    sleep(2);
    tmp_result = doca_sync_event_destroy(comp_event);
    if (tmp_result != DOCA_SUCCESS) {
        DOCA_LOG_ERR("Failed to destroy host completion event: %s", doca_error_get_descr(tmp_result));
        DOCA_ERROR_PROPAGATE(result, tmp_result);
    }
destroy_wait_event:
    tmp_result = doca_sync_event_destroy(wait_event);
    if (tmp_result != DOCA_SUCCESS) {
        DOCA_LOG_ERR("Failed to destroy host wait event: %s", doca_error_get_descr(tmp_result));
        DOCA_ERROR_PROPAGATE(result, tmp_result);
    }
    return result;
}