qres-test.c

Go to the documentation of this file.

#define QOS_DEBUG_LEVEL QOS_LEVEL_NODEBUG
#include <linux/aquosa/qos_debug.h>
#include <aquosa/qres_lib.h>
#include <aquosa/qmgr_util.h>

#include <sys/time.h>
#include <time.h>
#include <stdio.h>
#include <sched.h>
#include <string.h>

#define NUM_JOBS 1000

#define C_MIN 10000ul
#define C_MAX 20000ul
#define APP_T 40000ul

#define Q_MIN 1000ul
#define Q_MAX 2000ul
#define SRV_P 4000ul

// Computation times picked at random
unsigned long c[NUM_JOBS];

// Real computation times measured counting sheeps
unsigned long cr[NUM_JOBS];

// Computation sheeps measured
unsigned long cs[NUM_JOBS];

// Scheduling errors according to model
signed long em[NUM_JOBS];

// Scheduling errors actually measured
signed long e[NUM_JOBS];

// Start-time actually measured
unsigned long s[NUM_JOBS];

// Finishing-time actually measured
unsigned long f[NUM_JOBS];

// Budgets assigned to single jobs
unsigned long q[NUM_JOBS];

signed long timespec_sub_us(struct timespec *ts2, struct timespec *ts1) {
  return (ts2->tv_sec - ts1->tv_sec) * 1000000l + ((signed long) (ts2->tv_nsec - ts1->tv_nsec)) / 1000l;
}

unsigned long count_and_wait(unsigned long duration_usec) {
  unsigned long counted_sheeps = 0;
  unsigned long elapsed_usecs;
  struct timespec ts1, ts2;
  qos_log_debug("Counting ? sheeps for %lu usecs ...", duration_usec);
  clock_gettime(CLOCK_MONOTONIC, &ts1);
  do {
    clock_gettime(CLOCK_MONOTONIC, &ts2);
    elapsed_usecs = timespec_sub_us(&ts2, &ts1);
    counted_sheeps++;
  } while (elapsed_usecs < duration_usec);
  qos_log_debug("Counted %lu sheeps in %lu usecs", counted_sheeps, elapsed_usecs);
  return counted_sheeps;
}

unsigned long count(unsigned long sheeps) {
  unsigned long counted_sheeps = 0;
  unsigned long elapsed_usecs;
  struct timespec ts1, ts2;

  qos_log_debug("Counting %lu sheeps for ? usecs ...", sheeps);
  clock_gettime(CLOCK_MONOTONIC, &ts1);
  do {
    clock_gettime(CLOCK_MONOTONIC, &ts2);
    elapsed_usecs = timespec_sub_us(&ts2, &ts1);
    counted_sheeps++;
  } while (counted_sheeps < sheeps);
  qos_log_debug("Counted %lu sheeps in %lu usecs", counted_sheeps, elapsed_usecs);
  return elapsed_usecs;
}

int job = 0;
struct timespec ts1;

qres_sid_t sid;
qres_params_t params = {
  .Q_min = 0,
  .Q = 0,
  .P = SRV_P,
  .flags = 0,
  .timeout = 0
};

struct timespec foo_ts;

int job_fn_setup(void *app_data) {
  struct timespec ts2;
  if (job == 0) {
    clock_gettime(CLOCK_MONOTONIC, &ts1);
    ts2 = ts1;
  }

  /* Reuse finishing time of previous job */
  clock_gettime(CLOCK_MONOTONIC, &foo_ts);
  s[job] = timespec_sub_us(&ts2, &ts1);
  qos_log_debug("Starting job %d at %ld", job, s[job]);

  count(cs[job]);

  /* Measure finishing time */
  clock_gettime(CLOCK_MONOTONIC, &ts2);
  f[job] = timespec_sub_us(&ts2, &ts1);
  qos_log_debug("Ending job %d at %lu", job, f[job]);

  /* Store computation time */
  cr[job] = f[job] - s[job];

  /* Compute measured scheduling error */
  e[job] = f[job] - (job + 1) * APP_T;

  job = (job + 1) % NUM_JOBS;
  params.Q = q[job];
  qos_chk_ok_do(qres_set_params(sid, &params), exit(-1));

  return job == 0;
}

