rp_switch_telemetry_dev_main.c

Go to the documentation of this file.

/*
 * Copyright (c) 2023 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 <doca_pcc_dev.h>
#include <doca_pcc_dev_event.h>
#include <doca_pcc_dev_algo_access.h>
#include "pcc_common_dev.h"
#include "telem_template.h"
 
#define DOCA_PCC_DEV_EVNT_ROCE_ACK_MASK (1 << DOCA_PCC_DEV_EVNT_ROCE_ACK)
 
/*
 * Main entry point to user CC algorithm (Reference code)
 * This function starts the algorithm code of a single event
 * It receives the flow context data, the event info and outputs the new rate parameters
 * The function can support multiple algorithms and can call the per algorithm handler based on
 * the algo type. If a single algorithm is required this code can be simplified
 * The function can not be renamed as it is called by the handler infrastructure
 *
 * @algo_ctxt [in]: A pointer to a flow context data retrieved by libpcc.
 * @event [in]: A pointer to an event data structure to be passed to extractor functions
 * @attr [in]: A pointer to additional parameters (algo type).
 * @results [out]: A pointer to result struct to update rate in HW.
 */
void doca_pcc_dev_user_algo(doca_pcc_dev_algo_ctxt_t *algo_ctxt,
                doca_pcc_dev_event_t *event,
                const doca_pcc_dev_attr_t *attr,
                doca_pcc_dev_results_t *results)
{
    uint32_t port_num = doca_pcc_dev_get_ev_attr(event).port_num;
    uint32_t *param = doca_pcc_dev_get_algo_params(port_num, attr->algo_slot);
    uint32_t *counter = doca_pcc_dev_get_counters(port_num, attr->algo_slot);
 
    switch (attr->algo_slot) {
    case 0: {
        telem_template_algo(event, param, counter, algo_ctxt, results);
        break;
    }
    default: {
        doca_pcc_dev_default_internal_algo(algo_ctxt, event, attr, results);
        break;
    }
    };
}
 
/*
 * Main entry point to user algorithm initialization (reference code)
 * This function starts the user algorithm initialization code
 * The function will be called once per process load and should init all supported
 * algorithms and all ports
 *
 * @disable_event_bitmask [out]: user code can tell the infrastructure which event
 * types to ignore (mask out). Events of this type will be dropped and not passed to
 * any algo
 */
void doca_pcc_dev_user_init(uint32_t *disable_event_bitmask)
{
    uint32_t algo_idx = 0, algo_slot = 0, algo_en = 1;
 
    /* Initialize algorithm with algo_idx=0 */
    telem_template_init(algo_idx);
 
    for (int port_num = 0; port_num < DOCA_PCC_DEV_MAX_NUM_PORTS; ++port_num) {
        /* Slot 0 will use algo_idx 0, default enabled */
        doca_pcc_dev_init_algo_slot(port_num, algo_slot, algo_idx, algo_en);
        doca_pcc_dev_trace_5(0, port_num, algo_idx, algo_slot, algo_en, DOCA_PCC_DEV_EVNT_ROCE_ACK_MASK);
    }
 
    /* disable events of below type */
    *disable_event_bitmask = DOCA_PCC_DEV_EVNT_ROCE_ACK_MASK;
    if (DOCA_PCC_DEV_ACK_NACK_TX_EVENT_DISABLED_SUPPORTED == 1) {
        *disable_event_bitmask |= (1 << DOCA_PCC_DEV_EVNT_ROCE_TX_FOR_ACK_NACK);
    }
 
    doca_pcc_dev_printf("%s, disable_event_bitmask=0x%x\n", __func__, *disable_event_bitmask);
    doca_pcc_dev_trace_flush();
}
 
/*
 * Called when the parameter change was set externally.
 * The implementation should:
 *     Check the given new_parameters values. If those are correct from the algorithm perspective,
 *     assign them to the given parameter array.
 
 * @port_num [in]: index of the port
 * @algo_slot [in]: Algo slot identifier as referred to in the PPCC command field "algo_slot"
 * if possible it should be equal to the algo_idx
 * @param_id_base [in]: id of the first parameter that was changed.
 * @param_num [in]: number of all parameters that were changed
 * @new_param_values [in]: pointer to an array which holds param_num number of new values for parameters
 * @params [in]: pointer to an array which holds beginning of the current parameters to be changed
 * @return -
 * DOCA_PCC_DEV_STATUS_OK: Parameters were set
 * DOCA_PCC_DEV_STATUS_FAIL: the values (one or more) are not legal. No parameters were changed
 */
doca_pcc_dev_error_t doca_pcc_dev_user_set_algo_params(uint32_t port_num,
                               uint32_t algo_slot,
                               uint32_t param_id_base,
                               uint32_t param_num,
                               const uint32_t *new_param_values,
                               uint32_t *params)
{
    /* Notify the user that a change happened to take action.
     * I.E.: Pre calculate values to be used in the algo that are based on the parameter value.
     * Support more complex checks. E.G.: Param is a bit mask - min and max do not help
     * Param dependency checking.
     */
    doca_pcc_dev_error_t ret = DOCA_PCC_DEV_STATUS_OK;
 
    switch (algo_slot) {
    case 0: {
        uint32_t algo_idx = doca_pcc_dev_get_algo_index(port_num, algo_slot);
 
        if (algo_idx == 0)
            ret = telem_template_set_algo_params(param_id_base, param_num, new_param_values, params);
        else
            ret = DOCA_PCC_DEV_STATUS_FAIL;
 
        break;
    }
    default:
        break;
    }
    return ret;
}