ceph/src/spdk/dpdk/lib/librte_jobstats/rte_jobstats.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2015 Intel Corporation
   3  */
   4
   5 #include <string.h>
   6 #include <stdlib.h>
   7 #include <errno.h>
   8
   9 #include <rte_string_fns.h>
  10 #include <rte_errno.h>
  11 #include <rte_common.h>
  12 #include <rte_eal.h>
  13 #include <rte_log.h>
  14 #include <rte_cycles.h>
  15 #include <rte_branch_prediction.h>
  16
  17 #include "rte_jobstats.h"
  18
  19 #define ADD_TIME_MIN_MAX(obj, type, value) do {      \
  20         typeof(value) tmp = (value);                     \
  21         (obj)->type ## _time += tmp;                     \
  22         if (tmp < (obj)->min_ ## type ## _time)          \
  23                 (obj)->min_ ## type ## _time = tmp;          \
  24         if (tmp > (obj)->max_ ## type ## _time)          \
  25                 (obj)->max_ ## type ## _time = tmp;          \
  26 } while (0)
  27
  28 #define RESET_TIME_MIN_MAX(obj, type) do {           \
  29         (obj)->type ## _time = 0;                        \
  30         (obj)->min_ ## type ## _time = UINT64_MAX;       \
  31         (obj)->max_ ## type ## _time = 0;                \
  32 } while (0)
  33
  34 static inline uint64_t
  35 get_time(void)
  36 {
  37         rte_rmb();
  38         return rte_get_timer_cycles();
  39 }
  40
  41 /* Those are steps used to adjust job period.
  42  * Experiments show that for forwarding apps the up step must be less than down
  43  * step to achieve optimal performance.
  44  */
  45 #define JOB_UPDATE_STEP_UP    1
  46 #define JOB_UPDATE_STEP_DOWN  4
  47
  48 /*
  49  * Default update function that implements simple period adjustment.
  50  */
  51 static void
  52 default_update_function(struct rte_jobstats *job, int64_t result)
  53 {
  54         int64_t err = job->target - result;
  55
  56         /* Job is happy. Nothing to do */
  57         if (err == 0)
  58                 return;
  59
  60         if (err > 0) {
  61                 if (job->period + JOB_UPDATE_STEP_UP < job->max_period)
  62                         job->period += JOB_UPDATE_STEP_UP;
  63         } else {
  64                 if (job->min_period + JOB_UPDATE_STEP_DOWN < job->period)
  65                         job->period -= JOB_UPDATE_STEP_DOWN;
  66         }
  67 }
  68
  69 int
  70 rte_jobstats_context_init(struct rte_jobstats_context *ctx)
  71 {
  72         if (ctx == NULL)
  73                 return -EINVAL;
  74
  75         /* Init only needed parameters. Zero out everything else. */
  76         memset(ctx, 0, sizeof(struct rte_jobstats_context));
  77
  78         rte_jobstats_context_reset(ctx);
  79
  80         return 0;
  81 }
  82
  83 void
  84 rte_jobstats_context_start(struct rte_jobstats_context *ctx)
  85 {
  86         uint64_t now;
  87
  88         ctx->loop_executed_jobs = 0;
  89
  90         now = get_time();
  91         ADD_TIME_MIN_MAX(ctx, management, now - ctx->state_time);
  92         ctx->state_time = now;
  93 }
  94
  95 void
  96 rte_jobstats_context_finish(struct rte_jobstats_context *ctx)
  97 {
  98         uint64_t now;
  99
 100         if (likely(ctx->loop_executed_jobs))
 101                 ctx->loop_cnt++;
 102
 103         now = get_time();
 104         ADD_TIME_MIN_MAX(ctx, management, now - ctx->state_time);
 105         ctx->state_time = now;
 106 }
 107
 108 void
 109 rte_jobstats_context_reset(struct rte_jobstats_context *ctx)
 110 {
 111         RESET_TIME_MIN_MAX(ctx, exec);
 112         RESET_TIME_MIN_MAX(ctx, management);
 113         ctx->start_time = get_time();
 114         ctx->state_time = ctx->start_time;
 115         ctx->job_exec_cnt = 0;
 116         ctx->loop_cnt = 0;
 117 }
 118
 119 void
 120 rte_jobstats_set_target(struct rte_jobstats *job, int64_t target)
 121 {
 122         job->target = target;
 123 }
 124
 125 int
 126 rte_jobstats_start(struct rte_jobstats_context *ctx, struct rte_jobstats *job)
 127 {
 128         uint64_t now;
 129
 130         /* Some sanity check. */
 131         if (unlikely(ctx == NULL || job == NULL || job->context != NULL))
 132                 return -EINVAL;
 133
 134         /* Link job with context object. */
 135         job->context = ctx;
 136
 137         now = get_time();
 138         ADD_TIME_MIN_MAX(ctx, management, now - ctx->state_time);
 139         ctx->state_time = now;
 140
 141         return 0;
 142 }
 143
 144 int
 145 rte_jobstats_abort(struct rte_jobstats *job)
 146 {
 147         struct rte_jobstats_context *ctx;
 148         uint64_t now, exec_time;
 149
 150         /* Some sanity check. */
 151         if (unlikely(job == NULL || job->context == NULL))
 152                 return -EINVAL;
 153
 154         ctx = job->context;
 155         now = get_time();
 156         exec_time = now - ctx->state_time;
 157         ADD_TIME_MIN_MAX(ctx, management, exec_time);
 158         ctx->state_time = now;
 159         job->context = NULL;
 160
 161         return 0;
 162 }
 163
 164 int
 165 rte_jobstats_finish(struct rte_jobstats *job, int64_t job_value)
 166 {
 167         struct rte_jobstats_context *ctx;
 168         uint64_t now, exec_time;
 169         int need_update;
 170
 171         /* Some sanity check. */
 172         if (unlikely(job == NULL || job->context == NULL))
 173                 return -EINVAL;
 174
 175         need_update = job->target != job_value;
 176         /* Adjust period only if job is unhappy of its current period. */
 177         if (need_update)
 178                 (*job->update_period_cb)(job, job_value);
 179
 180         ctx = job->context;
 181
 182         /* Update execution time is considered as runtime so get time after it is
 183          * executed. */
 184         now = get_time();
 185         exec_time = now - ctx->state_time;
 186         ADD_TIME_MIN_MAX(job, exec, exec_time);
 187         ADD_TIME_MIN_MAX(ctx, exec, exec_time);
 188
 189         ctx->state_time = now;
 190
 191         ctx->loop_executed_jobs++;
 192         ctx->job_exec_cnt++;
 193
 194         job->exec_cnt++;
 195         job->context = NULL;
 196
 197         return need_update;
 198 }
 199
 200 void
 201 rte_jobstats_set_period(struct rte_jobstats *job, uint64_t period,
 202                 uint8_t saturate)
 203 {
 204         if (saturate != 0) {
 205                 if (period < job->min_period)
 206                         period = job->min_period;
 207                 else if (period > job->max_period)
 208                         period = job->max_period;
 209         }
 210
 211         job->period = period;
 212 }
 213
 214 void
 215 rte_jobstats_set_min(struct rte_jobstats *job, uint64_t period)
 216 {
 217         job->min_period = period;
 218         if (job->period < period)
 219                 job->period = period;
 220 }
 221
 222 void
 223 rte_jobstats_set_max(struct rte_jobstats *job, uint64_t period)
 224 {
 225         job->max_period = period;
 226         if (job->period > period)
 227                 job->period = period;
 228 }
 229
 230 int
 231 rte_jobstats_init(struct rte_jobstats *job, const char *name,
 232                 uint64_t min_period, uint64_t max_period, uint64_t initial_period,
 233                 int64_t target)
 234 {
 235         if (job == NULL)
 236                 return -EINVAL;
 237
 238         job->period = initial_period;
 239         job->min_period = min_period;
 240         job->max_period = max_period;
 241         job->target = target;
 242         job->update_period_cb = &default_update_function;
 243         rte_jobstats_reset(job);
 244         strlcpy(job->name, name == NULL ? "" : name, RTE_DIM(job->name));
 245         job->context = NULL;
 246
 247         return 0;
 248 }
 249
 250 void
 251 rte_jobstats_set_update_period_function(struct rte_jobstats *job,
 252                 rte_job_update_period_cb_t update_period_cb)
 253 {
 254         if (update_period_cb == NULL)
 255                 update_period_cb = default_update_function;
 256
 257         job->update_period_cb = update_period_cb;
 258 }
 259
 260 void
 261 rte_jobstats_reset(struct rte_jobstats *job)
 262 {
 263         RESET_TIME_MIN_MAX(job, exec);
 264         job->exec_cnt = 0;
 265 }