int job_fn(void *app_data) {
  struct timespec ts2;
  if (job == 0) {
    clock_gettime(CLOCK_MONOTONIC, &ts1);
    ts2 = ts1;
  }

  clock_gettime(CLOCK_MONOTONIC, &ts2);
  s[job] = timespec_sub_us(&ts2, &ts1);
  qos_log_debug("Starting job %d at %ld", job, s[job]);

  count(cs[job]);

  /* Measure finishing time */
  clock_gettime(CLOCK_MONOTONIC, &ts2);
  f[job] = timespec_sub_us(&ts2, &ts1);
  qos_log_debug("Ending job %d at %lu", job, f[job]);

  /* Compute measured scheduling error */
  e[job] = f[job] - (job + 1) * APP_T;

  job = (job + 1) % NUM_JOBS;
  params.Q = q[job];
  qos_chk_ok_do(qres_set_params(sid, &params), exit(-1));

  return job == 0;
}

qos_rv start_periodic(qmgr_period_spec_t *p_ps, struct timespec *p_ts) {
  qos_rv rv = QOS_E_GENERIC;

  p_ps->job_id = 1;

  /* Compute first job deadline */

  qos_log_debug("getting current time...");
  qos_chk_go(clock_gettime(CLOCK_MONOTONIC, &p_ps->deadline_ts) == 0,
    err, "clock_gettime() failed: %s", strerror(errno));

  qos_log_debug("read time: %09lu.%09lu", p_ps->deadline_ts.tv_sec, p_ps->deadline_ts.tv_nsec);

  p_ps->period_ts = *p_ts;
  timespec_add(&p_ps->deadline_ts, &p_ps->deadline_ts, &p_ps->period_ts);
  qos_log_debug("end of %dth period: %09lu.%09lu", p_ps->job_id,
    p_ps->deadline_ts.tv_sec, p_ps->deadline_ts.tv_nsec);

  return QOS_OK;

err:

  return rv;
}

qos_rv wait_periodic(qmgr_period_spec_t *p_ps) {
  struct timespec now;
  struct timespec delta;

  p_ps->job_id++;

  if (clock_gettime(CLOCK_MONOTONIC, &now) < 0) {
    qos_log_err("clock_gettime() failed: %s", strerror(errno));
    return QOS_E_GENERIC;
  }

  timespec_sub(&delta, &p_ps->deadline_ts, &now);
  qos_log_debug("delta time: %09ld.%09lu", delta.tv_sec, delta.tv_nsec);
  if (delta.tv_sec > 0 || (delta.tv_sec == 0 && delta.tv_nsec > 0)) {
    qos_log_debug("Sleeping...");
    if (nanosleep(&delta, NULL) < 0) {
      qos_log_err("nanosleep() failed: %s", strerror(errno));
      return QOS_E_GENERIC;
    }
  } else
    qos_log_warn("We are late: not waiting...");

  timespec_add(&p_ps->deadline_ts, &p_ps->deadline_ts, &p_ps->period_ts);
  qos_log_debug("end of %dth period: %09lu.%09lu", p_ps->job_id,
    p_ps->deadline_ts.tv_sec, p_ps->deadline_ts.tv_nsec);

  return QOS_OK;
}

