From d6f5d8bba6770c5fa56ebadba3b0e56b2b3d70d9 Mon Sep 17 00:00:00 2001 From: TKF Date: Sun, 8 Sep 2024 19:38:34 +0800 Subject: [PATCH] Update eevdf --- CMakeLists.txt | 4 +- include/skyloft/sched/ops.h | 4 + include/skyloft/sched/policy/cfs.h | 2 + include/skyloft/sched/policy/eevdf.h | 108 +++ include/skyloft/stat.h | 38 +- libos/sched/policy/eevdf.c | 902 ++++++++++++++++++ libos/sched/sched.c | 15 +- libos/sched/utimer.c | 5 + libos/shim/pthread.c | 7 +- libos/stat.c | 2 +- libos/sync/timer.c | 5 - paper_results/schbench/linux_eevdf/16.txt | 40 + paper_results/schbench/linux_eevdf/24.txt | 40 + paper_results/schbench/linux_eevdf/256.txt | 40 + paper_results/schbench/linux_eevdf/32.txt | 40 + paper_results/schbench/linux_eevdf/40.txt | 40 + paper_results/schbench/linux_eevdf/48.txt | 40 + paper_results/schbench/linux_eevdf/56.txt | 40 + paper_results/schbench/linux_eevdf/64.txt | 40 + paper_results/schbench/linux_eevdf/72.txt | 40 + paper_results/schbench/linux_eevdf/8.txt | 40 + paper_results/schbench/linux_eevdf/80.txt | 40 + paper_results/schbench/linux_eevdf/88.txt | 40 + paper_results/schbench/linux_eevdf/96.txt | 40 + paper_results/schbench/linux_eevdf/all.csv | 13 + paper_results/schbench/skyloft_cfs50us/16.txt | 73 +- paper_results/schbench/skyloft_cfs50us/24.txt | 73 +- paper_results/schbench/skyloft_cfs50us/32.txt | 73 +- paper_results/schbench/skyloft_cfs50us/4.txt | 18 - paper_results/schbench/skyloft_cfs50us/40.txt | 73 +- paper_results/schbench/skyloft_cfs50us/48.txt | 73 +- paper_results/schbench/skyloft_cfs50us/56.txt | 73 +- paper_results/schbench/skyloft_cfs50us/64.txt | 73 +- paper_results/schbench/skyloft_cfs50us/72.txt | 73 +- paper_results/schbench/skyloft_cfs50us/8.txt | 73 +- paper_results/schbench/skyloft_cfs50us/80.txt | 73 +- paper_results/schbench/skyloft_cfs50us/88.txt | 73 +- paper_results/schbench/skyloft_cfs50us/96.txt | 73 +- .../schbench/skyloft_cfs50us/all.csv | 25 +- paper_results/schbench/skyloft_eevdf/16.txt | 55 ++ paper_results/schbench/skyloft_eevdf/24.txt | 55 ++ paper_results/schbench/skyloft_eevdf/32.txt | 55 ++ paper_results/schbench/skyloft_eevdf/40.txt | 55 ++ paper_results/schbench/skyloft_eevdf/48.txt | 55 ++ paper_results/schbench/skyloft_eevdf/56.txt | 37 + paper_results/schbench/skyloft_eevdf/64.txt | 55 ++ paper_results/schbench/skyloft_eevdf/72.txt | 55 ++ paper_results/schbench/skyloft_eevdf/8.txt | 55 ++ paper_results/schbench/skyloft_eevdf/80.txt | 55 ++ paper_results/schbench/skyloft_eevdf/88.txt | 55 ++ paper_results/schbench/skyloft_eevdf/96.txt | 55 ++ paper_results/schbench/skyloft_eevdf/all.csv | 13 + scripts/bench/schbench.sh | 2 - scripts/build.sh | 2 +- scripts/params/schbench-eevdf.params | 3 + scripts/plots/plot_schbench.py | 27 +- utils/include/utils/compiler.h | 103 ++ utils/include/utils/defs.h | 134 ++- utils/include/utils/minmax.h | 81 ++ 59 files changed, 3239 insertions(+), 312 deletions(-) create mode 100644 include/skyloft/sched/policy/eevdf.h create mode 100644 libos/sched/policy/eevdf.c create mode 100644 paper_results/schbench/linux_eevdf/16.txt create mode 100644 paper_results/schbench/linux_eevdf/24.txt create mode 100644 paper_results/schbench/linux_eevdf/256.txt create mode 100644 paper_results/schbench/linux_eevdf/32.txt create mode 100644 paper_results/schbench/linux_eevdf/40.txt create mode 100644 paper_results/schbench/linux_eevdf/48.txt create mode 100644 paper_results/schbench/linux_eevdf/56.txt create mode 100644 paper_results/schbench/linux_eevdf/64.txt create mode 100644 paper_results/schbench/linux_eevdf/72.txt create mode 100644 paper_results/schbench/linux_eevdf/8.txt create mode 100644 paper_results/schbench/linux_eevdf/80.txt create mode 100644 paper_results/schbench/linux_eevdf/88.txt create mode 100644 paper_results/schbench/linux_eevdf/96.txt create mode 100644 paper_results/schbench/linux_eevdf/all.csv delete mode 100644 paper_results/schbench/skyloft_cfs50us/4.txt create mode 100644 paper_results/schbench/skyloft_eevdf/16.txt create mode 100644 paper_results/schbench/skyloft_eevdf/24.txt create mode 100644 paper_results/schbench/skyloft_eevdf/32.txt create mode 100644 paper_results/schbench/skyloft_eevdf/40.txt create mode 100644 paper_results/schbench/skyloft_eevdf/48.txt create mode 100644 paper_results/schbench/skyloft_eevdf/56.txt create mode 100644 paper_results/schbench/skyloft_eevdf/64.txt create mode 100644 paper_results/schbench/skyloft_eevdf/72.txt create mode 100644 paper_results/schbench/skyloft_eevdf/8.txt create mode 100644 paper_results/schbench/skyloft_eevdf/80.txt create mode 100644 paper_results/schbench/skyloft_eevdf/88.txt create mode 100644 paper_results/schbench/skyloft_eevdf/96.txt create mode 100644 paper_results/schbench/skyloft_eevdf/all.csv create mode 100644 scripts/params/schbench-eevdf.params create mode 100644 utils/include/utils/compiler.h create mode 100644 utils/include/utils/minmax.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 0f0a4ca..13f3476 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -10,7 +10,7 @@ set(CMAKE_C_STANDARD 23) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -O3 -Wall -Wextra -Wno-unused-parameter") if (DPDK) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}") -elseif (SCHED_POLICY MATCHES "^(fifo|rr|cfs)$") +elseif (SCHED_POLICY MATCHES "^(fifo|rr|cfs|eevdf)$") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mno-sse") endif() @@ -79,6 +79,8 @@ elseif(SCHED_POLICY STREQUAL "rr") add_definitions(-DSKYLOFT_SCHED_FIFO2) elseif(SCHED_POLICY STREQUAL "cfs") add_definitions(-DSKYLOFT_SCHED_CFS) +elseif(SCHED_POLICY STREQUAL "eevdf") + add_definitions(-DSKYLOFT_SCHED_EEVDF) elseif(SCHED_POLICY STREQUAL "sq") add_definitions(-DSKYLOFT_SCHED_SQ) elseif(SCHED_POLICY STREQUAL "sq_lcbe") diff --git a/include/skyloft/sched/ops.h b/include/skyloft/sched/ops.h index d6c0686..5e2a4d2 100644 --- a/include/skyloft/sched/ops.h +++ b/include/skyloft/sched/ops.h @@ -16,6 +16,10 @@ #include "policy/cfs.h" #define SCHED_NAME "cfs" #define SCHED_OP(op_name) cfs_##op_name +#elif defined(SKYLOFT_SCHED_EEVDF) +#include "policy/eevdf.h" +#define SCHED_NAME "eevdf" +#define SCHED_OP(op_name) eevdf_##op_name #elif defined(SKYLOFT_SCHED_SQ) #include "policy/sq.h" #define SCHED_NAME "sq" diff --git a/include/skyloft/sched/policy/cfs.h b/include/skyloft/sched/policy/cfs.h index 33966b3..6a0eb8b 100644 --- a/include/skyloft/sched/policy/cfs.h +++ b/include/skyloft/sched/policy/cfs.h @@ -19,6 +19,7 @@ struct load_weight { /* CFS percpu state */ struct cfs_rq { spinlock_t lock; + uint8_t pad0[60]; /* sum of load of all tasks */ struct load_weight load; uint32_t nr_running; @@ -82,6 +83,7 @@ struct task *cfs_sched_pick_next(); int cfs_sched_spawn(struct task *, int); void cfs_sched_yield(); void cfs_sched_wakeup(struct task *); +void cfs_sched_block(); bool cfs_sched_preempt(); int cfs_sched_init_task(struct task *); void cfs_sched_finish_task(struct task *); diff --git a/include/skyloft/sched/policy/eevdf.h b/include/skyloft/sched/policy/eevdf.h new file mode 100644 index 0000000..dff46f3 --- /dev/null +++ b/include/skyloft/sched/policy/eevdf.h @@ -0,0 +1,108 @@ +#pragma once + +#include +#include + +#include +#include +#include +#include + +#include "dummy.h" +#include "utils/log.h" + +/* EEVDF load weight: weight * inv_weight = 2^32 */ +struct load_weight { + uint64_t weight; + uint32_t inv_weight; +}; + +/* EEVDF percpu state */ +struct eevdf_rq { + spinlock_t lock; + uint8_t pad0[60]; + /* sum of load of all tasks */ + struct load_weight load; + /* rbtree root with leftmost node cached */ + struct rb_root_cached tasks_timeline; + uint32_t nr_running; + int64_t avg_vruntime; + uint64_t avg_load; + uint64_t min_vruntime; + struct eevdf_task *curr; +} __aligned_cacheline; + +struct eevdf_task { + int last_run; + struct load_weight load; + /* rbtree link */ + struct rb_node run_node; + uint64_t deadline; + uint64_t min_vruntime; + /* task states */ + bool on_rq; + /* task scheduled time */ + __nsec exec_start; + __nsec sum_exec_runtime; + __nsec prev_sum_exec_runtime; + uint64_t vruntime; + int64_t vlag; + uint64_t slice; +} __aligned_cacheline; + +#define WEIGHT_IDLEPRIO 3 +#define WMULT_IDLEPRIO 1431655765 +#define WMULT_CONST (~0U) +#define WMULT_SHIFT 32 +#define NICE_0_SHIFT 10 +#define NICE_0_LOAD (1L << NICE_0_SHIFT) + +#define SCHED_FIXEDPOINT_SHIFT 10 +#define NICE_0_LOAD_SHIFT (SCHED_FIXEDPOINT_SHIFT + SCHED_FIXEDPOINT_SHIFT) + +DECLARE_PERCPU(struct eevdf_rq *, percpu_rqs); + +#define this_rq() percpu_get(percpu_rqs) +#define cpu_rq(cpu) percpu_get_remote(percpu_rqs, cpu) +#define eevdf_task_of(task) ((struct eevdf_task *)task->policy_task_data) +#define task_of(task) (container_of((void *)task, struct task, policy_task_data)) + +#define eevdf_sched_init dummy_sched_init +#define eevdf_sched_set_params dummy_sched_set_params +#define eevdf_sched_poll dummy_sched_poll +#define eevdf_sched_dump_tasks dummy_sched_dump_tasks +#define eevdf_sched_balance dummy_sched_balance + +static inline void eevdf_sched_percpu_lock(int cpu) +{ + // log_debug("%s: %d", __func__, cpu); + spin_lock(&cpu_rq(cpu)->lock); +} + +static inline void eevdf_sched_percpu_unlock(int cpu) +{ + spin_unlock(&cpu_rq(cpu)->lock); + // log_debug("%s: %d", __func__, cpu); +} + +static inline int eevdf_sched_init_percpu(void *percpu_data) +{ + struct eevdf_rq *eevdf_rq = percpu_data; + percpu_get(percpu_rqs) = eevdf_rq; + spin_lock_init(&eevdf_rq->lock); + eevdf_rq->curr = NULL; + eevdf_rq->tasks_timeline = RB_ROOT_CACHED; + eevdf_rq->min_vruntime = (uint64_t)(-(1LL << 20)); + eevdf_rq->nr_running = 0; + eevdf_rq->load.weight = eevdf_rq->load.inv_weight = 0; + return 0; +} + +struct task *eevdf_sched_pick_next(); +int eevdf_sched_spawn(struct task *, int); +void eevdf_sched_yield(); +void eevdf_sched_wakeup(struct task *); +void eevdf_sched_block(); +bool eevdf_sched_preempt(); +int eevdf_sched_init_task(struct task *); +void eevdf_sched_finish_task(struct task *); diff --git a/include/skyloft/stat.h b/include/skyloft/stat.h index a40d66d..002a36c 100644 --- a/include/skyloft/stat.h +++ b/include/skyloft/stat.h @@ -1,6 +1,6 @@ #pragma once -#include +#include /* * These are per-kthread stat counters. It's recommended that most counters be @@ -17,8 +17,6 @@ enum { STAT_TASKS_STOLEN, STAT_IDLE, STAT_IDLE_CYCLES, - // STAT_WAKEUP, - // STAT_WAKEUP_CYCLES, STAT_SOFTIRQS_LOCAL, STAT_SOFTIRQ_CYCLES, STAT_ALLOC, @@ -27,7 +25,10 @@ enum { STAT_TX, #ifdef SKYLOFT_UINTR STAT_UINTR, - // STAT_UINTR_CYCLES, +#ifdef UTIMER + STAT_UTIMER_SENDS, + STAT_UTIMER_CYCLES, +#endif #endif /* total number of counters */ @@ -35,22 +36,13 @@ enum { }; static const char *STAT_STR[] = { - "local_spawns", - "switch_to", - "tasks_stolen", - "idle", - "idle_cycles", - // "wakeup", - // "wakeup_cycles", - "softirqs_local", - "softirq_cycles", - "alloc", - "alloc_cycles", - "rx", - "tx", + "local_spawns", "switch_to", "tasks_stolen", "idle", "idle_cycles", "softirqs_local", + "softirq_cycles", "alloc", "alloc_cycles", "rx", "tx", #ifdef SKYLOFT_UINTR "uintr", - // "uintr_cycles", +#ifdef UTIMER + "utimer_sends", "utimer_cycles", +#endif #endif }; @@ -70,13 +62,9 @@ static inline const char *stat_str(int idx) */ #define ADD_STAT_FORCE(counter, val) (thisk()->stats[STAT_##counter] += val) #ifdef SKYLOFT_STAT -#define ADD_STAT(counter, val) ADD_STAT_FORCE(counter, val) -#define STAT_CYCLES_BEGIN(timer) ({ \ - timer = now_tsc(); \ -}) -#define ADD_STAT_CYCLES(counter, timer) ({ \ - ADD_STAT_FORCE(counter, now_tsc() - timer); \ -}) +#define ADD_STAT(counter, val) ADD_STAT_FORCE(counter, val) +#define STAT_CYCLES_BEGIN(timer) ({ timer = now_tsc(); }) +#define ADD_STAT_CYCLES(counter, timer) ({ ADD_STAT_FORCE(counter, now_tsc() - timer); }) #else #define ADD_STAT(counter, val) #define STAT_CYCLES_BEGIN(timer) ((void)timer) diff --git a/libos/sched/policy/eevdf.c b/libos/sched/policy/eevdf.c new file mode 100644 index 0000000..8ebd117 --- /dev/null +++ b/libos/sched/policy/eevdf.c @@ -0,0 +1,902 @@ +/* + * eevdf.c: EEVDF-like scheduler + */ + +#include +#include +#include +#include + +#include +#include + +#define __node_2_task(node) rb_entry((node), struct eevdf_task, run_node) +#define scale_load(w) ((w) << SCHED_FIXEDPOINT_SHIFT) +#define scale_load_down(w) \ + ({ \ + unsigned long __w = (w); \ + \ + if (__w) \ + __w = max(2UL, __w >> SCHED_FIXEDPOINT_SHIFT); \ + __w; \ + }) + +#ifdef CONFIG_SCHED_DEBUG +#define SCHED_WARN_ON(x) WARN_ONCE(x, #x) +#else +#define SCHED_WARN_ON(x) ({ (void)(x), 0; }) +#endif + +/* TICK_NSEC is the time between ticks in nsec assuming SHIFTED_HZ */ +#define TICK_NSEC ((NSEC_PER_SEC + TIMER_HZ / 2) / TIMER_HZ) + +/* + * Minimal preemption granularity for CPU-bound tasks: + * (default: 0.75 msec * (1 + ilog(ncpus)), units: nanoseconds) + */ +__nsec sysctl_sched_base_slice = 12500ULL; + +DEFINE_PERCPU(struct eevdf_rq *, percpu_rqs); + +/* global counter for next CPU */ +static atomic_int TARGET_CPU = 0; +extern __thread int g_logic_cpu_id; + +static bool update_deadline(struct eevdf_rq *eevdf_rq, struct eevdf_task *task); +static inline struct eevdf_task *__pick_root_task(struct eevdf_rq *eevdf_rq); +static inline struct eevdf_task *__pick_first_task(struct eevdf_rq *eevdf_rq); + +static void __update_inv_weight(struct load_weight *lw) +{ + unsigned long w; + + if (likely(lw->inv_weight)) + return; + + w = lw->weight; + + if (unlikely(w >= WMULT_CONST)) + lw->inv_weight = 1; + else if (unlikely(!w)) + lw->inv_weight = WMULT_CONST; + else + lw->inv_weight = WMULT_CONST / w; +} + +static inline void update_load_add(struct load_weight *lw, unsigned long inc) +{ + lw->weight += inc; + lw->inv_weight = 0; +} + +static inline void update_load_sub(struct load_weight *lw, unsigned long dec) +{ + lw->weight -= dec; + lw->inv_weight = 0; +} + +static inline void update_load_set(struct load_weight *lw, unsigned long w) +{ + lw->weight = w; + lw->inv_weight = 0; +} + +static uint64_t __calc_delta(uint64_t delta_exec, unsigned long weight, struct load_weight *lw) +{ + uint64_t fact = weight; + int shift = WMULT_SHIFT; + + __update_inv_weight(lw); + + if (unlikely(fact >> 32)) { + while (fact >> 32) { + fact >>= 1; + shift--; + } + } + + /* hint to use a 32x32->64 mul */ + fact = (uint64_t)(uint32_t)fact * lw->inv_weight; + + while (fact >> 32) { + fact >>= 1; + shift--; + } + + return mul_u64_u32_shr(delta_exec, fact, shift); +} + +/* + * delta /= w + */ +static inline uint64_t calc_delta_fair(uint64_t delta, struct eevdf_task *task) +{ + if (unlikely(task->load.weight != NICE_0_LOAD)) + delta = __calc_delta(delta, NICE_0_LOAD, &task->load); + + return delta; +} + +static inline uint64_t min_vruntime(uint64_t min_vruntime, uint64_t vruntime) +{ + int64_t delta = (int64_t)(vruntime - min_vruntime); + if (delta < 0) + min_vruntime = vruntime; + + return min_vruntime; +} + +static inline bool task_before(const struct eevdf_task *a, const struct eevdf_task *b) +{ + /* + * Tiebreak on vruntime seems unnecessary since it can + * hardly happen. + */ + return (int64_t)(a->deadline - b->deadline) < 0; +} + +static inline int64_t task_key(struct eevdf_rq *eevdf_rq, struct eevdf_task *task) +{ + return (int64_t)(task->vruntime - eevdf_rq->min_vruntime); +} +/* + * Compute virtual time from the per-task service numbers: + * + * Fair schedulers conserve lag: + * + * \Sum lag_i = 0 + * + * Where lag_i is given by: + * + * lag_i = S - s_i = w_i * (V - v_i) + * + * Where S is the ideal service time and V is it's virtual time counterpart. + * Therefore: + * + * \Sum lag_i = 0 + * \Sum w_i * (V - v_i) = 0 + * \Sum w_i * V - w_i * v_i = 0 + * + * From which we can solve an expression for V in v_i (which we have in + * task->vruntime): + * + * \Sum v_i * w_i \Sum v_i * w_i + * V = -------------- = -------------- + * \Sum w_i W + * + * Specifically, this is the weighted average of all task virtual runtimes. + * + * [[ NOTE: this is only equal to the ideal scheduler under the condition + * that join/leave operations happen at lag_i = 0, otherwise the + * virtual time has non-contiguous motion equivalent to: + * + * V +-= lag_i / W + * + * Also see the comment in place_task() that deals with this. ]] + * + * However, since v_i is uint64_t, and the multiplication could easily overflow + * transform it into a relative form that uses smaller quantities: + * + * Substitute: v_i == (v_i - v0) + v0 + * + * \Sum ((v_i - v0) + v0) * w_i \Sum (v_i - v0) * w_i + * V = ---------------------------- = --------------------- + v0 + * W W + * + * Which we track using: + * + * v0 := eevdf_rq->min_vruntime + * \Sum (v_i - v0) * w_i := eevdf_rq->avg_vruntime + * \Sum w_i := eevdf_rq->avg_load + * + * Since min_vruntime is a monotonic increasing variable that closely tracks + * the per-task service, these deltas: (v_i - v), will be in the order of the + * maximal (virtual) lag induced in the system due to quantisation. + * + * Also, we use scale_load_down() to reduce the size. + * + * As measured, the max (key * weight) value was ~44 bits for a kernel build. + */ +static void avg_vruntime_add(struct eevdf_rq *eevdf_rq, struct eevdf_task *task) +{ + unsigned long weight = scale_load_down(task->load.weight); + int64_t key = task_key(eevdf_rq, task); + + eevdf_rq->avg_vruntime += key * weight; + eevdf_rq->avg_load += weight; +} + +static void avg_vruntime_sub(struct eevdf_rq *eevdf_rq, struct eevdf_task *task) +{ + unsigned long weight = scale_load_down(task->load.weight); + int64_t key = task_key(eevdf_rq, task); + + eevdf_rq->avg_vruntime -= key * weight; + eevdf_rq->avg_load -= weight; +} + +static inline void avg_vruntime_update(struct eevdf_rq *eevdf_rq, int64_t delta) +{ + /* + * v' = v + d ==> avg_vruntime' = avg_runtime - d*avg_load + */ + eevdf_rq->avg_vruntime -= eevdf_rq->avg_load * delta; +} + +/* + * Specifically: avg_runtime() + 0 must result in task_eligible() := true + * For this to be so, the result of this function must have a left bias. + */ +uint64_t avg_vruntime(struct eevdf_rq *eevdf_rq) +{ + struct eevdf_task *curr = eevdf_rq->curr; + int64_t avg = eevdf_rq->avg_vruntime; + long load = eevdf_rq->avg_load; + + if (curr && curr->on_rq) { + unsigned long weight = scale_load_down(curr->load.weight); + + avg += task_key(eevdf_rq, curr) * weight; + load += weight; + } + + if (load) { + /* sign flips effective floor / ceiling */ + if (avg < 0) + avg -= (load - 1); + avg = div_s64(avg, load); + } + + return eevdf_rq->min_vruntime + avg; +} + +/* + * lag_i = S - s_i = w_i * (V - v_i) + * + * However, since V is approximated by the weighted average of all entities it + * is possible -- by addition/removal/reweight to the tree -- to move V around + * and end up with a larger lag than we started with. + * + * Limit this to either double the slice length with a minimum of TICK_NSEC + * since that is the timing granularity. + * + * EEVDF gives the following limit for a steady state system: + * + * -r_max < lag < max(r_max, q) + * + * XXX could add max_slice to the augmented data to track this. + */ +static int64_t task_lag(uint64_t avruntime, struct eevdf_task *task) +{ + int64_t vlag, limit; + + vlag = avruntime - task->vruntime; + limit = calc_delta_fair(max_t(uint64_t, 2 * task->slice, TICK_NSEC), task); + + return clamp(vlag, -limit, limit); +} + +static void update_task_lag(struct eevdf_rq *eevdf_rq, struct eevdf_task *task) +{ + SCHED_WARN_ON(!task->on_rq); + + task->vlag = task_lag(avg_vruntime(eevdf_rq), task); +} + +/* + * Task is eligible once it received less service than it ought to have, + * eg. lag >= 0. + * + * lag_i = S - s_i = w_i*(V - v_i) + * + * lag_i >= 0 -> V >= v_i + * + * \Sum (v_i - v)*w_i + * V = ------------------ + v + * \Sum w_i + * + * lag_i >= 0 -> \Sum (v_i - v)*w_i >= (v_i - v)*(\Sum w_i) + * + * Note: using 'avg_vruntime() > task->vruntime' is inaccurate due + * to the loss in precision caused by the division. + */ +static int vruntime_eligible(struct eevdf_rq *eevdf_rq, uint64_t vruntime) +{ + struct eevdf_task *curr = eevdf_rq->curr; + int64_t avg = eevdf_rq->avg_vruntime; + long load = eevdf_rq->avg_load; + + if (curr && curr->on_rq) { + unsigned long weight = scale_load_down(curr->load.weight); + + avg += task_key(eevdf_rq, curr) * weight; + load += weight; + } + + return avg >= (int64_t)(vruntime - eevdf_rq->min_vruntime) * load; +} + +static inline int task_eligible(struct eevdf_rq *eevdf_rq, struct eevdf_task *task) +{ + return vruntime_eligible(eevdf_rq, task->vruntime); +} + +static uint64_t __update_min_vruntime(struct eevdf_rq *eevdf_rq, uint64_t vruntime) +{ + uint64_t min_vruntime = eevdf_rq->min_vruntime; + /* + * open coded max_vruntime() to allow updating avg_vruntime + */ + int64_t delta = (int64_t)(vruntime - min_vruntime); + if (delta > 0) { + avg_vruntime_update(eevdf_rq, delta); + min_vruntime = vruntime; + } + return min_vruntime; +} + +static void update_min_vruntime(struct eevdf_rq *eevdf_rq) +{ + struct eevdf_task *task = __pick_root_task(eevdf_rq); + struct eevdf_task *curr = eevdf_rq->curr; + uint64_t vruntime = eevdf_rq->min_vruntime; + + if (curr) { + if (curr->on_rq) + vruntime = curr->vruntime; + else + curr = NULL; + } + + if (task) { + if (!curr) + vruntime = task->min_vruntime; + else + vruntime = min_vruntime(vruntime, task->min_vruntime); + } + + /* ensure we never gain time by being placed backwards. */ + eevdf_rq->min_vruntime = __update_min_vruntime(eevdf_rq, vruntime); +} + +#define vruntime_gt(field, lse, rse) ({ (int64_t)((lse)->field - (rse)->field) > 0; }) + +static inline void __min_vruntime_update(struct eevdf_task *task, struct rb_node *node) +{ + if (node) { + struct eevdf_task *rse = __node_2_task(node); + if (vruntime_gt(min_vruntime, task, rse)) + task->min_vruntime = rse->min_vruntime; + } +} + +/* + * task->min_vruntime = min(task->vruntime, {left,right}->min_vruntime) + */ +static inline bool min_vruntime_update(struct eevdf_task *task, bool exit) +{ + uint64_t old_min_vruntime = task->min_vruntime; + struct rb_node *node = &task->run_node; + + task->min_vruntime = task->vruntime; + __min_vruntime_update(task, node->rb_right); + __min_vruntime_update(task, node->rb_left); + + return task->min_vruntime == old_min_vruntime; +} + +RB_DECLARE_CALLBACKS(static, min_vruntime_cb, struct eevdf_task, run_node, min_vruntime, + min_vruntime_update); + +static inline bool update_curr(struct eevdf_rq *eevdf_rq) +{ + struct eevdf_task *curr = eevdf_rq->curr; + __nsec now = now_ns(); + int64_t delta_exec; + bool resched = false; + + if (unlikely(!curr)) + return resched; + + delta_exec = now - curr->exec_start; + if (unlikely(delta_exec <= 0)) + return resched; + + curr->exec_start = now; + curr->sum_exec_runtime += delta_exec; + curr->vruntime += calc_delta_fair(delta_exec, curr); + resched = update_deadline(eevdf_rq, curr); + update_min_vruntime(eevdf_rq); + return resched; +} + +static bool update_deadline(struct eevdf_rq *eevdf_rq, struct eevdf_task *task) +{ + if ((int64_t)(task->vruntime - task->deadline) < 0) + return false; + + /* + * For EEVDF the virtual time slope is determined by w_i (iow. + * nice) while the request time r_i is determined by + * sysctl_sched_base_slice. + */ + task->slice = sysctl_sched_base_slice; + + /* + * EEVDF: vd_i = ve_i + r_i / w_i + */ + task->deadline = task->vruntime + calc_delta_fair(task->slice, task); + + /* + * The task has consumed its request, reschedule. + */ + if (eevdf_rq->nr_running > 1) { + return true; + // resched_curr(rq_of(eevdf_rq)); + // clear_buddies(eevdf_rq, task); + } + + return false; +} + +static void place_task(struct eevdf_rq *eevdf_rq, struct eevdf_task *task, bool init) +{ + uint64_t vslice, vruntime = avg_vruntime(eevdf_rq); + int64_t lag = 0; + + task->slice = sysctl_sched_base_slice; + vslice = calc_delta_fair(task->slice, task); + + // SCHED_FEAT(PLACE_LAG, true) + /* + * Due to how V is constructed as the weighted average of entities, + * adding tasks with positive lag, or removing tasks with negative lag + * will move 'time' backwards, this can screw around with the lag of + * other tasks. + * + * EEVDF: placement strategy #1 / #2 + */ + if (eevdf_rq->nr_running) { + struct eevdf_task *curr = eevdf_rq->curr; + unsigned long load; + + lag = task->vlag; + + /* + * If we want to place a task and preserve lag, we have to + * consider the effect of the new task on the weighted + * average and compensate for this, otherwise lag can quickly + * evaporate. + * + * Lag is defined as: + * + * lag_i = S - s_i = w_i * (V - v_i) + * + * To avoid the 'w_i' term all over the place, we only track + * the virtual lag: + * + * vl_i = V - v_i <=> v_i = V - vl_i + * + * And we take V to be the weighted average of all v: + * + * V = (\Sum w_j*v_j) / W + * + * Where W is: \Sum w_j + * + * Then, the weighted average after adding an task with lag + * vl_i is given by: + * + * V' = (\Sum w_j*v_j + w_i*v_i) / (W + w_i) + * = (W*V + w_i*(V - vl_i)) / (W + w_i) + * = (W*V + w_i*V - w_i*vl_i) / (W + w_i) + * = (V*(W + w_i) - w_i*l) / (W + w_i) + * = V - w_i*vl_i / (W + w_i) + * + * And the actual lag after adding an task with vl_i is: + * + * vl'_i = V' - v_i + * = V - w_i*vl_i / (W + w_i) - (V - vl_i) + * = vl_i - w_i*vl_i / (W + w_i) + * + * Which is strictly less than vl_i. So in order to preserve lag + * we should inflate the lag before placement such that the + * effective lag after placement comes out right. + * + * As such, invert the above relation for vl'_i to get the vl_i + * we need to use such that the lag after placement is the lag + * we computed before dequeue. + * + * vl'_i = vl_i - w_i*vl_i / (W + w_i) + * = ((W + w_i)*vl_i - w_i*vl_i) / (W + w_i) + * + * (W + w_i)*vl'_i = (W + w_i)*vl_i - w_i*vl_i + * = W*vl_i + * + * vl_i = (W + w_i)*vl'_i / W + */ + load = eevdf_rq->avg_load; + if (curr && curr->on_rq) + load += scale_load_down(curr->load.weight); + + lag *= load + scale_load_down(task->load.weight); + if (WARN_ON_ONCE(!load)) + load = 1; + lag = div_s64(lag, load); + } + + task->vruntime = vruntime - lag; + + // SCHED_FEAT(PLACE_LAG, true) + /* + * When joining the competition; the existing tasks will be, + * on average, halfway through their slice, as such start tasks + * off with half a slice to ease into the competition. + */ + if (init) + vslice /= 2; + + /* + * EEVDF: vd_i = ve_i + r_i/w_i + */ + task->deadline = task->vruntime + vslice; + log_debug("%s: rq: %p, task: %p, init: %d, slice: %lu, vrt: %lu, ddl: %lu", __func__, eevdf_rq, + task, init, task->slice, task->vruntime, task->deadline); +} + +static inline struct eevdf_task *__pick_root_task(struct eevdf_rq *eevdf_rq) +{ + struct rb_node *root = eevdf_rq->tasks_timeline.rb_root.rb_node; + + if (!root) + return NULL; + + return __node_2_task(root); +} + +static inline struct eevdf_task *__pick_first_task(struct eevdf_rq *eevdf_rq) +{ + struct rb_node *left = rb_first_cached(&eevdf_rq->tasks_timeline); + + if (!left) + return NULL; + + return __node_2_task(left); +} + +static inline void __dequeue_task(struct eevdf_rq *eevdf_rq, struct eevdf_task *task) +{ + rb_erase_augmented_cached(&task->run_node, &eevdf_rq->tasks_timeline, &min_vruntime_cb); + avg_vruntime_sub(eevdf_rq, task); +} + +static inline bool __deadline_less(struct rb_node *a, const struct rb_node *b) +{ + return (int64_t)(rb_entry(a, struct eevdf_task, run_node)->deadline - + rb_entry(b, struct eevdf_task, run_node)->deadline) < 0; +} + +/* + * Enqueue an task into the rb-tree: + */ +static inline void __enqueue_task(struct eevdf_rq *eevdf_rq, struct eevdf_task *task) +{ + avg_vruntime_add(eevdf_rq, task); + task->min_vruntime = task->vruntime; + rb_add_augmented_cached(&task->run_node, &eevdf_rq->tasks_timeline, __deadline_less, + &min_vruntime_cb); +} + +static void __set_next_task(struct eevdf_rq *eevdf_rq, struct eevdf_task *task) +{ + if (task->on_rq) { + __dequeue_task(eevdf_rq, task); + /* + * HACK, stash a copy of deadline at the point of pick in vlag, + * which isn't used until dequeue. + */ + task->vlag = task->deadline; + } + task->exec_start = now_ns(); + task->last_run = g_logic_cpu_id; + task->prev_sum_exec_runtime = task->sum_exec_runtime; + eevdf_rq->curr = task; +} + +static inline void enqueue_update(struct eevdf_rq *eevdf_rq, struct eevdf_task *task) +{ + update_load_add(&eevdf_rq->load, task->load.weight); + eevdf_rq->nr_running++; +} + +static void enqueue_task(struct eevdf_rq *eevdf_rq, struct eevdf_task *task) +{ + // log_debug("%s enter: rq=%p task=%p", __func__, eevdf_rq, task); + bool curr = (task == eevdf_rq->curr); + assert_spin_lock_held(&eevdf_rq->lock); + + if (curr) + place_task(eevdf_rq, task, 0); + update_curr(eevdf_rq); + + /* + * XXX now that the entity has been re-weighted, and it's lag adjusted, + * we can place the entity. + */ + if (!curr) + place_task(eevdf_rq, task, 0); + enqueue_update(eevdf_rq, task); + + if (!curr) + __enqueue_task(eevdf_rq, task); + + task->on_rq = true; + log_debug("%s exit: rq=%p task=%p curr=%p nr=%d\n", __func__, eevdf_rq, task, eevdf_rq->curr, + eevdf_rq->nr_running); +} + +static inline void dequeue_update(struct eevdf_rq *eevdf_rq, struct eevdf_task *task) +{ + update_load_sub(&eevdf_rq->load, task->load.weight); + eevdf_rq->nr_running--; +} + +static void dequeue_task(struct eevdf_rq *eevdf_rq, struct eevdf_task *task) +{ + assert_spin_lock_held(&eevdf_rq->lock); + + update_curr(eevdf_rq); + + update_task_lag(eevdf_rq, task); + if (task != eevdf_rq->curr) + __dequeue_task(eevdf_rq, task); + task->on_rq = false; + dequeue_update(eevdf_rq, task); + + update_min_vruntime(eevdf_rq); + log_debug("%s: task: %p, curr: %p, nr_run: %d", __func__, task, eevdf_rq->curr, + eevdf_rq->nr_running); +} + +int eevdf_sched_init_task(struct task *t) +{ + // log_debug("%s: %p", __func__, t); + struct eevdf_task *task = eevdf_task_of(t); + memset(task, 0, sizeof(struct eevdf_task)); + task->slice = sysctl_sched_base_slice; + /* guarantee task always has weight */ + update_load_set(&task->load, NICE_0_LOAD); + t->allow_preempt = true; + log_debug("%s: return\n", __func__); + return 0; +} + +void eevdf_sched_finish_task(struct task *t) +{ + // log_debug("%s: %p\n", __func__, t); + struct eevdf_rq *eevdf_rq = this_rq(); + struct eevdf_task *task = eevdf_task_of(t); + + assert_local_irq_disabled(); + + spin_lock(&eevdf_rq->lock); + dequeue_task(eevdf_rq, task); + eevdf_rq->curr = NULL; /* never touch it again */ + spin_unlock(&eevdf_rq->lock); + log_debug("%s: exit\n", __func__); +} + +static inline void __put_task(struct eevdf_rq *eevdf_rq, struct eevdf_task *task) +{ + log_debug("%s: rq: %p, task: %p", __func__, eevdf_rq, task); + spin_lock(&eevdf_rq->lock); + if (!task->on_rq) + enqueue_task(eevdf_rq, task); + spin_unlock(&eevdf_rq->lock); + // log_debug("%s: exit, rq: %p, task: %p\n", __func__, eevdf_rq, task); +} + +static void __fork_task(struct eevdf_rq *eevdf_rq, struct eevdf_task *task) +{ + struct eevdf_task *curr = eevdf_rq->curr; + if (curr) + update_curr(eevdf_rq); + place_task(eevdf_rq, task, true); +} + +static inline int find_target_cpu(struct eevdf_task *task, bool new_task) +{ + if (new_task) { + return atomic_fetch_add(&TARGET_CPU, 1) % USED_CPUS; + } else { + return task->last_run; + } +} + +int eevdf_sched_spawn(struct task *t, int cpu) +{ + struct eevdf_task *task = eevdf_task_of(t); + int target_cpu = find_target_cpu(task, true); + struct eevdf_rq *eevdf_rq = cpu_rq(target_cpu); + log_debug("%s: t: %p, cpu: %d, target_cpu: %d", __func__, t, cpu, target_cpu); + + __fork_task(eevdf_rq, task); + __put_task(eevdf_rq, task); + // log_debug("%s: exit, t: %p, cpu: %d\n", __func__, t, cpu); + + return 0; +} + +/* + * Earliest Eligible Virtual Deadline First + * + * In order to provide latency guarantees for different request sizes + * EEVDF selects the best runnable task from two criteria: + * + * 1) the task must be eligible (must be owed service) + * + * 2) from those tasks that meet 1), we select the one + * with the earliest virtual deadline. + * + * We can do this in O(log n) time due to an augmented RB-tree. The + * tree keeps the entries sorted on deadline, but also functions as a + * heap based on the vruntime by keeping: + * + * task->min_vruntime = min(task->vruntime, task->{left,right}->min_vruntime) + * + * Which allows tree pruning through eligibility. + */ +static struct eevdf_task *pick_eevdf(struct eevdf_rq *eevdf_rq) +{ + // log_debug("%s: %p", __func__, eevdf_rq); + struct rb_node *node = eevdf_rq->tasks_timeline.rb_root.rb_node; + struct eevdf_task *task = __pick_first_task(eevdf_rq); + struct eevdf_task *curr = eevdf_rq->curr; + struct eevdf_task *best = NULL; + + /* + * We can safely skip eligibility check if there is only one task + * in this eevdf_rq, saving some cycles. + */ + if (eevdf_rq->nr_running == 1) + return curr && curr->on_rq ? curr : task; + + if (curr && (!curr->on_rq || !task_eligible(eevdf_rq, curr))) + curr = NULL; + + // SCHED_FEAT(RUN_TO_PARITY, true) + /* + * Once selected, run a task until it either becomes non-eligible or + * until it gets a new slice. See the HACK in set_next_task(). + */ + if (curr && curr->vlag == curr->deadline) + return curr; + + /* Pick the leftmost task if it's eligible */ + if (task && task_eligible(eevdf_rq, task)) { + best = task; + goto found; + } + + /* Heap search for the EEVD task */ + while (node) { + struct rb_node *left = node->rb_left; + + /* + * Eligible entities in left subtree are always better + * choices, since they have earlier deadlines. + */ + if (left && vruntime_eligible(eevdf_rq, __node_2_task(left)->min_vruntime)) { + node = left; + continue; + } + + task = __node_2_task(node); + + /* + * The left subtree either is empty or has no eligible + * task, so check the current node since it is the one + * with earliest deadline that might be eligible. + */ + if (task_eligible(eevdf_rq, task)) { + best = task; + break; + } + + node = node->rb_right; + } +found: + if (!best || (curr && task_before(curr, best))) + best = curr; + + // log_debug("%s: best: %p", __func__, best); + return best; +} + +struct task *eevdf_sched_pick_next() +{ + struct eevdf_rq *rq = this_rq(); + struct eevdf_task *task; + struct eevdf_task *curr = rq->curr; + + assert_spin_lock_held(&rq->lock); + if (curr) { + if (curr->on_rq) + update_curr(rq); + else + curr = NULL; + } + + if (!rq->nr_running) + return NULL; + + task = pick_eevdf(rq); + if (!task) { + return NULL; + } + __set_next_task(rq, task); + + return task_of(task); +} + +void eevdf_sched_yield() +{ + struct eevdf_rq *rq = this_rq(); + struct eevdf_task *prev = rq->curr; + // log_debug("%s: rq: %p, curr: %p, self: %p", __func__, this_rq(), this_rq()->curr, + // eevdf_task_of(task_self())); + assert(this_rq()->curr == eevdf_task_of(task_self())); + + spin_lock(&rq->lock); + if (prev->on_rq) { + update_curr(rq); + prev->deadline += calc_delta_fair(prev->slice, prev); + __enqueue_task(rq, prev); + } + rq->curr = NULL; + spin_unlock(&rq->lock); + // log_debug("%s: exit, rq: %p", __func__, rq); +} + +void eevdf_sched_wakeup(struct task *t) +{ + // log_debug("%s: task: %p", __func__, t); + struct eevdf_task *task = eevdf_task_of(t); + struct eevdf_rq *rq = cpu_rq(find_target_cpu(task, false)); + + spin_lock(&rq->lock); + if (!task->on_rq) + enqueue_task(rq, task); + spin_unlock(&rq->lock); + log_debug("%s: rq: %p, task: %p \n", __func__, rq, task); +} + +void eevdf_sched_block() +{ + // log_debug("%s: enter", __func__); + struct eevdf_rq *rq = this_rq(); + + assert(rq->curr->on_rq); + + spin_lock(&rq->lock); + dequeue_task(rq, rq->curr); + rq->curr = NULL; + spin_unlock(&rq->lock); + // log_debug("%s: exit, rq: %p", __func__, rq); +} + +bool eevdf_sched_preempt() +{ + // log_debug("%s: enter", __func__); + bool resched = false; + struct eevdf_rq *eevdf_rq = this_rq(); + + assert_local_irq_disabled(); + + spin_lock(&eevdf_rq->lock); + resched = update_curr(eevdf_rq); + spin_unlock(&eevdf_rq->lock); + + // log_debug("%s: rq: %p, return %d\n", __func__, eevdf_rq, resched); + + return resched; +} diff --git a/libos/sched/sched.c b/libos/sched/sched.c index 0d82948..826fa76 100644 --- a/libos/sched/sched.c +++ b/libos/sched/sched.c @@ -139,10 +139,11 @@ __noreturn __noinline void schedule() STAT_CYCLES_BEGIN(elapsed); again: next = __sched_pick_next(); -#ifdef SKYLOFT_SCHED_CFS - __sched_percpu_unlock(g_logic_cpu_id); -#endif if (unlikely(!next)) { +#if defined(SKYLOFT_SCHED_CFS) || defined(SKYLOFT_SCHED_EEVDF) + // log_debug("%s: again, unlocking", __func__); + __sched_percpu_unlock(g_logic_cpu_id); +#endif #ifdef SCHED_PERCPU #ifdef SKYLOFT_DPDK if ((next = softirq_task(localk, SOFTIRQ_MAX_BUDGET))) { @@ -155,7 +156,7 @@ __noreturn __noinline void schedule() #endif /* optional load balance */ __sched_balance(); -#ifdef SKYLOFT_SCHED_CFS +#if defined(SKYLOFT_SCHED_CFS) || defined(SKYLOFT_SCHED_EEVDF) __sched_percpu_lock(g_logic_cpu_id); #endif #endif @@ -226,7 +227,8 @@ int sched_init_percpu() return -1; } - __curr = __idle = task; + __curr = NULL; + __idle = task; extern uint32_t *rcu_gen_percpu[USED_CPUS]; rcu_gen_percpu[g_logic_cpu_id] = &rcu_gen; @@ -361,9 +363,10 @@ void task_wakeup(struct task *task) void task_block(spinlock_t *lock) { int flags; + assert_preempt_disabled(); assert_spin_lock_held(lock); - local_irq_disable(); + local_irq_save(flags); preempt_enable(); diff --git a/libos/sched/utimer.c b/libos/sched/utimer.c index b8b967c..999501e 100644 --- a/libos/sched/utimer.c +++ b/libos/sched/utimer.c @@ -1,6 +1,7 @@ #include #include #include +#include #include #include @@ -33,6 +34,7 @@ static int utimer_init(void) __noreturn void utimer_main(void) { int i; + uint64_t stat; utimer_init(); @@ -40,9 +42,12 @@ __noreturn void utimer_main(void) while (true) { for (i = 0; i < proc->nr_ks; i++) { + STAT_CYCLES_BEGIN(stat); if (now_ns() > utimer.deadline[i]) { _senduipi(utimer.uintr_index[i]); utimer.deadline[i] = now_ns() + NSEC_PER_TICK; + ADD_STAT(UTIMER_SENDS, 1); + ADD_STAT_CYCLES(UTIMER_CYCLES, stat); } } } diff --git a/libos/shim/pthread.c b/libos/shim/pthread.c index be24915..62a7461 100644 --- a/libos/shim/pthread.c +++ b/libos/shim/pthread.c @@ -29,9 +29,10 @@ static void __trampoline(void *arg) spin_unlock_np(&j->lock); return; } - if (j->waiter != NULL) { - task_enqueue(0, j->waiter); - } + + if (j->waiter) + task_wakeup(j->waiter); + j->waiter = task_self(); task_block(&j->lock); } diff --git a/libos/stat.c b/libos/stat.c index f4db6a6..96e2b2b 100644 --- a/libos/stat.c +++ b/libos/stat.c @@ -12,7 +12,7 @@ void print_stats(void) printf("%3c", ' '); for (i = 0; i < STAT_NR; i++) printf("%16s", stat_str(i)); printf("\n"); - for (i = 0; i < proc->nr_ks; i++) { + for (i = 0; i < USED_CPUS; i++) { printf("%2d:", i); for (j = 0; j < STAT_NR; j++) printf("%16ld", proc->all_ks[i].stats[j]); printf("\n"); diff --git a/libos/sync/timer.c b/libos/sync/timer.c index a798b8d..13a71a7 100644 --- a/libos/sync/timer.c +++ b/libos/sync/timer.c @@ -217,13 +217,11 @@ bool timer_cancel(struct timer_entry *e) if (e->k != k) { /* Timer was merged to a different heap */ spin_unlock_np(&k->timer_lock); - preempt_enable(); goto try_again; } if (!e->armed) { spin_unlock_np(&k->timer_lock); - preempt_enable(); return false; } e->armed = false; @@ -231,7 +229,6 @@ bool timer_cancel(struct timer_entry *e) last = --k->nr_timers; if (e->idx == last) { spin_unlock_np(&k->timer_lock); - preempt_enable(); return true; } @@ -240,8 +237,6 @@ bool timer_cancel(struct timer_entry *e) sift_up(k->timers, e->idx); sift_down(k->timers, e->idx, k->nr_timers); spin_unlock_np(&k->timer_lock); - - preempt_enable(); return true; } diff --git a/paper_results/schbench/linux_eevdf/16.txt b/paper_results/schbench/linux_eevdf/16.txt new file mode 100644 index 0000000..827dd90 --- /dev/null +++ b/paper_results/schbench/linux_eevdf/16.txt @@ -0,0 +1,40 @@ +Wakeup Latencies percentiles (usec) runtime 10 (s) (63770 total samples) + 50.0th: 4 (0 samples) + 90.0th: 5 (15530 samples) + * 99.0th: 8 (5573 samples) + 99.9th: 12 (368 samples) + min=1, max=113 +Request Latencies percentiles (usec) runtime 10 (s) (64050 total samples) + 50.0th: 2492 (36509 samples) + 90.0th: 2492 (0 samples) + * 99.0th: 2508 (3062 samples) + 99.9th: 2636 (383 samples) + min=2426, max=4765 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 6408 (11 samples) + * 50.0th: 6408 (0 samples) + 90.0th: 6408 (0 samples) + min=6401, max=6408 +current rps: 6404 +Wakeup Latencies percentiles (usec) runtime 10 (s) (63771 total samples) + 50.0th: 4 (0 samples) + 90.0th: 5 (15531 samples) + * 99.0th: 8 (5573 samples) + 99.9th: 12 (368 samples) + min=1, max=113 +Request Latencies percentiles (usec) runtime 10 (s) (64067 total samples) + 50.0th: 2492 (36520 samples) + 90.0th: 2492 (0 samples) + * 99.0th: 2508 (3064 samples) + 99.9th: 2636 (385 samples) + min=2426, max=4765 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 6408 (11 samples) + * 50.0th: 6408 (0 samples) + 90.0th: 6408 (0 samples) + min=6401, max=6408 +average rps: 6407 +message_threads 1 +worker_threads 16 +operations 10 +matrix_size 73 diff --git a/paper_results/schbench/linux_eevdf/24.txt b/paper_results/schbench/linux_eevdf/24.txt new file mode 100644 index 0000000..5fa9138 --- /dev/null +++ b/paper_results/schbench/linux_eevdf/24.txt @@ -0,0 +1,40 @@ +Wakeup Latencies percentiles (usec) runtime 10 (s) (93212 total samples) + 50.0th: 5 (19239 samples) + 90.0th: 11 (34768 samples) + * 99.0th: 21 (7056 samples) + 99.9th: 873 (839 samples) + min=1, max=2376 +Request Latencies percentiles (usec) runtime 10 (s) (94980 total samples) + 50.0th: 2492 (34897 samples) + 90.0th: 2500 (28384 samples) + * 99.0th: 2540 (7944 samples) + 99.9th: 3420 (799 samples) + min=2427, max=4975 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9456 (3 samples) + * 50.0th: 9488 (3 samples) + 90.0th: 9520 (5 samples) + min=9411, max=9533 +current rps: 9493 +Wakeup Latencies percentiles (usec) runtime 10 (s) (93213 total samples) + 50.0th: 5 (19239 samples) + 90.0th: 11 (34769 samples) + * 99.0th: 21 (7056 samples) + 99.9th: 873 (839 samples) + min=1, max=2376 +Request Latencies percentiles (usec) runtime 10 (s) (95004 total samples) + 50.0th: 2492 (34901 samples) + 90.0th: 2500 (28388 samples) + * 99.0th: 2540 (7953 samples) + 99.9th: 3420 (803 samples) + min=2427, max=4975 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9456 (3 samples) + * 50.0th: 9488 (3 samples) + 90.0th: 9520 (5 samples) + min=9411, max=9533 +average rps: 9500 +message_threads 1 +worker_threads 24 +operations 10 +matrix_size 73 diff --git a/paper_results/schbench/linux_eevdf/256.txt b/paper_results/schbench/linux_eevdf/256.txt new file mode 100644 index 0000000..9a8b22b --- /dev/null +++ b/paper_results/schbench/linux_eevdf/256.txt @@ -0,0 +1,40 @@ +Wakeup Latencies percentiles (usec) runtime 10 (s) (101791 total samples) + 50.0th: 10960 (30607 samples) + 90.0th: 20512 (40654 samples) + * 99.0th: 26976 (9153 samples) + 99.9th: 78464 (914 samples) + min=1, max=344068 +Request Latencies percentiles (usec) runtime 10 (s) (101864 total samples) + 50.0th: 9392 (29600 samples) + 90.0th: 23200 (40393 samples) + * 99.0th: 34240 (9087 samples) + 99.9th: 132352 (915 samples) + min=2417, max=514774 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 10160 (3 samples) + * 50.0th: 10192 (3 samples) + 90.0th: 10224 (5 samples) + min=10004, max=10225 +current rps: 10214 +Wakeup Latencies percentiles (usec) runtime 10 (s) (101977 total samples) + 50.0th: 10960 (30613 samples) + 90.0th: 20512 (40786 samples) + * 99.0th: 26912 (9162 samples) + 99.9th: 78464 (918 samples) + min=1, max=344068 +Request Latencies percentiles (usec) runtime 10 (s) (102132 total samples) + 50.0th: 9392 (29717 samples) + 90.0th: 23200 (40456 samples) + * 99.0th: 34112 (9085 samples) + 99.9th: 129920 (918 samples) + min=2417, max=514774 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 10160 (3 samples) + * 50.0th: 10192 (3 samples) + 90.0th: 10224 (5 samples) + min=10004, max=10225 +average rps: 10213 +message_threads 1 +worker_threads 256 +operations 10 +matrix_size 73 diff --git a/paper_results/schbench/linux_eevdf/32.txt b/paper_results/schbench/linux_eevdf/32.txt new file mode 100644 index 0000000..2366296 --- /dev/null +++ b/paper_results/schbench/linux_eevdf/32.txt @@ -0,0 +1,40 @@ +Wakeup Latencies percentiles (usec) runtime 10 (s) (90720 total samples) + 50.0th: 16 (28087 samples) + 90.0th: 641 (35371 samples) + * 99.0th: 2308 (8212 samples) + 99.9th: 2356 (824 samples) + min=1, max=2954 +Request Latencies percentiles (usec) runtime 10 (s) (91103 total samples) + 50.0th: 2500 (30743 samples) + 90.0th: 4552 (32812 samples) + * 99.0th: 4840 (8482 samples) + 99.9th: 5768 (526 samples) + min=2429, max=9463 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9040 (3 samples) + * 50.0th: 9104 (3 samples) + 90.0th: 9136 (4 samples) + min=9034, max=9155 +current rps: 9093 +Wakeup Latencies percentiles (usec) runtime 10 (s) (90728 total samples) + 50.0th: 16 (28092 samples) + 90.0th: 641 (35372 samples) + * 99.0th: 2308 (8214 samples) + 99.9th: 2356 (824 samples) + min=1, max=2954 +Request Latencies percentiles (usec) runtime 10 (s) (91136 total samples) + 50.0th: 2500 (30750 samples) + 90.0th: 4552 (32831 samples) + * 99.0th: 4840 (8483 samples) + 99.9th: 5768 (526 samples) + min=2429, max=9463 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9040 (3 samples) + * 50.0th: 9104 (3 samples) + 90.0th: 9136 (4 samples) + min=9034, max=9155 +average rps: 9114 +message_threads 1 +worker_threads 32 +operations 10 +matrix_size 73 diff --git a/paper_results/schbench/linux_eevdf/40.txt b/paper_results/schbench/linux_eevdf/40.txt new file mode 100644 index 0000000..4fcd946 --- /dev/null +++ b/paper_results/schbench/linux_eevdf/40.txt @@ -0,0 +1,40 @@ +Wakeup Latencies percentiles (usec) runtime 10 (s) (94085 total samples) + 50.0th: 37 (27571 samples) + 90.0th: 1570 (37569 samples) + * 99.0th: 2332 (8609 samples) + 99.9th: 2356 (677 samples) + min=1, max=4686 +Request Latencies percentiles (usec) runtime 10 (s) (94254 total samples) + 50.0th: 2980 (23355 samples) + 90.0th: 4696 (38502 samples) + * 99.0th: 4840 (7670 samples) + 99.9th: 7176 (842 samples) + min=2431, max=22207 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9264 (3 samples) + * 50.0th: 9424 (4 samples) + 90.0th: 9488 (3 samples) + min=9272, max=9513 +current rps: 9491 +Wakeup Latencies percentiles (usec) runtime 10 (s) (94109 total samples) + 50.0th: 37 (27586 samples) + 90.0th: 1570 (37574 samples) + * 99.0th: 2332 (8609 samples) + 99.9th: 2356 (677 samples) + min=1, max=4686 +Request Latencies percentiles (usec) runtime 10 (s) (94303 total samples) + 50.0th: 2980 (23366 samples) + 90.0th: 4696 (38522 samples) + * 99.0th: 4840 (7677 samples) + 99.9th: 7176 (845 samples) + min=2431, max=22207 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9264 (3 samples) + * 50.0th: 9424 (4 samples) + 90.0th: 9488 (3 samples) + min=9272, max=9513 +average rps: 9430 +message_threads 1 +worker_threads 40 +operations 10 +matrix_size 73 diff --git a/paper_results/schbench/linux_eevdf/48.txt b/paper_results/schbench/linux_eevdf/48.txt new file mode 100644 index 0000000..fc6e93f --- /dev/null +++ b/paper_results/schbench/linux_eevdf/48.txt @@ -0,0 +1,40 @@ +Wakeup Latencies percentiles (usec) runtime 10 (s) (98667 total samples) + 50.0th: 515 (29255 samples) + 90.0th: 2124 (39616 samples) + * 99.0th: 2348 (8997 samples) + 99.9th: 2612 (584 samples) + min=1, max=4705 +Request Latencies percentiles (usec) runtime 10 (s) (98772 total samples) + 50.0th: 3036 (25514 samples) + 90.0th: 4760 (40075 samples) + * 99.0th: 5752 (8206 samples) + 99.9th: 7128 (889 samples) + min=2430, max=9473 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9840 (3 samples) + * 50.0th: 9872 (6 samples) + 90.0th: 9904 (2 samples) + min=9822, max=9893 +current rps: 9885 +Wakeup Latencies percentiles (usec) runtime 10 (s) (98683 total samples) + 50.0th: 515 (29255 samples) + 90.0th: 2124 (39626 samples) + * 99.0th: 2348 (9004 samples) + 99.9th: 2604 (582 samples) + min=1, max=4705 +Request Latencies percentiles (usec) runtime 10 (s) (98820 total samples) + 50.0th: 3036 (25530 samples) + 90.0th: 4760 (40097 samples) + * 99.0th: 5752 (8209 samples) + 99.9th: 7128 (889 samples) + min=2430, max=9473 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9840 (3 samples) + * 50.0th: 9872 (6 samples) + 90.0th: 9904 (2 samples) + min=9822, max=9893 +average rps: 9882 +message_threads 1 +worker_threads 48 +operations 10 +matrix_size 73 diff --git a/paper_results/schbench/linux_eevdf/56.txt b/paper_results/schbench/linux_eevdf/56.txt new file mode 100644 index 0000000..e64094c --- /dev/null +++ b/paper_results/schbench/linux_eevdf/56.txt @@ -0,0 +1,40 @@ +Wakeup Latencies percentiles (usec) runtime 10 (s) (100139 total samples) + 50.0th: 779 (29988 samples) + 90.0th: 2324 (40970 samples) + * 99.0th: 3836 (8083 samples) + 99.9th: 4632 (895 samples) + min=1, max=5090 +Request Latencies percentiles (usec) runtime 10 (s) (100243 total samples) + 50.0th: 3652 (28342 samples) + 90.0th: 4872 (40261 samples) + * 99.0th: 7192 (8790 samples) + 99.9th: 9456 (877 samples) + min=2428, max=12879 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9968 (3 samples) + * 50.0th: 10032 (7 samples) + 90.0th: 10032 (0 samples) + min=9959, max=10053 +current rps: 10041 +Wakeup Latencies percentiles (usec) runtime 10 (s) (100162 total samples) + 50.0th: 779 (29995 samples) + 90.0th: 2324 (40977 samples) + * 99.0th: 3836 (8088 samples) + 99.9th: 4632 (895 samples) + min=1, max=5090 +Request Latencies percentiles (usec) runtime 10 (s) (100299 total samples) + 50.0th: 3652 (28364 samples) + 90.0th: 4872 (40285 samples) + * 99.0th: 7192 (8797 samples) + 99.9th: 9456 (877 samples) + min=2428, max=12879 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9968 (3 samples) + * 50.0th: 10032 (7 samples) + 90.0th: 10032 (0 samples) + min=9959, max=10053 +average rps: 10030 +message_threads 1 +worker_threads 56 +operations 10 +matrix_size 73 diff --git a/paper_results/schbench/linux_eevdf/64.txt b/paper_results/schbench/linux_eevdf/64.txt new file mode 100644 index 0000000..2c3a3da --- /dev/null +++ b/paper_results/schbench/linux_eevdf/64.txt @@ -0,0 +1,40 @@ +Wakeup Latencies percentiles (usec) runtime 10 (s) (100453 total samples) + 50.0th: 965 (30058 samples) + 90.0th: 3132 (40159 samples) + * 99.0th: 4616 (9062 samples) + 99.9th: 4696 (883 samples) + min=1, max=6935 +Request Latencies percentiles (usec) runtime 10 (s) (100539 total samples) + 50.0th: 4408 (28151 samples) + 90.0th: 6040 (40142 samples) + * 99.0th: 8944 (9016 samples) + 99.9th: 11696 (902 samples) + min=2428, max=17890 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 10032 (5 samples) + * 50.0th: 10064 (6 samples) + 90.0th: 10064 (0 samples) + min=10014, max=10069 +current rps: 10069 +Wakeup Latencies percentiles (usec) runtime 10 (s) (100488 total samples) + 50.0th: 963 (30036 samples) + 90.0th: 3132 (40200 samples) + * 99.0th: 4616 (9065 samples) + 99.9th: 4696 (884 samples) + min=1, max=6935 +Request Latencies percentiles (usec) runtime 10 (s) (100606 total samples) + 50.0th: 4408 (28173 samples) + 90.0th: 6040 (40173 samples) + * 99.0th: 8944 (9023 samples) + 99.9th: 11696 (902 samples) + min=2428, max=17890 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 10032 (5 samples) + * 50.0th: 10064 (6 samples) + 90.0th: 10064 (0 samples) + min=10014, max=10069 +average rps: 10061 +message_threads 1 +worker_threads 64 +operations 10 +matrix_size 73 diff --git a/paper_results/schbench/linux_eevdf/72.txt b/paper_results/schbench/linux_eevdf/72.txt new file mode 100644 index 0000000..c5a0893 --- /dev/null +++ b/paper_results/schbench/linux_eevdf/72.txt @@ -0,0 +1,40 @@ +Wakeup Latencies percentiles (usec) runtime 10 (s) (100672 total samples) + 50.0th: 1206 (30134 samples) + 90.0th: 3660 (40320 samples) + * 99.0th: 4680 (9332 samples) + 99.9th: 5144 (577 samples) + min=1, max=7480 +Request Latencies percentiles (usec) runtime 10 (s) (100757 total samples) + 50.0th: 4664 (28947 samples) + 90.0th: 7128 (40421 samples) + * 99.0th: 10384 (8929 samples) + 99.9th: 13776 (895 samples) + min=2426, max=19075 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 10064 (5 samples) + * 50.0th: 10096 (4 samples) + 90.0th: 10128 (2 samples) + min=9812, max=10115 +current rps: 10084 +Wakeup Latencies percentiles (usec) runtime 10 (s) (100707 total samples) + 50.0th: 1206 (30138 samples) + 90.0th: 3660 (40336 samples) + * 99.0th: 4680 (9337 samples) + 99.9th: 5144 (578 samples) + min=1, max=7480 +Request Latencies percentiles (usec) runtime 10 (s) (100834 total samples) + 50.0th: 4664 (28968 samples) + 90.0th: 7128 (40456 samples) + * 99.0th: 10384 (8938 samples) + 99.9th: 13776 (896 samples) + min=2426, max=19075 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 10064 (5 samples) + * 50.0th: 10096 (4 samples) + 90.0th: 10128 (2 samples) + min=9812, max=10115 +average rps: 10083 +message_threads 1 +worker_threads 72 +operations 10 +matrix_size 73 diff --git a/paper_results/schbench/linux_eevdf/8.txt b/paper_results/schbench/linux_eevdf/8.txt new file mode 100644 index 0000000..3681f66 --- /dev/null +++ b/paper_results/schbench/linux_eevdf/8.txt @@ -0,0 +1,40 @@ +Wakeup Latencies percentiles (usec) runtime 10 (s) (32014 total samples) + 50.0th: 4 (0 samples) + 90.0th: 5 (8418 samples) + * 99.0th: 7 (1236 samples) + 99.9th: 17 (197 samples) + min=1, max=108 +Request Latencies percentiles (usec) runtime 10 (s) (32052 total samples) + 50.0th: 2484 (0 samples) + 90.0th: 2492 (15178 samples) + * 99.0th: 2500 (510 samples) + 99.9th: 2644 (196 samples) + min=2425, max=4383 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 3204 (10 samples) + * 50.0th: 3204 (0 samples) + 90.0th: 3204 (0 samples) + min=3198, max=3208 +current rps: 3207 +Wakeup Latencies percentiles (usec) runtime 10 (s) (32014 total samples) + 50.0th: 4 (0 samples) + 90.0th: 5 (8418 samples) + * 99.0th: 7 (1236 samples) + 99.9th: 17 (197 samples) + min=1, max=108 +Request Latencies percentiles (usec) runtime 10 (s) (32060 total samples) + 50.0th: 2484 (0 samples) + 90.0th: 2492 (15184 samples) + * 99.0th: 2500 (510 samples) + 99.9th: 2644 (197 samples) + min=2425, max=4383 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 3204 (10 samples) + * 50.0th: 3204 (0 samples) + 90.0th: 3204 (0 samples) + min=3198, max=3208 +average rps: 3206 +message_threads 1 +worker_threads 8 +operations 10 +matrix_size 73 diff --git a/paper_results/schbench/linux_eevdf/80.txt b/paper_results/schbench/linux_eevdf/80.txt new file mode 100644 index 0000000..c343cd0 --- /dev/null +++ b/paper_results/schbench/linux_eevdf/80.txt @@ -0,0 +1,40 @@ +Wakeup Latencies percentiles (usec) runtime 10 (s) (101282 total samples) + 50.0th: 1618 (30339 samples) + 90.0th: 4120 (40543 samples) + * 99.0th: 5976 (9086 samples) + 99.9th: 7000 (930 samples) + min=1, max=9910 +Request Latencies percentiles (usec) runtime 10 (s) (101345 total samples) + 50.0th: 4792 (26564 samples) + 90.0th: 7224 (40190 samples) + * 99.0th: 13392 (8977 samples) + 99.9th: 19424 (904 samples) + min=2429, max=28782 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 10096 (3 samples) + * 50.0th: 10128 (7 samples) + 90.0th: 10128 (0 samples) + min=10073, max=10144 +current rps: 10144 +Wakeup Latencies percentiles (usec) runtime 10 (s) (101315 total samples) + 50.0th: 1622 (30442 samples) + 90.0th: 4120 (40461 samples) + * 99.0th: 5976 (9089 samples) + 99.9th: 7000 (930 samples) + min=1, max=9910 +Request Latencies percentiles (usec) runtime 10 (s) (101431 total samples) + 50.0th: 4792 (26595 samples) + 90.0th: 7224 (40220 samples) + * 99.0th: 13392 (8990 samples) + 99.9th: 19424 (906 samples) + min=2429, max=28782 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 10096 (3 samples) + * 50.0th: 10128 (7 samples) + 90.0th: 10128 (0 samples) + min=10073, max=10144 +average rps: 10143 +message_threads 1 +worker_threads 80 +operations 10 +matrix_size 73 diff --git a/paper_results/schbench/linux_eevdf/88.txt b/paper_results/schbench/linux_eevdf/88.txt new file mode 100644 index 0000000..d70c601 --- /dev/null +++ b/paper_results/schbench/linux_eevdf/88.txt @@ -0,0 +1,40 @@ +Wakeup Latencies percentiles (usec) runtime 10 (s) (101291 total samples) + 50.0th: 1894 (30367 samples) + 90.0th: 4584 (40542 samples) + * 99.0th: 6904 (9038 samples) + 99.9th: 7192 (906 samples) + min=1, max=10504 +Request Latencies percentiles (usec) runtime 10 (s) (101353 total samples) + 50.0th: 4808 (29463 samples) + 90.0th: 8336 (38287 samples) + * 99.0th: 14704 (9080 samples) + 99.9th: 20192 (907 samples) + min=2429, max=32189 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 10096 (3 samples) + * 50.0th: 10128 (6 samples) + 90.0th: 10160 (2 samples) + min=10087, max=10149 +current rps: 10143 +Wakeup Latencies percentiles (usec) runtime 10 (s) (101340 total samples) + 50.0th: 1894 (30387 samples) + 90.0th: 4584 (40560 samples) + * 99.0th: 6904 (9044 samples) + 99.9th: 7192 (906 samples) + min=1, max=10504 +Request Latencies percentiles (usec) runtime 10 (s) (101447 total samples) + 50.0th: 4808 (29511 samples) + 90.0th: 8336 (38314 samples) + * 99.0th: 14704 (9086 samples) + 99.9th: 20192 (907 samples) + min=2429, max=32189 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 10096 (3 samples) + * 50.0th: 10128 (6 samples) + 90.0th: 10160 (2 samples) + min=10087, max=10149 +average rps: 10145 +message_threads 1 +worker_threads 88 +operations 10 +matrix_size 73 diff --git a/paper_results/schbench/linux_eevdf/96.txt b/paper_results/schbench/linux_eevdf/96.txt new file mode 100644 index 0000000..e5a3495 --- /dev/null +++ b/paper_results/schbench/linux_eevdf/96.txt @@ -0,0 +1,40 @@ +Wakeup Latencies percentiles (usec) runtime 10 (s) (101479 total samples) + 50.0th: 2076 (30579 samples) + 90.0th: 4824 (40491 samples) + * 99.0th: 7000 (9154 samples) + 99.9th: 9040 (853 samples) + min=1, max=12037 +Request Latencies percentiles (usec) runtime 10 (s) (101532 total samples) + 50.0th: 4824 (31906 samples) + 90.0th: 9456 (39002 samples) + * 99.0th: 15408 (8568 samples) + 99.9th: 21024 (913 samples) + min=2430, max=34837 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 10128 (4 samples) + * 50.0th: 10160 (7 samples) + 90.0th: 10160 (0 samples) + min=10001, max=10175 +current rps: 10175 +Wakeup Latencies percentiles (usec) runtime 10 (s) (101530 total samples) + 50.0th: 2076 (30529 samples) + 90.0th: 4824 (40515 samples) + * 99.0th: 7000 (9172 samples) + 99.9th: 9040 (857 samples) + min=1, max=12037 +Request Latencies percentiles (usec) runtime 10 (s) (101633 total samples) + 50.0th: 4824 (31943 samples) + 90.0th: 9456 (39040 samples) + * 99.0th: 15408 (8580 samples) + 99.9th: 21024 (916 samples) + min=2430, max=34837 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 10128 (4 samples) + * 50.0th: 10160 (7 samples) + 90.0th: 10160 (0 samples) + min=10001, max=10175 +average rps: 10163 +message_threads 1 +worker_threads 96 +operations 10 +matrix_size 73 diff --git a/paper_results/schbench/linux_eevdf/all.csv b/paper_results/schbench/linux_eevdf/all.csv new file mode 100644 index 0000000..55a6e08 --- /dev/null +++ b/paper_results/schbench/linux_eevdf/all.csv @@ -0,0 +1,13 @@ +cores,lat99,rps50 +8,7,3204,2500 +16,8,6408,2508 +24,21,9488,2540 +32,2308,9104,4840 +40,2332,9424,4840 +48,2348,9872,5752 +56,3836,10032,7192 +64,4616,10064,8944 +72,4680,10096,10384 +80,5976,10128,13392 +88,6904,10128,14704 +96,7000,10160,15408 diff --git a/paper_results/schbench/skyloft_cfs50us/16.txt b/paper_results/schbench/skyloft_cfs50us/16.txt index 3f67c96..e8b6ec0 100644 --- a/paper_results/schbench/skyloft_cfs50us/16.txt +++ b/paper_results/schbench/skyloft_cfs50us/16.txt @@ -1,18 +1,55 @@ -Wakeup Latencies percentiles (usec) runtime 1 (s) (6237 total samples) - 50.0th: 2 (2978 samples) - 90.0th: 2 (0 samples) - * 99.0th: 3 (232 samples) - 99.9th: 16 (55 samples) - min=1, max=24 -Request Latencies percentiles (usec) runtime 1 (s) (6258 total samples) - 50.0th: 2516 (0 samples) - 90.0th: 2644 (2327 samples) - * 99.0th: 2644 (0 samples) - 99.9th: 2652 (4 samples) - min=2511, max=2747 -RPS percentiles (requests) runtime 1 (s) (2 total samples) - 20.0th: 0 (1 samples) - * 50.0th: 0 (0 samples) - 90.0th: 6248 (1 samples) - min=6241, max=6241 -average rps: 6258 +Wakeup Latencies percentiles (usec) runtime 5 (s) (25788 total samples) + 50.0th: 2 (12115 samples) + 90.0th: 2 (0 samples) + * 99.0th: 3 (803 samples) + 99.9th: 8 (217 samples) + min=1, max=20 +Request Latencies percentiles (usec) runtime 5 (s) (25868 total samples) + 50.0th: 2636 (2218 samples) + 90.0th: 4168 (12350 samples) + * 99.0th: 4168 (0 samples) + 99.9th: 4168 (0 samples) + min=2511, max=4187 +RPS percentiles (requests) runtime 5 (s) (6 total samples) + 20.0th: 4600 (2 samples) + * 50.0th: 4648 (1 samples) + 90.0th: 6248 (3 samples) + min=4607, max=6248 +current rps: 4743 +Wakeup Latencies percentiles (usec) runtime 10 (s) (52582 total samples) + 50.0th: 1 (0 samples) + 90.0th: 2 (23921 samples) + * 99.0th: 3 (1555 samples) + 99.9th: 7 (476 samples) + min=1, max=20 +Request Latencies percentiles (usec) runtime 10 (s) (52719 total samples) + 50.0th: 2636 (4933 samples) + 90.0th: 4168 (24132 samples) + * 99.0th: 4168 (0 samples) + 99.9th: 4168 (0 samples) + min=2511, max=4187 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 4648 (3 samples) + * 50.0th: 5464 (3 samples) + 90.0th: 5624 (4 samples) + min=4607, max=6248 +current rps: 5460 +Wakeup Latencies percentiles (usec) runtime 10 (s) (52582 total samples) + 50.0th: 1 (0 samples) + 90.0th: 2 (23921 samples) + * 99.0th: 3 (1555 samples) + 99.9th: 7 (476 samples) + min=1, max=20 +Request Latencies percentiles (usec) runtime 10 (s) (52735 total samples) + 50.0th: 2636 (4934 samples) + 90.0th: 4168 (24141 samples) + * 99.0th: 4168 (0 samples) + 99.9th: 4168 (0 samples) + min=2511, max=4187 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 4648 (3 samples) + * 50.0th: 5464 (3 samples) + 90.0th: 5624 (4 samples) + min=4607, max=6248 +average rps: 5274 +timeout: the monitored command dumped core diff --git a/paper_results/schbench/skyloft_cfs50us/24.txt b/paper_results/schbench/skyloft_cfs50us/24.txt index d6b700b..7ae876d 100644 --- a/paper_results/schbench/skyloft_cfs50us/24.txt +++ b/paper_results/schbench/skyloft_cfs50us/24.txt @@ -1,18 +1,55 @@ -Wakeup Latencies percentiles (usec) runtime 1 (s) (9092 total samples) - 50.0th: 2 (4476 samples) - 90.0th: 2 (0 samples) - * 99.0th: 4 (318 samples) - 99.9th: 21 (31 samples) - min=1, max=33 -Request Latencies percentiles (usec) runtime 1 (s) (9344 total samples) - 50.0th: 2516 (0 samples) - 90.0th: 2644 (4093 samples) - * 99.0th: 2676 (404 samples) - 99.9th: 2764 (17 samples) - min=2511, max=3312 -RPS percentiles (requests) runtime 1 (s) (2 total samples) - 20.0th: 0 (1 samples) - * 50.0th: 0 (0 samples) - 90.0th: 9296 (1 samples) - min=9294, max=9294 -average rps: 9344 \ No newline at end of file +Wakeup Latencies percentiles (usec) runtime 5 (s) (37204 total samples) + 50.0th: 2 (18182 samples) + 90.0th: 2 (0 samples) + * 99.0th: 5 (2704 samples) + 99.9th: 7 (194 samples) + min=1, max=33 +Request Latencies percentiles (usec) runtime 5 (s) (38453 total samples) + 50.0th: 2644 (8756 samples) + 90.0th: 4168 (15186 samples) + * 99.0th: 4168 (0 samples) + 99.9th: 4168 (0 samples) + min=2512, max=4190 +RPS percentiles (requests) runtime 5 (s) (6 total samples) + 20.0th: 6344 (2 samples) + * 50.0th: 6472 (1 samples) + 90.0th: 9168 (3 samples) + min=6338, max=9161 +current rps: 8308 +Wakeup Latencies percentiles (usec) runtime 10 (s) (77180 total samples) + 50.0th: 2 (37714 samples) + 90.0th: 2 (0 samples) + * 99.0th: 4 (3790 samples) + 99.9th: 6 (524 samples) + min=1, max=33 +Request Latencies percentiles (usec) runtime 10 (s) (79640 total samples) + 50.0th: 2588 (5144 samples) + 90.0th: 4168 (39711 samples) + * 99.0th: 4168 (0 samples) + 99.9th: 4168 (0 samples) + min=2512, max=4227 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 6472 (3 samples) + * 50.0th: 8136 (3 samples) + 90.0th: 8432 (4 samples) + min=6338, max=9161 +current rps: 8447 +Wakeup Latencies percentiles (usec) runtime 10 (s) (77181 total samples) + 50.0th: 2 (37715 samples) + 90.0th: 2 (0 samples) + * 99.0th: 4 (3790 samples) + 99.9th: 6 (524 samples) + min=1, max=33 +Request Latencies percentiles (usec) runtime 10 (s) (79665 total samples) + 50.0th: 2588 (5146 samples) + 90.0th: 4168 (39725 samples) + * 99.0th: 4168 (0 samples) + 99.9th: 4168 (0 samples) + min=2512, max=4227 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 6472 (3 samples) + * 50.0th: 8136 (3 samples) + 90.0th: 8432 (4 samples) + min=6338, max=9161 +average rps: 7967 +timeout: the monitored command dumped core diff --git a/paper_results/schbench/skyloft_cfs50us/32.txt b/paper_results/schbench/skyloft_cfs50us/32.txt index ac27b78..5b03b9a 100644 --- a/paper_results/schbench/skyloft_cfs50us/32.txt +++ b/paper_results/schbench/skyloft_cfs50us/32.txt @@ -1,18 +1,55 @@ -Wakeup Latencies percentiles (usec) runtime 1 (s) (9333 total samples) - 50.0th: 2 (2991 samples) - 90.0th: 28 (3193 samples) - * 99.0th: 34 (661 samples) - 99.9th: 53 (36 samples) - min=1, max=61 -Request Latencies percentiles (usec) runtime 1 (s) (9590 total samples) - 50.0th: 2644 (1738 samples) - 90.0th: 4808 (3712 samples) - * 99.0th: 4808 (0 samples) - 99.9th: 4936 (50 samples) - min=2511, max=5239 -RPS percentiles (requests) runtime 1 (s) (2 total samples) - 20.0th: 0 (1 samples) - * 50.0th: 0 (0 samples) - 90.0th: 9520 (1 samples) - min=9530, max=9530 -average rps: 9590 \ No newline at end of file +Wakeup Latencies percentiles (usec) runtime 5 (s) (43912 total samples) + 50.0th: 2 (12286 samples) + 90.0th: 28 (13109 samples) + * 99.0th: 34 (4140 samples) + 99.9th: 35 (97 samples) + min=1, max=75 +Request Latencies percentiles (usec) runtime 5 (s) (45048 total samples) + 50.0th: 2644 (4958 samples) + 90.0th: 4808 (21801 samples) + * 99.0th: 5048 (688 samples) + 99.9th: 5048 (0 samples) + min=2511, max=5472 +RPS percentiles (requests) runtime 5 (s) (6 total samples) + 20.0th: 8656 (2 samples) + * 50.0th: 8784 (1 samples) + 90.0th: 9520 (3 samples) + min=8668, max=9529 +current rps: 8924 +Wakeup Latencies percentiles (usec) runtime 10 (s) (86510 total samples) + 50.0th: 2 (24104 samples) + 90.0th: 28 (26253 samples) + * 99.0th: 34 (8269 samples) + 99.9th: 35 (201 samples) + min=1, max=75 +Request Latencies percentiles (usec) runtime 10 (s) (88915 total samples) + 50.0th: 2676 (12827 samples) + 90.0th: 4808 (43179 samples) + * 99.0th: 5016 (198 samples) + 99.9th: 5048 (844 samples) + min=2510, max=5472 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 8624 (3 samples) + * 50.0th: 8784 (3 samples) + 90.0th: 9072 (4 samples) + min=8498, max=9529 +current rps: 8798 +Wakeup Latencies percentiles (usec) runtime 10 (s) (86511 total samples) + 50.0th: 2 (24104 samples) + 90.0th: 28 (26253 samples) + * 99.0th: 34 (8270 samples) + 99.9th: 35 (201 samples) + min=1, max=75 +Request Latencies percentiles (usec) runtime 10 (s) (88948 total samples) + 50.0th: 2676 (12831 samples) + 90.0th: 4808 (43201 samples) + * 99.0th: 5016 (198 samples) + 99.9th: 5048 (844 samples) + min=2510, max=5472 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 8624 (3 samples) + * 50.0th: 8784 (3 samples) + 90.0th: 9072 (4 samples) + min=8498, max=9529 +average rps: 8895 +timeout: the monitored command dumped core diff --git a/paper_results/schbench/skyloft_cfs50us/4.txt b/paper_results/schbench/skyloft_cfs50us/4.txt deleted file mode 100644 index 4d801c6..0000000 --- a/paper_results/schbench/skyloft_cfs50us/4.txt +++ /dev/null @@ -1,18 +0,0 @@ -Wakeup Latencies percentiles (usec) runtime 10 (s) (15076 total samples) - 50.0th: 1 (0 samples) - 90.0th: 2 (5753 samples) - * 99.0th: 2 (0 samples) - 99.9th: 3 (48 samples) - min=1, max=6 -Request Latencies percentiles (usec) runtime 10 (s) (15089 total samples) - 50.0th: 2660 (0 samples) - 90.0th: 2660 (0 samples) - * 99.0th: 2668 (242 samples) - 99.9th: 2668 (0 samples) - min=2525, max=2722 -RPS percentiles (requests) runtime 10 (s) (11 total samples) - 20.0th: 1510 (11 samples) - * 50.0th: 1510 (0 samples) - 90.0th: 1510 (0 samples) - min=1506, max=1511 -average rps: 1509 diff --git a/paper_results/schbench/skyloft_cfs50us/40.txt b/paper_results/schbench/skyloft_cfs50us/40.txt index ecca6fb..76d9b5d 100644 --- a/paper_results/schbench/skyloft_cfs50us/40.txt +++ b/paper_results/schbench/skyloft_cfs50us/40.txt @@ -1,18 +1,55 @@ -Wakeup Latencies percentiles (usec) runtime 1 (s) (9444 total samples) - 50.0th: 21 (1925 samples) - 90.0th: 31 (3857 samples) - * 99.0th: 34 (775 samples) - 99.9th: 51 (68 samples) - min=1, max=71 -Request Latencies percentiles (usec) runtime 1 (s) (9737 total samples) - 50.0th: 4808 (6786 samples) - 90.0th: 4808 (0 samples) - * 99.0th: 4856 (316 samples) - 99.9th: 5128 (37 samples) - min=2512, max=5270 -RPS percentiles (requests) runtime 1 (s) (2 total samples) - 20.0th: 0 (1 samples) - * 50.0th: 0 (0 samples) - 90.0th: 9648 (1 samples) - min=9660, max=9660 -average rps: 9737 \ No newline at end of file +Wakeup Latencies percentiles (usec) runtime 5 (s) (45170 total samples) + 50.0th: 23 (11183 samples) + 90.0th: 31 (18977 samples) + * 99.0th: 34 (2796 samples) + 99.9th: 36 (231 samples) + min=1, max=61 +Request Latencies percentiles (usec) runtime 5 (s) (46209 total samples) + 50.0th: 4792 (11267 samples) + 90.0th: 4808 (21957 samples) + * 99.0th: 4808 (0 samples) + 99.9th: 5032 (338 samples) + min=2512, max=6105 +RPS percentiles (requests) runtime 5 (s) (6 total samples) + 20.0th: 8976 (3 samples) + * 50.0th: 8976 (0 samples) + 90.0th: 9680 (3 samples) + min=8968, max=9683 +current rps: 9248 +Wakeup Latencies percentiles (usec) runtime 10 (s) (91054 total samples) + 50.0th: 23 (21930 samples) + 90.0th: 31 (38174 samples) + * 99.0th: 34 (5770 samples) + 99.9th: 36 (474 samples) + min=1, max=61 +Request Latencies percentiles (usec) runtime 10 (s) (93329 total samples) + 50.0th: 4808 (73056 samples) + 90.0th: 4808 (0 samples) + * 99.0th: 4808 (0 samples) + 99.9th: 4968 (724 samples) + min=2512, max=6105 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 8976 (3 samples) + * 50.0th: 9264 (3 samples) + 90.0th: 9552 (4 samples) + min=8968, max=9683 +current rps: 9152 +Wakeup Latencies percentiles (usec) runtime 10 (s) (91056 total samples) + 50.0th: 23 (21930 samples) + 90.0th: 31 (38175 samples) + * 99.0th: 34 (5770 samples) + 99.9th: 36 (474 samples) + min=1, max=61 +Request Latencies percentiles (usec) runtime 10 (s) (93371 total samples) + 50.0th: 4808 (73095 samples) + 90.0th: 4808 (0 samples) + * 99.0th: 4808 (0 samples) + 99.9th: 4968 (724 samples) + min=2512, max=6105 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 8976 (3 samples) + * 50.0th: 9264 (3 samples) + 90.0th: 9552 (4 samples) + min=8968, max=9683 +average rps: 9337 +timeout: the monitored command dumped core diff --git a/paper_results/schbench/skyloft_cfs50us/48.txt b/paper_results/schbench/skyloft_cfs50us/48.txt index 31d822e..50795fa 100644 --- a/paper_results/schbench/skyloft_cfs50us/48.txt +++ b/paper_results/schbench/skyloft_cfs50us/48.txt @@ -1,18 +1,55 @@ -Wakeup Latencies percentiles (usec) runtime 1 (s) (9763 total samples) - 50.0th: 23 (2887 samples) - 90.0th: 30 (3867 samples) - * 99.0th: 35 (890 samples) - 99.9th: 71 (39 samples) - min=1, max=78 -Request Latencies percentiles (usec) runtime 1 (s) (9970 total samples) - 50.0th: 4808 (0 samples) - 90.0th: 4808 (0 samples) - * 99.0th: 5000 (677 samples) - 99.9th: 6008 (74 samples) - min=2602, max=7962 -RPS percentiles (requests) runtime 1 (s) (2 total samples) - 20.0th: 0 (1 samples) - * 50.0th: 0 (0 samples) - 90.0th: 9904 (1 samples) - min=9891, max=9891 -average rps: 9970 \ No newline at end of file +Wakeup Latencies percentiles (usec) runtime 5 (s) (48827 total samples) + 50.0th: 23 (13107 samples) + 90.0th: 30 (19311 samples) + * 99.0th: 34 (3424 samples) + 99.9th: 40 (245 samples) + min=1, max=82 +Request Latencies percentiles (usec) runtime 5 (s) (49546 total samples) + 50.0th: 4808 (27727 samples) + 90.0th: 4808 (0 samples) + * 99.0th: 5048 (1977 samples) + 99.9th: 8104 (476 samples) + min=2598, max=8169 +RPS percentiles (requests) runtime 5 (s) (6 total samples) + 20.0th: 9808 (2 samples) + * 50.0th: 9904 (3 samples) + 90.0th: 9936 (1 samples) + min=9813, max=9922 +current rps: 9917 +Wakeup Latencies percentiles (usec) runtime 10 (s) (97223 total samples) + 50.0th: 23 (26167 samples) + 90.0th: 30 (38460 samples) + * 99.0th: 34 (6921 samples) + 99.9th: 36 (393 samples) + min=1, max=82 +Request Latencies percentiles (usec) runtime 10 (s) (98615 total samples) + 50.0th: 4808 (53728 samples) + 90.0th: 4808 (0 samples) + * 99.0th: 8104 (4332 samples) + 99.9th: 8368 (272 samples) + min=2513, max=8657 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9744 (3 samples) + * 50.0th: 9904 (5 samples) + 90.0th: 9936 (3 samples) + min=9592, max=9924 +current rps: 9924 +Wakeup Latencies percentiles (usec) runtime 10 (s) (97227 total samples) + 50.0th: 23 (26167 samples) + 90.0th: 30 (38461 samples) + * 99.0th: 34 (6922 samples) + 99.9th: 36 (393 samples) + min=1, max=82 +Request Latencies percentiles (usec) runtime 10 (s) (98667 total samples) + 50.0th: 4808 (53752 samples) + 90.0th: 4808 (0 samples) + * 99.0th: 8104 (4334 samples) + 99.9th: 8368 (272 samples) + min=2513, max=8657 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9744 (3 samples) + * 50.0th: 9904 (5 samples) + 90.0th: 9936 (3 samples) + min=9592, max=9924 +average rps: 9867 +timeout: the monitored command dumped core diff --git a/paper_results/schbench/skyloft_cfs50us/56.txt b/paper_results/schbench/skyloft_cfs50us/56.txt index f358591..7a2dae7 100644 --- a/paper_results/schbench/skyloft_cfs50us/56.txt +++ b/paper_results/schbench/skyloft_cfs50us/56.txt @@ -1,18 +1,55 @@ -Wakeup Latencies percentiles (usec) runtime 1 (s) (9719 total samples) - 50.0th: 23 (3181 samples) - 90.0th: 34 (3703 samples) - * 99.0th: 79 (805 samples) - 99.9th: 105 (71 samples) - min=1, max=113 -Request Latencies percentiles (usec) runtime 1 (s) (9918 total samples) - 50.0th: 4808 (0 samples) - 90.0th: 9680 (2385 samples) - * 99.0th: 9776 (843 samples) - 99.9th: 10096 (43 samples) - min=2512, max=16424 -RPS percentiles (requests) runtime 1 (s) (2 total samples) - 20.0th: 0 (1 samples) - * 50.0th: 0 (0 samples) - 90.0th: 9840 (1 samples) - min=9836, max=9836 -average rps: 9918 \ No newline at end of file +Wakeup Latencies percentiles (usec) runtime 5 (s) (47260 total samples) + 50.0th: 23 (15241 samples) + 90.0th: 34 (17903 samples) + * 99.0th: 81 (4278 samples) + 99.9th: 85 (216 samples) + min=1, max=103 +Request Latencies percentiles (usec) runtime 5 (s) (47886 total samples) + 50.0th: 4808 (18732 samples) + 90.0th: 9712 (9968 samples) + * 99.0th: 16368 (3466 samples) + 99.9th: 16416 (388 samples) + min=2512, max=16447 +RPS percentiles (requests) runtime 5 (s) (6 total samples) + 20.0th: 9232 (2 samples) + * 50.0th: 9328 (1 samples) + 90.0th: 9872 (3 samples) + min=9245, max=9868 +current rps: 9319 +Wakeup Latencies percentiles (usec) runtime 10 (s) (95931 total samples) + 50.0th: 23 (30826 samples) + 90.0th: 34 (36217 samples) + * 99.0th: 81 (8994 samples) + 99.9th: 85 (446 samples) + min=1, max=103 +Request Latencies percentiles (usec) runtime 10 (s) (97304 total samples) + 50.0th: 4808 (36149 samples) + 90.0th: 9680 (18952 samples) + * 99.0th: 12368 (8626 samples) + 99.9th: 16416 (882 samples) + min=2511, max=16447 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9328 (3 samples) + * 50.0th: 9840 (3 samples) + 90.0th: 9872 (4 samples) + min=9245, max=9890 +current rps: 9890 +Wakeup Latencies percentiles (usec) runtime 10 (s) (95936 total samples) + 50.0th: 23 (30827 samples) + 90.0th: 34 (36220 samples) + * 99.0th: 81 (8995 samples) + 99.9th: 85 (446 samples) + min=1, max=103 +Request Latencies percentiles (usec) runtime 10 (s) (97365 total samples) + 50.0th: 4808 (36163 samples) + 90.0th: 9680 (18974 samples) + * 99.0th: 12368 (8631 samples) + 99.9th: 16416 (882 samples) + min=2511, max=16447 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9328 (3 samples) + * 50.0th: 9840 (3 samples) + 90.0th: 9872 (4 samples) + min=9245, max=9890 +average rps: 9737 +timeout: the monitored command dumped core diff --git a/paper_results/schbench/skyloft_cfs50us/64.txt b/paper_results/schbench/skyloft_cfs50us/64.txt index c5491f1..00b98ab 100644 --- a/paper_results/schbench/skyloft_cfs50us/64.txt +++ b/paper_results/schbench/skyloft_cfs50us/64.txt @@ -1,18 +1,55 @@ -Wakeup Latencies percentiles (usec) runtime 1 (s) (9704 total samples) - 50.0th: 20 (2900 samples) - 90.0th: 71 (3999 samples) - * 99.0th: 81 (746 samples) - 99.9th: 124 (88 samples) - min=1, max=132 -Request Latencies percentiles (usec) runtime 1 (s) (9896 total samples) - 50.0th: 7224 (1422 samples) - 90.0th: 9744 (4057 samples) - * 99.0th: 9776 (140 samples) - 99.9th: 10160 (76 samples) - min=2512, max=10266 -RPS percentiles (requests) runtime 1 (s) (2 total samples) - 20.0th: 0 (1 samples) - * 50.0th: 0 (0 samples) - 90.0th: 9808 (1 samples) - min=9799, max=9799 -average rps: 9896 \ No newline at end of file +Wakeup Latencies percentiles (usec) runtime 5 (s) (47838 total samples) + 50.0th: 20 (13984 samples) + 90.0th: 63 (19102 samples) + * 99.0th: 83 (4591 samples) + 99.9th: 85 (134 samples) + min=1, max=137 +Request Latencies percentiles (usec) runtime 5 (s) (48612 total samples) + 50.0th: 7224 (9271 samples) + 90.0th: 9744 (19679 samples) + * 99.0th: 12368 (2040 samples) + 99.9th: 16416 (425 samples) + min=2511, max=16477 +RPS percentiles (requests) runtime 5 (s) (6 total samples) + 20.0th: 9616 (2 samples) + * 50.0th: 9680 (1 samples) + 90.0th: 9808 (3 samples) + min=9624, max=9797 +current rps: 9672 +Wakeup Latencies percentiles (usec) runtime 10 (s) (95816 total samples) + 50.0th: 20 (28245 samples) + 90.0th: 64 (38512 samples) + * 99.0th: 83 (8770 samples) + 99.9th: 84 (238 samples) + min=1, max=137 +Request Latencies percentiles (usec) runtime 10 (s) (97390 total samples) + 50.0th: 7224 (18824 samples) + 90.0th: 9744 (39273 samples) + * 99.0th: 12240 (3539 samples) + 99.9th: 16416 (947 samples) + min=2510, max=16477 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9680 (6 samples) + * 50.0th: 9680 (0 samples) + 90.0th: 9808 (4 samples) + min=9624, max=9853 +current rps: 9687 +Wakeup Latencies percentiles (usec) runtime 10 (s) (95823 total samples) + 50.0th: 20 (28245 samples) + 90.0th: 64 (38518 samples) + * 99.0th: 83 (8770 samples) + 99.9th: 84 (238 samples) + min=1, max=137 +Request Latencies percentiles (usec) runtime 10 (s) (97461 total samples) + 50.0th: 7224 (18839 samples) + 90.0th: 9744 (39312 samples) + * 99.0th: 12240 (3541 samples) + 99.9th: 16416 (949 samples) + min=2510, max=16477 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9680 (6 samples) + * 50.0th: 9680 (0 samples) + 90.0th: 9808 (4 samples) + min=9624, max=9853 +average rps: 9746 +timeout: the monitored command dumped core diff --git a/paper_results/schbench/skyloft_cfs50us/72.txt b/paper_results/schbench/skyloft_cfs50us/72.txt index 10137da..ebb3531 100644 --- a/paper_results/schbench/skyloft_cfs50us/72.txt +++ b/paper_results/schbench/skyloft_cfs50us/72.txt @@ -1,18 +1,55 @@ -Wakeup Latencies percentiles (usec) runtime 1 (s) (9733 total samples) - 50.0th: 15 (2542 samples) - 90.0th: 72 (3831 samples) - * 99.0th: 83 (786 samples) - 99.9th: 136 (81 samples) - min=1, max=144 -Request Latencies percentiles (usec) runtime 1 (s) (9855 total samples) - 50.0th: 7384 (3132 samples) - 90.0th: 9744 (4349 samples) - * 99.0th: 9872 (305 samples) - 99.9th: 10288 (86 samples) - min=2511, max=13044 -RPS percentiles (requests) runtime 1 (s) (2 total samples) - 20.0th: 0 (1 samples) - * 50.0th: 0 (0 samples) - 90.0th: 9776 (1 samples) - min=9760, max=9760 -average rps: 9855 \ No newline at end of file +Wakeup Latencies percentiles (usec) runtime 5 (s) (47842 total samples) + 50.0th: 16 (11787 samples) + 90.0th: 69 (18895 samples) + * 99.0th: 82 (4159 samples) + 99.9th: 86 (283 samples) + min=1, max=138 +Request Latencies percentiles (usec) runtime 5 (s) (48319 total samples) + 50.0th: 7400 (16060 samples) + 90.0th: 9744 (18256 samples) + * 99.0th: 12368 (3726 samples) + 99.9th: 16416 (457 samples) + min=2511, max=16416 +RPS percentiles (requests) runtime 5 (s) (6 total samples) + 20.0th: 9456 (2 samples) + * 50.0th: 9488 (1 samples) + 90.0th: 9776 (3 samples) + min=9466, max=9790 +current rps: 9466 +Wakeup Latencies percentiles (usec) runtime 10 (s) (96277 total samples) + 50.0th: 16 (23393 samples) + 90.0th: 69 (38437 samples) + * 99.0th: 82 (8289 samples) + 99.9th: 85 (519 samples) + min=1, max=138 +Request Latencies percentiles (usec) runtime 10 (s) (97282 total samples) + 50.0th: 7400 (32837 samples) + 90.0th: 9744 (37361 samples) + * 99.0th: 10256 (6672 samples) + 99.9th: 16368 (791 samples) + min=2511, max=16416 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9488 (3 samples) + * 50.0th: 9776 (7 samples) + 90.0th: 9776 (0 samples) + min=9466, max=9794 +current rps: 9782 +Wakeup Latencies percentiles (usec) runtime 10 (s) (96290 total samples) + 50.0th: 16 (23396 samples) + 90.0th: 69 (38443 samples) + * 99.0th: 82 (8290 samples) + 99.9th: 85 (519 samples) + min=1, max=138 +Request Latencies percentiles (usec) runtime 10 (s) (97367 total samples) + 50.0th: 7400 (32876 samples) + 90.0th: 9744 (37394 samples) + * 99.0th: 10256 (6679 samples) + 99.9th: 16368 (791 samples) + min=2511, max=16416 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9488 (3 samples) + * 50.0th: 9776 (7 samples) + 90.0th: 9776 (0 samples) + min=9466, max=9794 +average rps: 9737 +timeout: the monitored command dumped core diff --git a/paper_results/schbench/skyloft_cfs50us/8.txt b/paper_results/schbench/skyloft_cfs50us/8.txt index 440e8c6..ac0f8b6 100644 --- a/paper_results/schbench/skyloft_cfs50us/8.txt +++ b/paper_results/schbench/skyloft_cfs50us/8.txt @@ -1,18 +1,55 @@ -Wakeup Latencies percentiles (usec) runtime 1 (s) (3076 total samples) - 50.0th: 1 (0 samples) - 90.0th: 2 (1267 samples) - * 99.0th: 2 (0 samples) - 99.9th: 7 (15 samples) - min=1, max=7 -Request Latencies percentiles (usec) runtime 1 (s) (3076 total samples) - 50.0th: 2636 (851 samples) - 90.0th: 2644 (1376 samples) - * 99.0th: 2644 (0 samples) - 99.9th: 2644 (0 samples) - min=2511, max=2714 -RPS percentiles (requests) runtime 1 (s) (2 total samples) - 20.0th: 0 (1 samples) - * 50.0th: 0 (0 samples) - 90.0th: 3068 (1 samples) - min=3068, max=3068 -average rps: 3076 \ No newline at end of file +Wakeup Latencies percentiles (usec) runtime 5 (s) (12992 total samples) + 50.0th: 1 (0 samples) + 90.0th: 2 (5270 samples) + * 99.0th: 3 (249 samples) + 99.9th: 4 (10 samples) + min=1, max=9 +Request Latencies percentiles (usec) runtime 5 (s) (12997 total samples) + 50.0th: 2636 (3211 samples) + 90.0th: 4168 (6362 samples) + * 99.0th: 4168 (0 samples) + 99.9th: 4168 (0 samples) + min=2511, max=4173 +RPS percentiles (requests) runtime 5 (s) (6 total samples) + 20.0th: 2220 (2 samples) + * 50.0th: 2340 (1 samples) + 90.0th: 2860 (3 samples) + min=2216, max=2860 +current rps: 2790 +Wakeup Latencies percentiles (usec) runtime 10 (s) (26593 total samples) + 50.0th: 1 (0 samples) + 90.0th: 2 (10716 samples) + * 99.0th: 3 (481 samples) + 99.9th: 3 (0 samples) + min=1, max=9 +Request Latencies percentiles (usec) runtime 10 (s) (26609 total samples) + 50.0th: 2636 (7421 samples) + 90.0th: 4168 (12685 samples) + * 99.0th: 4168 (0 samples) + 99.9th: 4168 (0 samples) + min=2511, max=4177 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 2340 (3 samples) + * 50.0th: 2764 (3 samples) + 90.0th: 2796 (4 samples) + min=2216, max=2860 +current rps: 2632 +Wakeup Latencies percentiles (usec) runtime 10 (s) (26593 total samples) + 50.0th: 1 (0 samples) + 90.0th: 2 (10716 samples) + * 99.0th: 3 (481 samples) + 99.9th: 3 (0 samples) + min=1, max=9 +Request Latencies percentiles (usec) runtime 10 (s) (26617 total samples) + 50.0th: 2636 (7424 samples) + 90.0th: 4168 (12690 samples) + * 99.0th: 4168 (0 samples) + 99.9th: 4168 (0 samples) + min=2511, max=4177 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 2340 (3 samples) + * 50.0th: 2764 (3 samples) + 90.0th: 2796 (4 samples) + min=2216, max=2860 +average rps: 2662 +timeout: the monitored command dumped core diff --git a/paper_results/schbench/skyloft_cfs50us/80.txt b/paper_results/schbench/skyloft_cfs50us/80.txt index a260981..4beff10 100644 --- a/paper_results/schbench/skyloft_cfs50us/80.txt +++ b/paper_results/schbench/skyloft_cfs50us/80.txt @@ -1,18 +1,55 @@ -Wakeup Latencies percentiles (usec) runtime 1 (s) (9718 total samples) - 50.0th: 17 (2792 samples) - 90.0th: 77 (3716 samples) - * 99.0th: 116 (751 samples) - 99.9th: 149 (76 samples) - min=1, max=179 -Request Latencies percentiles (usec) runtime 1 (s) (9857 total samples) - 50.0th: 9648 (3377 samples) - 90.0th: 12176 (3914 samples) - * 99.0th: 12240 (520 samples) - 99.9th: 12688 (58 samples) - min=2511, max=12818 -RPS percentiles (requests) runtime 1 (s) (2 total samples) - 20.0th: 0 (1 samples) - * 50.0th: 0 (0 samples) - 90.0th: 9744 (1 samples) - min=9740, max=9740 -average rps: 9857 \ No newline at end of file +Wakeup Latencies percentiles (usec) runtime 5 (s) (46721 total samples) + 50.0th: 16 (12281 samples) + 90.0th: 76 (18125 samples) + * 99.0th: 117 (4320 samples) + 99.9th: 123 (257 samples) + min=1, max=375 +Request Latencies percentiles (usec) runtime 5 (s) (47215 total samples) + 50.0th: 9648 (12450 samples) + 90.0th: 12208 (19431 samples) + * 99.0th: 16480 (3149 samples) + 99.9th: 20576 (471 samples) + min=2511, max=20582 +RPS percentiles (requests) runtime 5 (s) (6 total samples) + 20.0th: 8976 (2 samples) + * 50.0th: 9264 (1 samples) + 90.0th: 9808 (3 samples) + min=8965, max=9811 +current rps: 8965 +Wakeup Latencies percentiles (usec) runtime 10 (s) (94945 total samples) + 50.0th: 16 (24176 samples) + 90.0th: 76 (37337 samples) + * 99.0th: 117 (8812 samples) + 99.9th: 122 (527 samples) + min=1, max=375 +Request Latencies percentiles (usec) runtime 10 (s) (96063 total samples) + 50.0th: 9648 (25889 samples) + 90.0th: 12208 (40501 samples) + * 99.0th: 16416 (4780 samples) + 99.9th: 20512 (580 samples) + min=2511, max=20582 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9264 (3 samples) + * 50.0th: 9712 (3 samples) + 90.0th: 9808 (5 samples) + min=8965, max=9811 +current rps: 9792 +Wakeup Latencies percentiles (usec) runtime 10 (s) (94958 total samples) + 50.0th: 16 (24182 samples) + 90.0th: 76 (37340 samples) + * 99.0th: 117 (8813 samples) + 99.9th: 122 (527 samples) + min=1, max=375 +Request Latencies percentiles (usec) runtime 10 (s) (96156 total samples) + 50.0th: 9648 (25919 samples) + 90.0th: 12208 (40547 samples) + * 99.0th: 16416 (4781 samples) + 99.9th: 20512 (580 samples) + min=2511, max=20582 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9264 (3 samples) + * 50.0th: 9712 (3 samples) + 90.0th: 9808 (5 samples) + min=8965, max=9811 +average rps: 9616 +timeout: the monitored command dumped core diff --git a/paper_results/schbench/skyloft_cfs50us/88.txt b/paper_results/schbench/skyloft_cfs50us/88.txt index d424995..f72db9a 100644 --- a/paper_results/schbench/skyloft_cfs50us/88.txt +++ b/paper_results/schbench/skyloft_cfs50us/88.txt @@ -1,18 +1,55 @@ -Wakeup Latencies percentiles (usec) runtime 1 (s) (9540 total samples) - 50.0th: 16 (2649 samples) - 90.0th: 104 (3872 samples) - * 99.0th: 120 (804 samples) - 99.9th: 187 (76 samples) - min=1, max=204 -Request Latencies percentiles (usec) runtime 1 (s) (9701 total samples) - 50.0th: 9744 (3081 samples) - 90.0th: 12208 (3758 samples) - * 99.0th: 20448 (704 samples) - 99.9th: 20512 (71 samples) - min=2512, max=20555 -RPS percentiles (requests) runtime 1 (s) (2 total samples) - 20.0th: 0 (1 samples) - * 50.0th: 0 (0 samples) - 90.0th: 9552 (1 samples) - min=9566, max=9566 -average rps: 9701 \ No newline at end of file +Wakeup Latencies percentiles (usec) runtime 5 (s) (46928 total samples) + 50.0th: 16 (13369 samples) + 90.0th: 102 (18132 samples) + * 99.0th: 119 (4196 samples) + 99.9th: 126 (363 samples) + min=1, max=232 +Request Latencies percentiles (usec) runtime 5 (s) (47424 total samples) + 50.0th: 9776 (15684 samples) + 90.0th: 12240 (19589 samples) + * 99.0th: 20512 (1930 samples) + 99.9th: 20576 (72 samples) + min=2512, max=20584 +RPS percentiles (requests) runtime 5 (s) (6 total samples) + 20.0th: 9296 (3 samples) + * 50.0th: 9296 (0 samples) + 90.0th: 9680 (3 samples) + min=9282, max=9666 +current rps: 9282 +Wakeup Latencies percentiles (usec) runtime 10 (s) (94173 total samples) + 50.0th: 16 (26993 samples) + 90.0th: 102 (36208 samples) + * 99.0th: 119 (8418 samples) + 99.9th: 122 (699 samples) + min=1, max=232 +Request Latencies percentiles (usec) runtime 10 (s) (95219 total samples) + 50.0th: 9776 (32076 samples) + 90.0th: 12208 (33433 samples) + * 99.0th: 20512 (9007 samples) + 99.9th: 20576 (188 samples) + min=2512, max=20584 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9296 (3 samples) + * 50.0th: 9456 (3 samples) + 90.0th: 9712 (4 samples) + min=9282, max=9770 +current rps: 9449 +Wakeup Latencies percentiles (usec) runtime 10 (s) (94187 total samples) + 50.0th: 16 (26995 samples) + 90.0th: 102 (36217 samples) + * 99.0th: 119 (8418 samples) + 99.9th: 122 (699 samples) + min=1, max=232 +Request Latencies percentiles (usec) runtime 10 (s) (95321 total samples) + 50.0th: 9776 (32111 samples) + 90.0th: 12208 (33473 samples) + * 99.0th: 20512 (9020 samples) + 99.9th: 20576 (188 samples) + min=2512, max=20584 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9296 (3 samples) + * 50.0th: 9456 (3 samples) + 90.0th: 9712 (4 samples) + min=9282, max=9770 +average rps: 9532 +timeout: the monitored command dumped core diff --git a/paper_results/schbench/skyloft_cfs50us/96.txt b/paper_results/schbench/skyloft_cfs50us/96.txt index a5cbd4d..da4d10b 100644 --- a/paper_results/schbench/skyloft_cfs50us/96.txt +++ b/paper_results/schbench/skyloft_cfs50us/96.txt @@ -1,18 +1,55 @@ -Wakeup Latencies percentiles (usec) runtime 1 (s) (9768 total samples) - 50.0th: 17 (2892 samples) - 90.0th: 109 (3981 samples) - * 99.0th: 121 (746 samples) - 99.9th: 206 (80 samples) - min=1, max=232 -Request Latencies percentiles (usec) runtime 1 (s) (9855 total samples) - 50.0th: 9968 (2561 samples) - 90.0th: 12208 (4093 samples) - * 99.0th: 12336 (738 samples) - 99.9th: 12816 (80 samples) - min=2512, max=13943 -RPS percentiles (requests) runtime 1 (s) (2 total samples) - 20.0th: 0 (1 samples) - * 50.0th: 0 (0 samples) - 90.0th: 9712 (1 samples) - min=9719, max=9719 -average rps: 9855 \ No newline at end of file +Wakeup Latencies percentiles (usec) runtime 5 (s) (46867 total samples) + 50.0th: 15 (13262 samples) + 90.0th: 107 (18841 samples) + * 99.0th: 120 (4013 samples) + 99.9th: 154 (287 samples) + min=1, max=241 +Request Latencies percentiles (usec) runtime 5 (s) (47242 total samples) + 50.0th: 10032 (9501 samples) + 90.0th: 12240 (20437 samples) + * 99.0th: 20512 (2932 samples) + 99.9th: 20576 (158 samples) + min=2512, max=20575 +RPS percentiles (requests) runtime 5 (s) (6 total samples) + 20.0th: 9136 (2 samples) + * 50.0th: 9168 (1 samples) + 90.0th: 9808 (3 samples) + min=9132, max=9793 +current rps: 9132 +Wakeup Latencies percentiles (usec) runtime 10 (s) (94275 total samples) + 50.0th: 15 (26808 samples) + 90.0th: 107 (37743 samples) + * 99.0th: 120 (8103 samples) + 99.9th: 123 (503 samples) + min=1, max=241 +Request Latencies percentiles (usec) runtime 10 (s) (95177 total samples) + 50.0th: 10000 (18783 samples) + 90.0th: 12240 (42023 samples) + * 99.0th: 20512 (5130 samples) + 99.9th: 20576 (296 samples) + min=2512, max=20596 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9136 (3 samples) + * 50.0th: 9552 (3 samples) + 90.0th: 9776 (4 samples) + min=8973, max=9793 +current rps: 9777 +Wakeup Latencies percentiles (usec) runtime 10 (s) (94298 total samples) + 50.0th: 15 (26815 samples) + 90.0th: 107 (37751 samples) + * 99.0th: 120 (8104 samples) + 99.9th: 123 (503 samples) + min=1, max=241 +Request Latencies percentiles (usec) runtime 10 (s) (95296 total samples) + 50.0th: 10000 (18828 samples) + 90.0th: 12240 (42068 samples) + * 99.0th: 20512 (5134 samples) + 99.9th: 20576 (296 samples) + min=2512, max=20596 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9136 (3 samples) + * 50.0th: 9552 (3 samples) + 90.0th: 9776 (4 samples) + min=8973, max=9793 +average rps: 9530 +timeout: the monitored command dumped core diff --git a/paper_results/schbench/skyloft_cfs50us/all.csv b/paper_results/schbench/skyloft_cfs50us/all.csv index 3d47662..6ce9aa9 100644 --- a/paper_results/schbench/skyloft_cfs50us/all.csv +++ b/paper_results/schbench/skyloft_cfs50us/all.csv @@ -1,14 +1,13 @@ cores,wake99,rps50,lat99 -4,2,1510,2668 -8,2,0,2644 -16,3,0,2644 -24,4,0,2676 -32,34,0,4808 -40,34,0,4856 -48,35,0,5000 -56,79,0,9776 -64,81,0,9776 -72,83,0,9872 -80,116,0,12240 -88,120,0,20448 -96,121,0,12336 +8,3,2764,4168 +16,3,5464,4168 +24,4,8136,4168 +32,34,8784,5016 +40,34,9264,4808 +48,34,9904,8104 +56,81,9840,12368 +64,83,9680,12240 +72,82,9776,10256 +80,117,9712,16416 +88,119,9456,20512 +96,120,9552,20512 diff --git a/paper_results/schbench/skyloft_eevdf/16.txt b/paper_results/schbench/skyloft_eevdf/16.txt new file mode 100644 index 0000000..6be86d1 --- /dev/null +++ b/paper_results/schbench/skyloft_eevdf/16.txt @@ -0,0 +1,55 @@ +Wakeup Latencies percentiles (usec) runtime 5 (s) (25071 total samples) + 50.0th: 2 (11770 samples) + 90.0th: 2 (0 samples) + * 99.0th: 6 (1898 samples) + 99.9th: 14 (155 samples) + min=1, max=68 +Request Latencies percentiles (usec) runtime 5 (s) (25112 total samples) + 50.0th: 2644 (7235 samples) + 90.0th: 4168 (10028 samples) + * 99.0th: 4168 (0 samples) + 99.9th: 4168 (0 samples) + min=2514, max=4187 +RPS percentiles (requests) runtime 5 (s) (6 total samples) + 20.0th: 4136 (2 samples) + * 50.0th: 4152 (1 samples) + 90.0th: 5928 (3 samples) + min=4129, max=5921 +current rps: 5488 +Wakeup Latencies percentiles (usec) runtime 10 (s) (51541 total samples) + 50.0th: 2 (24016 samples) + 90.0th: 2 (0 samples) + * 99.0th: 5 (3274 samples) + 99.9th: 12 (359 samples) + min=1, max=68 +Request Latencies percentiles (usec) runtime 10 (s) (51621 total samples) + 50.0th: 2644 (16037 samples) + 90.0th: 4168 (17613 samples) + * 99.0th: 4168 (0 samples) + 99.9th: 4168 (0 samples) + min=2514, max=4196 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 4152 (3 samples) + * 50.0th: 5432 (3 samples) + 90.0th: 5496 (4 samples) + min=4129, max=5921 +current rps: 5033 +Wakeup Latencies percentiles (usec) runtime 10 (s) (51542 total samples) + 50.0th: 2 (24016 samples) + 90.0th: 2 (0 samples) + * 99.0th: 5 (3274 samples) + 99.9th: 12 (359 samples) + min=1, max=68 +Request Latencies percentiles (usec) runtime 10 (s) (51638 total samples) + 50.0th: 2644 (16041 samples) + 90.0th: 4168 (17622 samples) + * 99.0th: 4168 (0 samples) + 99.9th: 4168 (0 samples) + min=2514, max=4196 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 4152 (3 samples) + * 50.0th: 5432 (3 samples) + 90.0th: 5496 (4 samples) + min=4129, max=5921 +average rps: 5164 +timeout: the monitored command dumped core diff --git a/paper_results/schbench/skyloft_eevdf/24.txt b/paper_results/schbench/skyloft_eevdf/24.txt new file mode 100644 index 0000000..2a423d6 --- /dev/null +++ b/paper_results/schbench/skyloft_eevdf/24.txt @@ -0,0 +1,55 @@ +Wakeup Latencies percentiles (usec) runtime 5 (s) (39136 total samples) + 50.0th: 2 (23138 samples) + 90.0th: 3 (4011 samples) + * 99.0th: 4 (897 samples) + 99.9th: 7 (256 samples) + min=1, max=37 +Request Latencies percentiles (usec) runtime 5 (s) (40109 total samples) + 50.0th: 2612 (7505 samples) + 90.0th: 4168 (19537 samples) + * 99.0th: 4184 (43 samples) + 99.9th: 4232 (391 samples) + min=2460, max=4242 +RPS percentiles (requests) runtime 5 (s) (6 total samples) + 20.0th: 7224 (2 samples) + * 50.0th: 7704 (1 samples) + 90.0th: 8944 (3 samples) + min=7228, max=8956 +current rps: 8270 +Wakeup Latencies percentiles (usec) runtime 10 (s) (79415 total samples) + 50.0th: 2 (46613 samples) + 90.0th: 3 (7611 samples) + * 99.0th: 4 (1679 samples) + 99.9th: 6 (444 samples) + min=1, max=37 +Request Latencies percentiles (usec) runtime 10 (s) (81497 total samples) + 50.0th: 2644 (32457 samples) + 90.0th: 4168 (23558 samples) + * 99.0th: 4168 (0 samples) + 99.9th: 4232 (590 samples) + min=2460, max=4242 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 7704 (3 samples) + * 50.0th: 8152 (3 samples) + 90.0th: 8592 (4 samples) + min=7228, max=8956 +current rps: 8597 +Wakeup Latencies percentiles (usec) runtime 10 (s) (79417 total samples) + 50.0th: 2 (46614 samples) + 90.0th: 3 (7612 samples) + * 99.0th: 4 (1679 samples) + 99.9th: 6 (444 samples) + min=1, max=37 +Request Latencies percentiles (usec) runtime 10 (s) (81523 total samples) + 50.0th: 2644 (32472 samples) + 90.0th: 4168 (23562 samples) + * 99.0th: 4168 (0 samples) + 99.9th: 4232 (590 samples) + min=2460, max=4242 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 7704 (3 samples) + * 50.0th: 8152 (3 samples) + 90.0th: 8592 (4 samples) + min=7228, max=8956 +average rps: 8152 +timeout: the monitored command dumped core diff --git a/paper_results/schbench/skyloft_eevdf/32.txt b/paper_results/schbench/skyloft_eevdf/32.txt new file mode 100644 index 0000000..a4aa49e --- /dev/null +++ b/paper_results/schbench/skyloft_eevdf/32.txt @@ -0,0 +1,55 @@ +Wakeup Latencies percentiles (usec) runtime 5 (s) (43792 total samples) + 50.0th: 2 (0 samples) + 90.0th: 20 (16268 samples) + * 99.0th: 23 (3503 samples) + 99.9th: 27 (288 samples) + min=1, max=62 +Request Latencies percentiles (usec) runtime 5 (s) (44691 total samples) + 50.0th: 2676 (5782 samples) + 90.0th: 4808 (19124 samples) + * 99.0th: 4824 (2950 samples) + 99.9th: 5080 (240 samples) + min=2513, max=6083 +RPS percentiles (requests) runtime 5 (s) (6 total samples) + 20.0th: 8336 (2 samples) + * 50.0th: 8368 (1 samples) + 90.0th: 9488 (3 samples) + min=8348, max=9503 +current rps: 9249 +Wakeup Latencies percentiles (usec) runtime 10 (s) (87668 total samples) + 50.0th: 2 (0 samples) + 90.0th: 20 (32565 samples) + * 99.0th: 23 (6866 samples) + 99.9th: 25 (545 samples) + min=1, max=62 +Request Latencies percentiles (usec) runtime 10 (s) (89342 total samples) + 50.0th: 2652 (9825 samples) + 90.0th: 4808 (38331 samples) + * 99.0th: 4824 (5905 samples) + 99.9th: 5064 (267 samples) + min=2513, max=6083 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 8368 (3 samples) + * 50.0th: 8816 (3 samples) + 90.0th: 9296 (4 samples) + min=8348, max=9503 +current rps: 8837 +Wakeup Latencies percentiles (usec) runtime 10 (s) (87668 total samples) + 50.0th: 2 (0 samples) + 90.0th: 20 (32565 samples) + * 99.0th: 23 (6866 samples) + 99.9th: 25 (545 samples) + min=1, max=62 +Request Latencies percentiles (usec) runtime 10 (s) (89374 total samples) + 50.0th: 2652 (9828 samples) + 90.0th: 4808 (38350 samples) + * 99.0th: 4824 (5907 samples) + 99.9th: 5064 (267 samples) + min=2513, max=6083 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 8368 (3 samples) + * 50.0th: 8816 (3 samples) + 90.0th: 9296 (4 samples) + min=8348, max=9503 +average rps: 8937 +timeout: the monitored command dumped core diff --git a/paper_results/schbench/skyloft_eevdf/40.txt b/paper_results/schbench/skyloft_eevdf/40.txt new file mode 100644 index 0000000..782f521 --- /dev/null +++ b/paper_results/schbench/skyloft_eevdf/40.txt @@ -0,0 +1,55 @@ +Wakeup Latencies percentiles (usec) runtime 5 (s) (45941 total samples) + 50.0th: 14 (13820 samples) + 90.0th: 21 (16089 samples) + * 99.0th: 23 (3151 samples) + 99.9th: 47 (375 samples) + min=1, max=70 +Request Latencies percentiles (usec) runtime 5 (s) (47029 total samples) + 50.0th: 4808 (28137 samples) + 90.0th: 4824 (8723 samples) + * 99.0th: 4968 (195 samples) + 99.9th: 8120 (417 samples) + min=2514, max=8151 +RPS percentiles (requests) runtime 5 (s) (6 total samples) + 20.0th: 9232 (2 samples) + * 50.0th: 9328 (1 samples) + 90.0th: 9648 (3 samples) + min=9245, max=9655 +current rps: 9373 +Wakeup Latencies percentiles (usec) runtime 10 (s) (91806 total samples) + 50.0th: 14 (27417 samples) + 90.0th: 21 (31943 samples) + * 99.0th: 23 (6169 samples) + 99.9th: 25 (719 samples) + min=1, max=70 +Request Latencies percentiles (usec) runtime 10 (s) (94013 total samples) + 50.0th: 4808 (55408 samples) + 90.0th: 4824 (17051 samples) + * 99.0th: 8104 (1064 samples) + 99.9th: 8136 (798 samples) + min=2514, max=8151 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9328 (3 samples) + * 50.0th: 9392 (7 samples) + 90.0th: 9392 (0 samples) + min=9245, max=9655 +current rps: 9384 +Wakeup Latencies percentiles (usec) runtime 10 (s) (91807 total samples) + 50.0th: 14 (27417 samples) + 90.0th: 21 (31943 samples) + * 99.0th: 23 (6169 samples) + 99.9th: 25 (719 samples) + min=1, max=70 +Request Latencies percentiles (usec) runtime 10 (s) (94054 total samples) + 50.0th: 4808 (55441 samples) + 90.0th: 4824 (17056 samples) + * 99.0th: 8104 (1064 samples) + 99.9th: 8136 (798 samples) + min=2514, max=8151 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9328 (3 samples) + * 50.0th: 9392 (7 samples) + 90.0th: 9392 (0 samples) + min=9245, max=9655 +average rps: 9405 +timeout: the monitored command dumped core diff --git a/paper_results/schbench/skyloft_eevdf/48.txt b/paper_results/schbench/skyloft_eevdf/48.txt new file mode 100644 index 0000000..8c94d9d --- /dev/null +++ b/paper_results/schbench/skyloft_eevdf/48.txt @@ -0,0 +1,55 @@ +Wakeup Latencies percentiles (usec) runtime 5 (s) (48946 total samples) + 50.0th: 16 (16268 samples) + 90.0th: 22 (17592 samples) + * 99.0th: 32 (2311 samples) + 99.9th: 51 (382 samples) + min=1, max=88 +Request Latencies percentiles (usec) runtime 5 (s) (49602 total samples) + 50.0th: 4808 (21823 samples) + 90.0th: 4824 (11008 samples) + * 99.0th: 5000 (1552 samples) + 99.9th: 5288 (396 samples) + min=2599, max=8184 +RPS percentiles (requests) runtime 5 (s) (6 total samples) + 20.0th: 9904 (6 samples) + * 50.0th: 9904 (0 samples) + 90.0th: 9904 (0 samples) + min=9891, max=9913 +current rps: 9912 +Wakeup Latencies percentiles (usec) runtime 10 (s) (97886 total samples) + 50.0th: 16 (32433 samples) + 90.0th: 22 (35411 samples) + * 99.0th: 32 (4760 samples) + 99.9th: 48 (709 samples) + min=1, max=88 +Request Latencies percentiles (usec) runtime 10 (s) (99221 total samples) + 50.0th: 4808 (43285 samples) + 90.0th: 4824 (21609 samples) + * 99.0th: 5000 (2965 samples) + 99.9th: 5320 (735 samples) + min=2516, max=8184 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9904 (11 samples) + * 50.0th: 9904 (0 samples) + 90.0th: 9904 (0 samples) + min=9891, max=9919 +current rps: 9911 +Wakeup Latencies percentiles (usec) runtime 10 (s) (97892 total samples) + 50.0th: 16 (32435 samples) + 90.0th: 22 (35412 samples) + * 99.0th: 32 (4760 samples) + 99.9th: 48 (709 samples) + min=1, max=88 +Request Latencies percentiles (usec) runtime 10 (s) (99275 total samples) + 50.0th: 4808 (43305 samples) + 90.0th: 4824 (21625 samples) + * 99.0th: 5000 (2966 samples) + 99.9th: 5320 (736 samples) + min=2516, max=8184 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9904 (11 samples) + * 50.0th: 9904 (0 samples) + 90.0th: 9904 (0 samples) + min=9891, max=9919 +average rps: 9928 +timeout: the monitored command dumped core diff --git a/paper_results/schbench/skyloft_eevdf/56.txt b/paper_results/schbench/skyloft_eevdf/56.txt new file mode 100644 index 0000000..58dc37c --- /dev/null +++ b/paper_results/schbench/skyloft_eevdf/56.txt @@ -0,0 +1,37 @@ +Wakeup Latencies percentiles (usec) runtime 5 (s) (48473 total samples) + 50.0th: 17 (13328 samples) + 90.0th: 30 (19956 samples) + * 99.0th: 49 (3771 samples) + 99.9th: 67 (376 samples) + min=1, max=137 +Request Latencies percentiles (usec) runtime 5 (s) (49130 total samples) + 50.0th: 4808 (15574 samples) + 90.0th: 9680 (18170 samples) + * 99.0th: 9776 (4106 samples) + 99.9th: 16416 (452 samples) + min=2514, max=16444 +RPS percentiles (requests) runtime 5 (s) (6 total samples) + 20.0th: 9776 (3 samples) + * 50.0th: 9776 (0 samples) + 90.0th: 9872 (3 samples) + min=9760, max=9876 +current rps: 9779 +Wakeup Latencies percentiles (usec) runtime 10 (s) (96815 total samples) + 50.0th: 16 (26466 samples) + 90.0th: 30 (39817 samples) + * 99.0th: 49 (7681 samples) + 99.9th: 60 (690 samples) + min=1, max=137 +Request Latencies percentiles (usec) runtime 10 (s) (98148 total samples) + 50.0th: 4808 (31039 samples) + 90.0th: 9680 (37064 samples) + * 99.0th: 9776 (8357 samples) + 99.9th: 16368 (557 samples) + min=2513, max=16445 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9712 (3 samples) + * 50.0th: 9776 (3 samples) + 90.0th: 9872 (5 samples) + min=9692, max=9876 +current rps: 9870 +timeout: the monitored command dumped core diff --git a/paper_results/schbench/skyloft_eevdf/64.txt b/paper_results/schbench/skyloft_eevdf/64.txt new file mode 100644 index 0000000..3896069 --- /dev/null +++ b/paper_results/schbench/skyloft_eevdf/64.txt @@ -0,0 +1,55 @@ +Wakeup Latencies percentiles (usec) runtime 5 (s) (47612 total samples) + 50.0th: 16 (14507 samples) + 90.0th: 36 (18833 samples) + * 99.0th: 52 (4039 samples) + 99.9th: 81 (429 samples) + min=1, max=130 +Request Latencies percentiles (usec) runtime 5 (s) (48243 total samples) + 50.0th: 7256 (14584 samples) + 90.0th: 9744 (20966 samples) + * 99.0th: 16368 (2424 samples) + 99.9th: 16416 (301 samples) + min=2514, max=16476 +RPS percentiles (requests) runtime 5 (s) (6 total samples) + 20.0th: 9424 (2 samples) + * 50.0th: 9488 (1 samples) + 90.0th: 9840 (3 samples) + min=9423, max=9828 +current rps: 9690 +Wakeup Latencies percentiles (usec) runtime 10 (s) (94833 total samples) + 50.0th: 16 (29065 samples) + 90.0th: 36 (37435 samples) + * 99.0th: 52 (8049 samples) + 99.9th: 64 (775 samples) + min=1, max=130 +Request Latencies percentiles (usec) runtime 10 (s) (96188 total samples) + 50.0th: 7256 (29398 samples) + 90.0th: 9744 (41593 samples) + * 99.0th: 16368 (5006 samples) + 99.9th: 16416 (698 samples) + min=2514, max=16476 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9424 (3 samples) + * 50.0th: 9616 (3 samples) + 90.0th: 9808 (4 samples) + min=9116, max=9828 +current rps: 9116 +Wakeup Latencies percentiles (usec) runtime 10 (s) (94840 total samples) + 50.0th: 16 (29069 samples) + 90.0th: 36 (37437 samples) + * 99.0th: 52 (8049 samples) + 99.9th: 64 (775 samples) + min=1, max=130 +Request Latencies percentiles (usec) runtime 10 (s) (96258 total samples) + 50.0th: 7256 (29414 samples) + 90.0th: 9744 (41627 samples) + * 99.0th: 16368 (5019 samples) + 99.9th: 16416 (700 samples) + min=2514, max=16476 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9424 (3 samples) + * 50.0th: 9616 (3 samples) + 90.0th: 9808 (4 samples) + min=9116, max=9828 +average rps: 9626 +timeout: the monitored command dumped core diff --git a/paper_results/schbench/skyloft_eevdf/72.txt b/paper_results/schbench/skyloft_eevdf/72.txt new file mode 100644 index 0000000..38f9073 --- /dev/null +++ b/paper_results/schbench/skyloft_eevdf/72.txt @@ -0,0 +1,55 @@ +Wakeup Latencies percentiles (usec) runtime 5 (s) (46593 total samples) + 50.0th: 19 (12053 samples) + 90.0th: 41 (18640 samples) + * 99.0th: 54 (3869 samples) + 99.9th: 82 (407 samples) + min=1, max=164 +Request Latencies percentiles (usec) runtime 5 (s) (47143 total samples) + 50.0th: 7384 (14609 samples) + 90.0th: 9744 (18215 samples) + * 99.0th: 16416 (4669 samples) + 99.9th: 16416 (0 samples) + min=2514, max=16470 +RPS percentiles (requests) runtime 5 (s) (6 total samples) + 20.0th: 8720 (2 samples) + * 50.0th: 9136 (1 samples) + 90.0th: 9776 (3 samples) + min=8720, max=9790 +current rps: 8720 +Wakeup Latencies percentiles (usec) runtime 10 (s) (93636 total samples) + 50.0th: 19 (24348 samples) + 90.0th: 41 (37556 samples) + * 99.0th: 54 (7742 samples) + 99.9th: 70 (774 samples) + min=1, max=164 +Request Latencies percentiles (usec) runtime 10 (s) (94782 total samples) + 50.0th: 7368 (28240 samples) + 90.0th: 9744 (38538 samples) + * 99.0th: 16416 (8585 samples) + 99.9th: 16416 (0 samples) + min=2514, max=16470 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 8720 (3 samples) + * 50.0th: 9744 (5 samples) + 90.0th: 9776 (2 samples) + min=8628, max=9794 +current rps: 9794 +Wakeup Latencies percentiles (usec) runtime 10 (s) (93637 total samples) + 50.0th: 19 (24349 samples) + 90.0th: 41 (37556 samples) + * 99.0th: 54 (7742 samples) + 99.9th: 70 (774 samples) + min=1, max=164 +Request Latencies percentiles (usec) runtime 10 (s) (94855 total samples) + 50.0th: 7368 (28271 samples) + 90.0th: 9744 (38573 samples) + * 99.0th: 16416 (8588 samples) + 99.9th: 16416 (0 samples) + min=2514, max=16470 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 8720 (3 samples) + * 50.0th: 9744 (5 samples) + 90.0th: 9776 (2 samples) + min=8628, max=9794 +average rps: 9486 +timeout: the monitored command dumped core diff --git a/paper_results/schbench/skyloft_eevdf/8.txt b/paper_results/schbench/skyloft_eevdf/8.txt new file mode 100644 index 0000000..88aff26 --- /dev/null +++ b/paper_results/schbench/skyloft_eevdf/8.txt @@ -0,0 +1,55 @@ +Wakeup Latencies percentiles (usec) runtime 5 (s) (13051 total samples) + 50.0th: 1 (0 samples) + 90.0th: 2 (5646 samples) + * 99.0th: 4 (747 samples) + 99.9th: 6 (42 samples) + min=1, max=11 +Request Latencies percentiles (usec) runtime 5 (s) (13051 total samples) + 50.0th: 2644 (6563 samples) + 90.0th: 4168 (3866 samples) + * 99.0th: 4168 (0 samples) + 99.9th: 4168 (0 samples) + min=2514, max=4178 +RPS percentiles (requests) runtime 5 (s) (6 total samples) + 20.0th: 2196 (2 samples) + * 50.0th: 2484 (1 samples) + 90.0th: 3060 (3 samples) + min=2198, max=3060 +current rps: 2784 +Wakeup Latencies percentiles (usec) runtime 10 (s) (27001 total samples) + 50.0th: 1 (0 samples) + 90.0th: 2 (11303 samples) + * 99.0th: 4 (1535 samples) + 99.9th: 6 (102 samples) + min=1, max=15 +Request Latencies percentiles (usec) runtime 10 (s) (27005 total samples) + 50.0th: 2644 (15264 samples) + 90.0th: 4168 (6203 samples) + * 99.0th: 4168 (0 samples) + 99.9th: 4168 (0 samples) + min=2514, max=4178 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 2484 (3 samples) + * 50.0th: 2628 (3 samples) + 90.0th: 3060 (5 samples) + min=2198, max=3060 +current rps: 2630 +Wakeup Latencies percentiles (usec) runtime 10 (s) (27001 total samples) + 50.0th: 1 (0 samples) + 90.0th: 2 (11303 samples) + * 99.0th: 4 (1535 samples) + 99.9th: 6 (102 samples) + min=1, max=15 +Request Latencies percentiles (usec) runtime 10 (s) (27013 total samples) + 50.0th: 2644 (15268 samples) + 90.0th: 4168 (6206 samples) + * 99.0th: 4168 (0 samples) + 99.9th: 4168 (0 samples) + min=2514, max=4178 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 2484 (3 samples) + * 50.0th: 2628 (3 samples) + 90.0th: 3060 (5 samples) + min=2198, max=3060 +average rps: 2701 +timeout: the monitored command dumped core diff --git a/paper_results/schbench/skyloft_eevdf/80.txt b/paper_results/schbench/skyloft_eevdf/80.txt new file mode 100644 index 0000000..3f0912e --- /dev/null +++ b/paper_results/schbench/skyloft_eevdf/80.txt @@ -0,0 +1,55 @@ +Wakeup Latencies percentiles (usec) runtime 5 (s) (47372 total samples) + 50.0th: 22 (13215 samples) + 90.0th: 47 (18581 samples) + * 99.0th: 68 (4191 samples) + 99.9th: 102 (383 samples) + min=1, max=201 +Request Latencies percentiles (usec) runtime 5 (s) (47945 total samples) + 50.0th: 9680 (15173 samples) + 90.0th: 12208 (20209 samples) + * 99.0th: 16368 (2490 samples) + 99.9th: 20576 (478 samples) + min=2515, max=20595 +RPS percentiles (requests) runtime 5 (s) (6 total samples) + 20.0th: 9392 (2 samples) + * 50.0th: 9520 (1 samples) + 90.0th: 9744 (3 samples) + min=9386, max=9732 +current rps: 9598 +Wakeup Latencies percentiles (usec) runtime 10 (s) (95479 total samples) + 50.0th: 22 (26642 samples) + 90.0th: 47 (37380 samples) + * 99.0th: 67 (8328 samples) + 99.9th: 85 (840 samples) + min=1, max=201 +Request Latencies percentiles (usec) runtime 10 (s) (96722 total samples) + 50.0th: 9680 (31163 samples) + 90.0th: 12176 (36765 samples) + * 99.0th: 12400 (8559 samples) + 99.9th: 20512 (821 samples) + min=2515, max=20649 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9520 (3 samples) + * 50.0th: 9680 (3 samples) + 90.0th: 9776 (5 samples) + min=9386, max=9782 +current rps: 9779 +Wakeup Latencies percentiles (usec) runtime 10 (s) (95487 total samples) + 50.0th: 22 (26644 samples) + 90.0th: 47 (37381 samples) + * 99.0th: 67 (8330 samples) + 99.9th: 85 (840 samples) + min=1, max=201 +Request Latencies percentiles (usec) runtime 10 (s) (96810 total samples) + 50.0th: 9680 (31164 samples) + 90.0th: 12176 (36804 samples) + * 99.0th: 12400 (8574 samples) + 99.9th: 20512 (821 samples) + min=2515, max=20649 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9520 (3 samples) + * 50.0th: 9680 (3 samples) + 90.0th: 9776 (5 samples) + min=9386, max=9782 +average rps: 9681 +timeout: the monitored command dumped core diff --git a/paper_results/schbench/skyloft_eevdf/88.txt b/paper_results/schbench/skyloft_eevdf/88.txt new file mode 100644 index 0000000..942e6b6 --- /dev/null +++ b/paper_results/schbench/skyloft_eevdf/88.txt @@ -0,0 +1,55 @@ +Wakeup Latencies percentiles (usec) runtime 5 (s) (47270 total samples) + 50.0th: 25 (14415 samples) + 90.0th: 51 (18857 samples) + * 99.0th: 77 (4106 samples) + 99.9th: 121 (343 samples) + min=1, max=224 +Request Latencies percentiles (usec) runtime 5 (s) (47894 total samples) + 50.0th: 9744 (16508 samples) + 90.0th: 12208 (16867 samples) + * 99.0th: 20512 (3747 samples) + 99.9th: 20576 (150 samples) + min=2515, max=20610 +RPS percentiles (requests) runtime 5 (s) (6 total samples) + 20.0th: 9456 (2 samples) + * 50.0th: 9488 (2 samples) + 90.0th: 9744 (2 samples) + min=9454, max=9733 +current rps: 9454 +Wakeup Latencies percentiles (usec) runtime 10 (s) (95323 total samples) + 50.0th: 25 (29022 samples) + 90.0th: 51 (37925 samples) + * 99.0th: 75 (8014 samples) + 99.9th: 91 (790 samples) + min=1, max=224 +Request Latencies percentiles (usec) runtime 10 (s) (96679 total samples) + 50.0th: 9744 (33102 samples) + 90.0th: 12208 (35182 samples) + * 99.0th: 16416 (6133 samples) + 99.9th: 20576 (949 samples) + min=2514, max=20610 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9488 (4 samples) + * 50.0th: 9712 (2 samples) + 90.0th: 9776 (5 samples) + min=9454, max=9780 +current rps: 9765 +Wakeup Latencies percentiles (usec) runtime 10 (s) (95337 total samples) + 50.0th: 25 (29025 samples) + 90.0th: 51 (37930 samples) + * 99.0th: 75 (8015 samples) + 99.9th: 91 (790 samples) + min=1, max=224 +Request Latencies percentiles (usec) runtime 10 (s) (96779 total samples) + 50.0th: 9744 (33130 samples) + 90.0th: 12208 (35239 samples) + * 99.0th: 16416 (6136 samples) + 99.9th: 20576 (949 samples) + min=2514, max=20610 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9488 (4 samples) + * 50.0th: 9712 (2 samples) + 90.0th: 9776 (5 samples) + min=9454, max=9780 +average rps: 9678 +timeout: the monitored command dumped core diff --git a/paper_results/schbench/skyloft_eevdf/96.txt b/paper_results/schbench/skyloft_eevdf/96.txt new file mode 100644 index 0000000..458ecfe --- /dev/null +++ b/paper_results/schbench/skyloft_eevdf/96.txt @@ -0,0 +1,55 @@ +Wakeup Latencies percentiles (usec) runtime 5 (s) (47331 total samples) + 50.0th: 27 (14290 samples) + 90.0th: 54 (19152 samples) + * 99.0th: 79 (3926 samples) + 99.9th: 151 (410 samples) + min=1, max=577 +Request Latencies percentiles (usec) runtime 5 (s) (47890 total samples) + 50.0th: 9776 (14372 samples) + 90.0th: 12208 (19228 samples) + * 99.0th: 20512 (3837 samples) + 99.9th: 20576 (240 samples) + min=2514, max=20600 +RPS percentiles (requests) runtime 5 (s) (6 total samples) + 20.0th: 9008 (2 samples) + * 50.0th: 9584 (1 samples) + 90.0th: 9776 (3 samples) + min=9021, max=9766 +current rps: 9684 +Wakeup Latencies percentiles (usec) runtime 10 (s) (95226 total samples) + 50.0th: 27 (29034 samples) + 90.0th: 53 (37604 samples) + * 99.0th: 78 (8640 samples) + 99.9th: 101 (768 samples) + min=1, max=577 +Request Latencies percentiles (usec) runtime 10 (s) (96397 total samples) + 50.0th: 9808 (31924 samples) + 90.0th: 12208 (36548 samples) + * 99.0th: 20512 (7426 samples) + 99.9th: 20576 (355 samples) + min=2514, max=20603 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9584 (3 samples) + * 50.0th: 9648 (3 samples) + 90.0th: 9776 (5 samples) + min=9021, max=9786 +current rps: 9629 +Wakeup Latencies percentiles (usec) runtime 10 (s) (95241 total samples) + 50.0th: 27 (29038 samples) + 90.0th: 53 (37608 samples) + * 99.0th: 78 (8643 samples) + 99.9th: 101 (769 samples) + min=1, max=577 +Request Latencies percentiles (usec) runtime 10 (s) (96506 total samples) + 50.0th: 9808 (31948 samples) + 90.0th: 12208 (36597 samples) + * 99.0th: 20512 (7437 samples) + 99.9th: 20576 (355 samples) + min=2514, max=20603 +RPS percentiles (requests) runtime 10 (s) (11 total samples) + 20.0th: 9584 (3 samples) + * 50.0th: 9648 (3 samples) + 90.0th: 9776 (5 samples) + min=9021, max=9786 +average rps: 9651 +timeout: the monitored command dumped core diff --git a/paper_results/schbench/skyloft_eevdf/all.csv b/paper_results/schbench/skyloft_eevdf/all.csv new file mode 100644 index 0000000..07c5bd9 --- /dev/null +++ b/paper_results/schbench/skyloft_eevdf/all.csv @@ -0,0 +1,13 @@ +cores,wake99,rps50,lat99 +8,4,2628,4168 +16,5,5432,4168 +24,4,8152,4168 +32,23,8816,4824 +40,23,9392,8104 +48,32,9904,5000 +56,49,9776,9776 +64,52,9616,16368 +72,54,9744,16416 +80,67,9680,12400 +88,75,9712,16416 +96,78,9648,20512 diff --git a/scripts/bench/schbench.sh b/scripts/bench/schbench.sh index 5b1552b..3393f58 100755 --- a/scripts/bench/schbench.sh +++ b/scripts/bench/schbench.sh @@ -9,8 +9,6 @@ cmd="$bin -n10 -F128 -m1 -r10 -i5" mkdir -p $dir echo "cores,wake99,rps50,lat99" > $dir/all.csv -# cores="4 8 16 24 32 40 48" -# cores="64 72 80 96 112 128 144 160 176 192 208 224 240 256" cores=$(seq 8 8 96) for i in $cores; do diff --git a/scripts/build.sh b/scripts/build.sh index ad840ee..ab5d3c7 100755 --- a/scripts/build.sh +++ b/scripts/build.sh @@ -11,7 +11,7 @@ if [[ $app_name =~ synthetic-(.*) ]]; then build_cmd="make install SCHED=${BASH_REMATCH[1]} UINTR=1 DPDK=0" elif [[ $app_name =~ schbench-([a-zA-Z0-9]+).* ]]; then params_file=$script_dir/params/$app_name.params - build_cmd="make schbench SCHED=${BASH_REMATCH[1]} UINTR=1 DPDK=0" + build_cmd="make schbench SCHED=${BASH_REMATCH[1]} UINTR=1 DPDK=0 LOG=warn" elif [ $app_name == "memcached" ]; then params_file=$script_dir/params/$app_name.params build_cmd="make memcached SCHED=fifo UINTR=0 DPDK=1" diff --git a/scripts/params/schbench-eevdf.params b/scripts/params/schbench-eevdf.params new file mode 100644 index 0000000..9cb1450 --- /dev/null +++ b/scripts/params/schbench-eevdf.params @@ -0,0 +1,3 @@ +#define USED_CPUS 24 +#define USED_HW_CPU_LIST "0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23" +#define TIMER_HZ 100000 diff --git a/scripts/plots/plot_schbench.py b/scripts/plots/plot_schbench.py index fc719e3..fd0f3b3 100644 --- a/scripts/plots/plot_schbench.py +++ b/scripts/plots/plot_schbench.py @@ -2,7 +2,7 @@ import argparse import numpy as np import matplotlib.pyplot as plt -from matplotlib.ticker import (MultipleLocator, AutoMinorLocator) +from matplotlib.ticker import MultipleLocator, AutoMinorLocator from common import * @@ -15,6 +15,8 @@ "linux_rr", "linux_cfs", "linux_cfs_opt", + "linux_eevdf", + "skyloft_eevdf", "skyloft_rr50us", "skyloft_cfs50us", ] @@ -22,6 +24,8 @@ "Linux-RR", "Linux-CFS", "Linux-CFS-opt", + "Linux-EEVDF", + "Skyloft-EEVDF", "Skyloft-RR", "Skyloft-CFS", ] @@ -29,6 +33,8 @@ ".:", "+--", "*--", + "*-", + "x--", "x-", "o-", ] @@ -36,14 +42,17 @@ COLORS(0), COLORS(4), COLORS(2), + COLORS(6), + COLORS(5), COLORS(1), COLORS(3), ] + def load_result(name): f = open(name, "r") results = [list(map(int, line.strip().split(","))) for line in f.readlines()[1:]] - results = list(filter(lambda x: x[0] >=8 and x[0] <= 96, results)) + results = list(filter(lambda x: x[0] >= 8 and x[0] <= 96, results)) results = np.array(results) cores = results[:, 0] @@ -52,6 +61,7 @@ def load_result(name): rps = results[:, 2] / 1000 return cores, lat, lat2, rps + def plot_one(ax, idx, x, y): ax.plot( x, @@ -65,12 +75,13 @@ def plot_one(ax, idx, x, y): color=COLORS[idx], ) + def plot(data=None, output=None): res_dir = os.path.join(RES_DIR, data) fig, ax = plt.subplots(figsize=(6, 2.5)) axs = [ax] - axs[0].set_yscale('log', base=10) + axs[0].set_yscale("log", base=10) axs[0].set_ylim(1, 20000) axs[0].set_yticks([1, 10, 100, 1000, 10000]) axs[0].set_yticklabels(["1$\mu$s", "10$\mu$s", "100$\mu$s", "1ms", "10ms"]) @@ -86,13 +97,15 @@ def plot(data=None, output=None): ax.xaxis.set_minor_locator(MultipleLocator(8)) for i, fname in enumerate(FNAMES): - results = load_result(f'{res_dir}/{fname}/all.csv') + results = load_result(f"{res_dir}/{fname}/all.csv") print(fname, results) plot_one(ax, i, results[0], results[idx + 1]) handles, labels = ax.get_legend_handles_labels() - plt.legend(handles, labels, loc='lower right', - bbox_to_anchor=(1, -0.03), + plt.legend( + handles, + labels, + loc="upper left", ncol=1, fontsize=8, frameon=False, @@ -109,4 +122,4 @@ def plot(data=None, output=None): if __name__ == "__main__": - plot("schbench", args.output) + plot("schbench", "schbench.pdf") diff --git a/utils/include/utils/compiler.h b/utils/include/utils/compiler.h new file mode 100644 index 0000000..4ca594f --- /dev/null +++ b/utils/include/utils/compiler.h @@ -0,0 +1,103 @@ +#ifndef _UTILS_COMPILER_H +#define _UTILS_COMPILER_H + +/* Indirect macros required for expanded argument pasting, eg. __LINE__. */ +#define ___PASTE(a, b) a##b +#define __PASTE(a, b) ___PASTE(a, b) + +#define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __COUNTER__) + +#define __compiletime_assert(condition, msg, prefix, suffix) \ + do { \ + } while (0) + +#define _compiletime_assert(condition, msg, prefix, suffix) \ + __compiletime_assert(condition, msg, prefix, suffix) + +/** + * compiletime_assert - break build and emit msg if condition is false + * @condition: a compile-time constant condition to check + * @msg: a message to emit if condition is false + * + * In tradition of POSIX assert, this macro will break the build if the + * supplied condition is *false*, emitting the supplied error message if the + * compiler has support to do so. + */ +#define compiletime_assert(condition, msg) \ + _compiletime_assert(condition, msg, __compiletime_assert_, __COUNTER__) + +/* + * This returns a constant expression while determining if an argument is + * a constant expression, most importantly without evaluating the argument. + * Glory to Martin Uecker + * + * Details: + * - sizeof() return an integer constant expression, and does not evaluate + * the value of its operand; it only examines the type of its operand. + * - The results of comparing two integer constant expressions is also + * an integer constant expression. + * - The first literal "8" isn't important. It could be any literal value. + * - The second literal "8" is to avoid warnings about unaligned pointers; + * this could otherwise just be "1". + * - (long)(x) is used to avoid warnings about 64-bit types on 32-bit + * architectures. + * - The C Standard defines "null pointer constant", "(void *)0", as + * distinct from other void pointers. + * - If (x) is an integer constant expression, then the "* 0l" resolves + * it into an integer constant expression of value 0. Since it is cast to + * "void *", this makes the second operand a null pointer constant. + * - If (x) is not an integer constant expression, then the second operand + * resolves to a void pointer (but not a null pointer constant: the value + * is not an integer constant 0). + * - The conditional operator's third operand, "(int *)8", is an object + * pointer (to type "int"). + * - The behavior (including the return type) of the conditional operator + * ("operand1 ? operand2 : operand3") depends on the kind of expressions + * given for the second and third operands. This is the central mechanism + * of the macro: + * - When one operand is a null pointer constant (i.e. when x is an integer + * constant expression) and the other is an object pointer (i.e. our + * third operand), the conditional operator returns the type of the + * object pointer operand (i.e. "int *"). Here, within the sizeof(), we + * would then get: + * sizeof(*((int *)(...)) == sizeof(int) == 4 + * - When one operand is a void pointer (i.e. when x is not an integer + * constant expression) and the other is an object pointer (i.e. our + * third operand), the conditional operator returns a "void *" type. + * Here, within the sizeof(), we would then get: + * sizeof(*((void *)(...)) == sizeof(void) == 1 + * - The equality comparison to "sizeof(int)" therefore depends on (x): + * sizeof(int) == sizeof(int) (x) was a constant expression + * sizeof(int) != sizeof(void) (x) was not a constant expression + */ +#define __is_constexpr(x) (sizeof(int) == sizeof(*(8 ? ((void *)((long)(x) * 0l)) : (int *)8))) + +/** + * BUILD_BUG_ON_MSG - break compile if a condition is true & emit supplied + * error message. + * @condition: the condition which the compiler should know is false. + * + * See BUILD_BUG_ON for description. + */ +#define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg) + +/** + * static_assert - check integer constant expression at build time + * + * static_assert() is a wrapper for the C11 _Static_assert, with a + * little macro magic to make the message optional (defaulting to the + * stringification of the tested expression). + * + * Contrary to BUILD_BUG_ON(), static_assert() can be used at global + * scope, but requires the expression to be an integer constant + * expression (i.e., it is not enough that __builtin_constant_p() is + * true for expr). + * + * Also note that BUILD_BUG_ON() fails the build if the condition is + * true, while static_assert() fails the build if the expression is + * false. + */ +#define static_assert(expr, ...) __static_assert(expr, ##__VA_ARGS__, #expr) +#define __static_assert(expr, msg, ...) _Static_assert(expr, msg) + +#endif // _UTILS_COMPILER_H diff --git a/utils/include/utils/defs.h b/utils/include/utils/defs.h index a6c8b92..a976183 100644 --- a/utils/include/utils/defs.h +++ b/utils/include/utils/defs.h @@ -30,8 +30,8 @@ * subtraction to return the pointer to the enclosing type. */ #ifndef container_of -#define container_of(member_ptr, containing_type, member) \ - ((containing_type *)((char *)(member_ptr)-offsetof(containing_type, member)) + \ +#define container_of(member_ptr, containing_type, member) \ + ((containing_type *)((char *)(member_ptr) - offsetof(containing_type, member)) + \ check_types_match(*(member_ptr), ((containing_type *)0)->member)) #endif @@ -80,7 +80,7 @@ * * Returns true if the integer is a power of two. */ -#define is_power_of_two(x) ((x) != 0 && !((x) & ((x)-1))) +#define is_power_of_two(x) ((x) != 0 && !((x) & ((x) - 1))) /** * align_up - rounds a value up to an alignment @@ -89,10 +89,10 @@ * * Returns an aligned value. */ -#define align_up(x, align) \ - ({ \ - assert(is_power_of_two(align)); \ - (((x)-1) | ((typeof(x))(align)-1)) + 1; \ +#define align_up(x, align) \ + ({ \ + assert(is_power_of_two(align)); \ + (((x) - 1) | ((typeof(x))(align) - 1)) + 1; \ }) /** @@ -102,10 +102,10 @@ * * Returns an aligned value. */ -#define align_down(x, align) \ - ({ \ - assert(is_power_of_two(align)); \ - ((x) & ~((typeof(x))(align)-1)); \ +#define align_down(x, align) \ + ({ \ + assert(is_power_of_two(align)); \ + ((x) & ~((typeof(x))(align) - 1)); \ }) /** @@ -115,7 +115,7 @@ * * Returns true if the value is aligned. */ -#define is_aligned(x, align) (((x) & ((typeof(x))(align)-1)) == 0) +#define is_aligned(x, align) (((x) & ((typeof(x))(align) - 1)) == 0) /** * div_up - divides two numbers, rounding up to an integer @@ -124,7 +124,7 @@ * * Returns a rounded-up quotient. */ -#define div_up(x, d) ((((x) + (d)-1)) / (d)) +#define div_up(x, d) ((((x) + (d) - 1)) / (d)) /** * Define an array of per-cpu variables, make the array size a multiple of @@ -333,7 +333,7 @@ static __always_inline void __write_once_size(volatile void *p, void *res, int s #define CACHE_LINE_SIZE 64 -/* multiply u64 with u32 */ +/* multiply uint64_t with uint32_t */ static inline uint64_t mul_u64_u32_shr(uint64_t a, uint32_t mul, unsigned int shift) { uint32_t ah, al; @@ -348,3 +348,109 @@ static inline uint64_t mul_u64_u32_shr(uint64_t a, uint32_t mul, unsigned int sh return ret; } + +#define div64_long(x, y) div64_s64((x), (y)) +#define div64_ul(x, y) div64_u64((x), (y)) + +/** + * div_u64_rem - unsigned 64bit divide with 32bit divisor with remainder + * @dividend: unsigned 64bit dividend + * @divisor: unsigned 32bit divisor + * @remainder: pointer to unsigned 32bit remainder + * + * Return: sets ``*remainder``, then returns dividend / divisor + * + * This is commonly provided by 32bit archs to provide an optimized 64bit + * divide. + */ +static inline uint64_t div_u64_rem(uint64_t dividend, uint32_t divisor, uint32_t *remainder) +{ + *remainder = dividend % divisor; + return dividend / divisor; +} + +/** + * div_s64_rem - signed 64bit divide with 32bit divisor with remainder + * @dividend: signed 64bit dividend + * @divisor: signed 32bit divisor + * @remainder: pointer to signed 32bit remainder + * + * Return: sets ``*remainder``, then returns dividend / divisor + */ +static inline int64_t div_s64_rem(int64_t dividend, int32_t divisor, int32_t *remainder) +{ + *remainder = dividend % divisor; + return dividend / divisor; +} + +/** + * div64_u64_rem - unsigned 64bit divide with 64bit divisor and remainder + * @dividend: unsigned 64bit dividend + * @divisor: unsigned 64bit divisor + * @remainder: pointer to unsigned 64bit remainder + * + * Return: sets ``*remainder``, then returns dividend / divisor + */ +static inline uint64_t div64_u64_rem(uint64_t dividend, uint64_t divisor, uint64_t *remainder) +{ + *remainder = dividend % divisor; + return dividend / divisor; +} + +/** + * div64_uint64_t - unsigned 64bit divide with 64bit divisor + * @dividend: unsigned 64bit dividend + * @divisor: unsigned 64bit divisor + * + * Return: dividend / divisor + */ +static inline uint64_t div64_u64(uint64_t dividend, uint64_t divisor) +{ + return dividend / divisor; +} + +/** + * div64_int64_t - signed 64bit divide with 64bit divisor + * @dividend: signed 64bit dividend + * @divisor: signed 64bit divisor + * + * Return: dividend / divisor + */ +static inline int64_t div64_s64(int64_t dividend, int64_t divisor) +{ + return dividend / divisor; +} + +/** + * div_uint64_t - unsigned 64bit divide with 32bit divisor + * @dividend: unsigned 64bit dividend + * @divisor: unsigned 32bit divisor + * + * This is the most common 64bit divide and should be used if possible, + * as many 32bit archs can optimize this variant better than a full 64bit + * divide. + * + * Return: dividend / divisor + */ +#ifndef div_u64 +static inline uint64_t div_u64(uint64_t dividend, uint32_t divisor) +{ + uint32_t remainder; + return div_u64_rem(dividend, divisor, &remainder); +} +#endif + +/** + * div_int64_t - signed 64bit divide with 32bit divisor + * @dividend: signed 64bit dividend + * @divisor: signed 32bit divisor + * + * Return: dividend / divisor + */ +#ifndef div_s64 +static inline int64_t div_s64(int64_t dividend, int32_t divisor) +{ + int32_t remainder; + return div_s64_rem(dividend, divisor, &remainder); +} +#endif \ No newline at end of file diff --git a/utils/include/utils/minmax.h b/utils/include/utils/minmax.h new file mode 100644 index 0000000..27d8aee --- /dev/null +++ b/utils/include/utils/minmax.h @@ -0,0 +1,81 @@ +#ifndef _UTILS_MINMAX_H +#define _UTILS_MINMAX_H + +#include "compiler.h" + +#define __cmp_op_min < +#define __cmp_op_max > + +#define __cmp(op, x, y) ((x)__cmp_op_##op(y) ? (x) : (y)) + +#define __cmp_once_unique(op, type, x, y, ux, uy) \ + ({ \ + type ux = (x); \ + type uy = (y); \ + __cmp(op, ux, uy); \ + }) + +#define __cmp_once(op, type, x, y) \ + __cmp_once_unique(op, type, x, y, __UNIQUE_ID(x_), __UNIQUE_ID(y_)) + +#define __careful_cmp_once(op, x, y, ux, uy) \ + ({ \ + __auto_type ux = (x); \ + __auto_type uy = (y); \ + BUILD_BUG_ON_MSG(!__types_ok(x, y, ux, uy), #op "(" #x ", " #y ") signedness error"); \ + __cmp(op, ux, uy); \ + }) + +#define __careful_cmp(op, x, y) __careful_cmp_once(op, x, y, __UNIQUE_ID(x_), __UNIQUE_ID(y_)) + +/** + * min - return minimum of two values of the same or compatible types + * @x: first value + * @y: second value + */ +#define min(x, y) __careful_cmp(min, x, y) + +/** + * max - return maximum of two values of the same or compatible types + * @x: first value + * @y: second value + */ +#define max(x, y) __careful_cmp(max, x, y) + +/** + * max_t - return maximum of two values, using the specified type + * @type: data type to use + * @x: first value + * @y: second value + */ +#define max_t(type, x, y) __cmp_once(max, type, x, y) + +#define __clamp(val, lo, hi) ((val) >= (hi) ? (hi) : ((val) <= (lo) ? (lo) : (val))) + +#define __clamp_once(val, lo, hi, uval, ulo, uhi) \ + ({ \ + __auto_type uval = (val); \ + __auto_type ulo = (lo); \ + __auto_type uhi = (hi); \ + static_assert(__builtin_choose_expr(__is_constexpr((lo) > (hi)), (lo) <= (hi), true), \ + "clamp() low limit " #lo " greater than high limit " #hi); \ + BUILD_BUG_ON_MSG(!__types_ok3(val, lo, hi, uval, ulo, uhi), \ + "clamp(" #val ", " #lo ", " #hi ") signedness error"); \ + __clamp(uval, ulo, uhi); \ + }) + +#define __careful_clamp(val, lo, hi) \ + __clamp_once(val, lo, hi, __UNIQUE_ID(v_), __UNIQUE_ID(l_), __UNIQUE_ID(h_)) + +/** + * clamp - return a value clamped to a given range with strict typechecking + * @val: current value + * @lo: lowest allowable value + * @hi: highest allowable value + * + * This macro does strict typechecking of @lo/@hi to make sure they are of the + * same type as @val. See the unnecessary pointer comparisons. + */ +#define clamp(val, lo, hi) __careful_clamp(val, lo, hi) + +#endif // _UTILS_MINMAX_H