VNFs/DPPD-PROX/stats_prio.c

   1 /*
   2 // Copyright (c) 2010-2017 Intel Corporation
   3 //
   4 // Licensed under the Apache License, Version 2.0 (the "License");
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://www.apache.org/licenses/LICENSE-2.0
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an "AS IS" BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 */
  16
  17 #include <stddef.h>
  18
  19 #include "handle_aggregator.h"
  20 #include "stats_prio_task.h"
  21 #include "prox_cfg.h"
  22 #include "prox_globals.h"
  23 #include "lconf.h"
  24
  25 struct lcore_task_stats {
  26         struct task_stats task_stats[MAX_TASKS_PER_CORE];
  27 };
  28
  29 struct lcore_prio_task_stats {
  30         struct prio_task_stats prio_task_stats[MAX_TASKS_PER_CORE];
  31 };
  32
  33 extern int last_stat;
  34 static struct prio_task_stats   prio_task_stats_set[RTE_MAX_LCORE * MAX_TASKS_PER_CORE];
  35 static uint8_t nb_prio_tasks_tot;
  36
  37 int stats_get_n_prio_tasks_tot(void)
  38 {
  39         return nb_prio_tasks_tot;
  40 }
  41
  42 struct prio_task_stats_sample *stats_get_prio_task_stats_sample(uint32_t prio_task_id, int l)
  43 {
  44         return &prio_task_stats_set[prio_task_id].sample[l == last_stat];
  45 }
  46
  47 struct prio_task_stats_sample *stats_get_prio_task_stats_sample_by_core_task(uint32_t lcore_id, uint32_t prio_task_id, int l)
  48 {
  49         for (uint8_t task_id = 0; task_id < nb_prio_tasks_tot; ++task_id) {
  50                 if ((prio_task_stats_set[task_id].lcore_id == lcore_id) && (prio_task_stats_set[task_id].task_id == task_id))
  51                         return &prio_task_stats_set[prio_task_id].sample[l == last_stat];
  52         }
  53         return NULL;
  54 }
  55
  56 void stats_prio_task_reset(void)
  57 {
  58         struct prio_task_stats *cur_task_stats;
  59
  60         for (uint8_t task_id = 0; task_id < nb_prio_tasks_tot; ++task_id) {
  61                 cur_task_stats = &prio_task_stats_set[task_id];
  62                 for (int i = 0; i < 8; i++) {
  63                         cur_task_stats->tot_drop_tx_fail_prio[i] = 0;
  64                         cur_task_stats->tot_rx_prio[i] = 0;
  65                 }
  66         }
  67 }
  68
  69 uint64_t stats_core_task_tot_drop_tx_fail_prio(uint8_t prio_task_id, uint8_t prio)
  70 {
  71         return prio_task_stats_set[prio_task_id].tot_drop_tx_fail_prio[prio];
  72 }
  73
  74 uint64_t stats_core_task_tot_rx_prio(uint8_t prio_task_id, uint8_t prio)
  75 {
  76         return prio_task_stats_set[prio_task_id].tot_rx_prio[prio];
  77 }
  78
  79 void stats_prio_task_post_proc(void)
  80 {
  81         for (uint8_t task_id = 0; task_id < nb_prio_tasks_tot; ++task_id) {
  82                 struct prio_task_stats *cur_task_stats = &prio_task_stats_set[task_id];
  83                 const struct prio_task_stats_sample *last = &cur_task_stats->sample[last_stat];
  84                 const struct prio_task_stats_sample *prev = &cur_task_stats->sample[!last_stat];
  85
  86                 for (int i=0; i<8; i++) {
  87                         cur_task_stats->tot_rx_prio[i] += last->rx_prio[i] - prev->rx_prio[i];
  88                         cur_task_stats->tot_drop_tx_fail_prio[i] += last->drop_tx_fail_prio[i] - prev->drop_tx_fail_prio[i];
  89                 }
  90         }
  91 }
  92
  93 void stats_prio_task_update(void)
  94 {
  95         uint64_t before, after;
  96
  97         for (uint8_t task_id = 0; task_id < nb_prio_tasks_tot; ++task_id) {
  98                 struct prio_task_stats *cur_task_stats = &prio_task_stats_set[task_id];
  99                 struct prio_task_rt_stats *stats = cur_task_stats->stats;
 100                 struct prio_task_stats_sample *last = &cur_task_stats->sample[last_stat];
 101
 102                 before = rte_rdtsc();
 103                 for (int i=0; i<8; i++) {
 104                         last->drop_tx_fail_prio[i] = stats->drop_tx_fail_prio[i];
 105                         last->rx_prio[i] = stats->rx_prio[i];
 106                 }
 107                 after = rte_rdtsc();
 108                 last->tsc = (before >> 1) + (after >> 1);
 109         }
 110 }
 111
 112 void stats_prio_task_init(void)
 113 {
 114         struct lcore_cfg *lconf;
 115         uint32_t lcore_id;
 116
 117         /* add cores that are receiving from and sending to physical ports first */
 118         lcore_id = -1;
 119         while(prox_core_next(&lcore_id, 0) == 0) {
 120                 lconf = &lcore_cfg[lcore_id];
 121                 for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
 122                         struct task_args *targ = &lconf->targs[task_id];
 123                         if (strcmp(targ->task_init->mode_str, "aggreg") == 0) {
 124                                 struct prio_task_rt_stats *stats = &((struct task_aggregator *)(lconf->tasks_all[task_id]))->stats;
 125                                 prio_task_stats_set[nb_prio_tasks_tot].stats = stats;
 126                                 prio_task_stats_set[nb_prio_tasks_tot].lcore_id = lcore_id;
 127                                 prio_task_stats_set[nb_prio_tasks_tot++].task_id = task_id;
 128                         }
 129                 }
 130         }
 131 }