int main(int argc, char *argv[]) {
  unsigned long sheeps_per_sec;
  unsigned long elapsed;
  int i;
  struct sched_param sp = {
    .sched_priority = 20
  };

  long period_nsec = APP_T * 1000;
  struct timespec ts, ts_setup;

  clock_getres(CLOCK_MONOTONIC, &ts);
  printf("# Requested period: %lu nsec\n", period_nsec);
  printf("# Timer resolution: %lu sec and %lu nsec\n", ts.tv_sec, ts.tv_nsec);
  unsigned long timer_res = ts.tv_sec * 1000000000ul + ts.tv_nsec;
  unsigned long new_period_nsec = period_nsec / timer_res * timer_res;
  while (new_period_nsec < period_nsec)
    new_period_nsec += timer_res;
  period_nsec = new_period_nsec;
  printf("# Real period: %lu nsec\n", period_nsec);

  srand(time(NULL));

  sheeps_per_sec = count_and_wait(1000000ul);
  elapsed = count(sheeps_per_sec);
  printf("# sheeps_per_sec = %lu\n", sheeps_per_sec);
  printf("# elapsed = %lu\n", elapsed);

  qos_chk_do(sched_setscheduler(0, SCHED_RR, &sp) >= 0, perror("Could not gain RT priority"), "");

  for (i = 0; i < NUM_JOBS; ++i) {
    c[i] = C_MIN + (unsigned long) ((C_MAX - C_MIN) * (rand() / (RAND_MAX + 1.0)));
    cs[i] = count_and_wait(c[i]);
    qos_log_debug("Random c_k=%lu requires %lu cycles", c[i], cs[i]);
  }

  /* Just do it again */
  for (i = 0; i < NUM_JOBS; ++i) {
    c[i] = C_MIN + (unsigned long) ((C_MAX - C_MIN) * (rand() / (RAND_MAX + 1.0)));
    cs[i] = count_and_wait(c[i]);
    qos_log_debug("Random c_k=%lu requires %lu cycles", c[i], cs[i]);
  }

  sp.sched_priority = 0;
  qos_chk_do(sched_setscheduler(0, SCHED_OTHER, &sp) >= 0, perror("Could not drop RT priority"), "");

  /* Compute random budgets */
  for (i = 0; i < NUM_JOBS; ++i) {
    q[i] = Q_MIN + (qres_time_t) ((Q_MAX - Q_MIN) * (rand() / (RAND_MAX + 1.0)));
    qos_log_debug("Computed random budget: %lu", q[i]);
  }

  /* Set-up reservation */
  qos_chk_ok_do(qres_init(), exit(-1));
  params.Q = q[0];
  qos_chk_ok_do(qres_create_server(&params, &sid), exit(-1));

  int eot;
  qmgr_period_spec_t ps;

  /* Set period to tiny value, so it never blocks with same code base */
  ts_setup = (struct timespec) {
    .tv_sec = 0,
    .tv_nsec = 1000
  };

  /* First, count cycles (server unbound, so set_params() has no effect) */
  qos_chk_ok_exit(start_periodic(&ps, &ts_setup));
  eot = job_fn_setup(NULL);
  while (! eot) {
    qos_chk_ok_exit(wait_periodic(&ps));
    eot = job_fn_setup(NULL);
  }

  qos_chk_ok_do(qres_attach_thread(sid, 0, 0), exit(-1));

  ts = (struct timespec) {
    .tv_sec = period_nsec / 1000000000L,
    .tv_nsec = period_nsec % 1000000000L
  };

  /* Then, compute for the counted cycles */
  qos_chk_ok_exit(start_periodic(&ps, &ts));

  eot = job_fn(NULL);
  while (! eot) {
    qos_chk_ok_exit(wait_periodic(&ps));
    eot = job_fn(NULL);
  }

  qos_chk_ok_do(qres_cleanup(), exit(-1));

  /* Compute theoretical scheduling errors */
  signed long e_k = 0;
  for (i = 0; i < NUM_JOBS; ++i) {
    em[i] = e_k = cr[i] * SRV_P / q[i] - APP_T + (e_k >= 0 ? e_k : 0);
  }

  printf("#%11s%12s%12s%12s%12s%12s%12s%12s%12s%12s%12s\n", "Start", "Comp time", "Real Comp", "Period", "Cycles", "Budget", "Srv P", "End Time", "Real eps", "Ideal eps", "Diff");
  for (i = 0; i < NUM_JOBS; ++i) {
    printf("%12ld%12ld%12ld%12ld%12ld%12ld%12ld%12ld%12ld%12ld%12ld\n", s[i], c[i], cr[i], APP_T, cs[i], q[i], SRV_P, f[i], e[i], em[i], e[i] - em[i]);
  }

  return 0;
}

---