betaFeedback

WorksComputer Science

Restoring Fair Hrtick Re-arming After Same-Task Repicks in the Linux EEVDF Scheduler

Abstract

Linux uses one-shot high-resolution scheduler ticks (hrticks) to request rescheduling at fair-class execution boundaries. We analyze a gap in the dispatch path in which an expired fair hrtick is not restarted when the fair scheduler selects the current task again. The gap arises because the same-task fast path bypasses set_next_task_fair(), the location that normally records the next fair hrtick delay. We introduce SNT_REPICK, an explicit same-task activation type for struct sched_class. For fair tasks, it preserves the fast path while restarting the hrtick from refreshed EEVDF state. For SCHED_DEADLINE, it deliberately performs no hrtick restart because the corresponding runtime state is not refreshed on a repick. The implementation was merged into the mainline Linux kernel as commit c72945693b. We give a conditional timing analysis for systems on which the periodic scheduler tick remains active and report validation from two platforms. Functional tests on an 80-core Ampere Altra exercised fair hrtick, deadline hrtick, and the CONFIG_HIGH_RES_TIMERS=n fallback. Independently, Intel's 0-Day Kernel Test Service reported a 34.2% increase in its stress-ng.rawudp.packets_32_bytes_received_per_sec metric on a 192-thread Intel Xeon 6740E under the documented test configuration. We distinguish this reported benchmark result from causal claims that require separate scheduler and network instrumentation.

Introduction

Operating systems deployed across cloud datacenters and high-performance computing (HPC) nodes must arbitrate compute capacity among heterogeneous workloads. Batch simulations, networking daemons, and message-passing pipelines can share processor cores, making both proportional allocation and timely scheduling decisions important [4]. The CPU scheduler is the operating-system component that mediates these decisions [5].

For nearly seventeen years, the default general-purpose scheduler in the Linux kernel was the Completely Fair Scheduler (CFS) [4]. CFS approximated Generalized Processor Sharing (GPS) by balancing tasks across red-black trees indexed by virtual execution time (vruntime). However, CFS inherently conflated throughput allocation with dispatch latency, relying on an intricate web of ad-hoc heuristics (such as sleeper credits, wake-up preemption granularity tunables, and latency-sensitive burst mechanisms) to prevent interactive starvation [4]. In Linux version 6.6, the kernel transitioned its fair scheduling class to the Earliest Eligible Virtual Deadline First (EEVDF) scheduler [6, 2]. EEVDF formally decouples bandwidth allocation (governed by entity weights wiw_i) from dispatch latency (governed by request slices qiq_i and virtual deadlines did_i).

In current Linux kernels, EEVDF supplies the selection policy within the fair scheduling class. Linux configurations using conventional periodic ticks inspect task state at a frequency selected by CONFIG_HZ, commonly 100–1000 Hz [10]. Where enabled, CONFIG_SCHED_HRTICK supplements this mechanism with one-shot high-resolution timer events. Hrticks request rescheduling at a calculated fair-scheduling boundary; they do not by themselves establish an end-to-end application-latency guarantee.

Missed Fair-Hrtick Restart on a Same-Task Repick

The implementation before commit c72945693b contained a long-standing activation gap in the core scheduler dispatch loop (kernel/sched/core.c and kernel/sched/fair.c):

  1. One-Shot Timer Mechanics: Hardware timers armed via hrtick_start_fair() are programmed as one-shot events. Upon expiration, the timer disarms, enters interrupt context, and marks the task for rescheduling by setting TIF_NEED_RESCHED.

  1. Same-Task Selection in Saturated Runtimes: During the invocation of __schedule(), the scheduling class picks the next entity. In high-concurrency polling loops (e.g., multi-threaded raw UDP ingestion), the current task frequently remains the earliest eligible task with the minimum deadline.

  1. The Fast-Path Dispatcher Bypass: To minimize context-switch latency, put_prev_set_next_task() checks whether next==prevnext == prev. If true, the legacy kernel executed an immediate return, bypassing the scheduling class method set_next_task_fair().

  1. The Missed Restart: Because set_next_task_fair() was bypassed, no subsequent fair high-resolution timer was armed. The task returned to user space with its one-shot timer expired and cleared. On a configuration with an active periodic tick and absent another scheduling event, the next periodic tick is the next scheduler timing opportunity.

The defect can defer the next fair hrtick after a same-task repick. Its application-level impact depends on workload, kernel configuration, tick behavior, and other rescheduling events; these factors motivate the scoped analysis and measurements in this paper.

Contributions

In this paper, we analyze and repair this missed restart:

  • Conditional Timing Analysis: We formulate the delay caused by a lost one-shot timer under explicit periodic-tick assumptions and identify why the bound does not generalize unchanged to tickless configurations.

  • The SNT_REPICK Architectural Protocol: We introduce a unified scheduler activation protocol into struct sched_class, defining explicit semantics for normal activation (SNT_NORMAL), cross-task switches (SNT_PICK), and same-task repicks (SNT_REPICK).

  • Cross-Class Safety: We explain why a fair repick can restart its hrtick after the fair entity state is refreshed, whereas a deadline repick must not restart its hrtick from stale runtime state.

  • Evidence and Scope: We document functional validation on Ampere Altra and a public 0-Day Kernel Test Service comparison that reports a 34.2% improvement in one stress-ng.rawudp metric on Intel Xeon 6740E hardware [8].

Background and Mathematical Formulation

Generalized Processor Sharing and EEVDF Mechanics

Consider a system with NN active runnable entities T={T1,T2,…,TN}\mathcal{T} = \{T_1, T_2, \ldots, T_N\}. Each entity TiT_i is characterized by a static or dynamic weight wi>0w_i > 0 and an allocated time slice quantum qi>0q_i > 0. The total runqueue weight is W=∑j=1NwjW = \sum_{j=1}^{N} w_j.

In an ideal Generalized Processor Sharing (GPS) model [1], the system virtual time V(t)V(t) progresses inversely proportional to the aggregate weight:

V(t)=∫0t1W(τ) dτ(1)V(t) = \int_{0}^{t} \frac{1}{W(\tau)} \, d\tau \tag*{(1)}

For any task TiT_i running continuously on a physical processor over physical time interval [t,t+Δt)[t, t + \Delta t), its allocated virtual runtime advances as:

vi(t+Δt)=vi(t)+Δtwi(2)v_i(t + \Delta t) = v_i(t) + \frac{\Delta t}{w_i} \tag*{(2)}

EEVDF ensures proportional share allocation by maintaining the allocation lag [2]:

lagi(t)=V(t)−vi(t)(3)lag_i(t) = V(t) - v_i(t) \tag*{(3)}

An entity is eligible to execute if and only if lag⁡i(t)≥0⟺vi(t)≤V(t)\operatorname{lag}_i(t) \ge0 \Longleftrightarrow v_i(t) \le V(t). When eligible, its priority is ordered by its virtual deadline di(t)d_i(t):

di(t)=vi(t)+qiwi(4)d_i(t) = v_i(t) + \frac{q_i}{w_i} \tag*{(4)}

The scheduler selects the entity T∗(t)T^*(t) satisfying:

T∗(t)=arg⁡min⁡Ti∈T, vi(t)≤V(t){di(t)}(5)T^*(t) = \underset{T_i \in\mathcal{T},\, v_i(t) \le V(t)}{\arg\min} \{d_i(t)\} \tag*{(5)}

High-Resolution Preemption and a Conditional Disarming Bound

When CONFIG_SCHED_HRTICK is enabled, the kernel records a delay for a high-resolution timer event at physical time:

tpreempt=tcurrent+δslice(6)t_{\mathrm{preempt}} = t_{\mathrm{current}} + \delta_{\mathrm{slice}} \tag*{(6)}

where δslice=min⁡(qi−Δtconsumed,δquantum)\delta_{\mathrm{slice}} = \min(q_i - \Delta t_{\mathrm{consumed}}, \delta_{\mathrm{quantum}}).

Definition 1 (Timer-Event Delay). Let ϵirq\epsilon_{\mathrm{irq}} denote the delay from an hrtick expiry to the execution of its interrupt handler. This is a timer-event quantity, not an end-to-end application-latency bound:

Ltimer≤ϵirq(7)\mathcal{L}_{\mathrm{timer}} \le\epsilon_{\mathrm{irq}} \tag*{(7)}

Proposition 1 (Conditional delay after a lost fair hrtick). Assume that (i) the periodic scheduler tick remains active with frequency fhzf_{\mathrm{hz}}, (ii) no earlier wakeup, interrupt, or explicit yield invokes scheduling, and (iii) the same task remains runnable. Let τjiffy=1/fhz\tau_{\mathrm{jiffy}} = 1/f_{\mathrm{hz}}. If a same-task repick skips timer re-arming at physical time t0t_0, the time until the next periodic scheduling opportunity is bounded by:

0<ΔS≤τjiffy.(8)0 < \Delta S \le\tau_{\mathrm{jiffy}}. \tag*{(8)}

Proof. Under the stated assumptions, hrtick expiry leaves no newly armed fair hrtick after the fast-path return. The next periodic tick occurs no later than one tick period after t0t_0, giving the bound. The proposition does not apply to tickless operation, to CPUs for which the periodic tick is stopped, or when another event causes scheduling earlier.

Lemma 2 (Weighted delay model). Let the runnable competitors of TiT_i have aggregate weight W−wiW - w_i. In the simplified work-conserving model used here, a lost scheduling opportunity of duration ΔS\Delta S defers their aggregate proportional service by:

Dqueue=W−wiW⋅ΔS.(9)D_{\mathrm{queue}} = \frac{W - w_i}{W} \cdot\Delta S. \tag*{(9)}

For example, with CONFIG_HZ=250, τjiffy=4\tau_{\mathrm{jiffy}} = 4 ms. A lost hrtick can therefore defer the next periodic scheduling opportunity by nearly 4 ms under the proposition’s assumptions. This example is a scheduler-level timing bound; it does not by itself establish packet loss, throughput loss, or an application-latency bound.

The SNT_REPICK Protocol Architecture

To repair the missing activation while preserving the same-task fast path, the merged patch introduces the Same-Next-Task Repick (SNT_REPICK) activation type [7].

Formal State Machine

Prior to our patch, the scheduling class interface exposed a boolean flag first to set_next_task():

void (*set_next_task)(struct rq *rq, struct task_struct *p, bool first);

This binary representation could not distinguish between a fresh task selection after a context switch and a same-task reselection within the fast-path. We replaced this flag across the kernel with an explicit enumeration:

Illustrative timing profile showing baseline Linux Kernel with disarmed timer failure and patched SNT_REPICK with continuous enforcement

Figure 1. Illustrative timing profile under the active-periodic-tick assumptions in Section 2. In the baseline, skipping set_next_task_fair() leaves no fair hrtick active. SNT_REPICK records the next fair hrtick delay at every repick boundary.

enum snt_e {
    SNT_NORMAL, /* External task activation via set_next_task() */
    SNT_PICK,   /* put_prev_set_next_task(): Standard transition (prev != next) */
    SNT_REPICK, /* put_prev_set_next_task(): Fast-path repick (prev == next) */
};

The following exact hunk from kernel/sched/sched.h shows the relevant dispatch change:

static inline void put_prev_set_next_task(struct rq *rq,
                                          struct task_struct *prev,
                                          struct task_struct *next)
{
    __put_prev_set_next_dl_server(rq, prev, next);

    if (next == prev) {
        next->sched_class->set_next_task(rq, next, SNT_REPICK);
        return;
    }

    prev->sched_class->put_prev_task(rq, prev, next);
    next->sched_class->set_next_task(rq, next, SNT_PICK);
}
SNT_REPICK dispatcher state-machine transition in put_prev_set_next_task()

Figure 2. The SNT_REPICK dispatcher state-machine transition in put_prev_set_next_task(). Fair tasks safely re-arm their one-shot hardware tick timers while real-time deadline tasks bypass re-arming to preserve execution budget invariants.

Fair Scheduling Class Realization (kernel/sched/fair.c)

Handling SNT_REPICK within set_next_task_fair() requires decoupling timer maintenance from structural entity accounting:

  1. Bypassing Structural State Updates: On a repick, the task is already active on the CPU. The scheduler skips clear_buddies(), update_misfit_status(), and task group throttle validation.

  2. Entity Runtime Refresh Guarantee: Under EEVDF, before pick_task_fair() selects an entity again, it invokes update_curr() to refresh virtual runtime metrics and slice consumption. Therefore, rq->cfs.curr reflects fresh runtime metrics.

  3. Two-Stage Timer Re-Arming: The repick branch jumps directly to timer re-arming. hrtick_start_fair() computes the quantum duration and stores the delay offset; when __schedule() exits and releases runqueue locks, hrtick_schedule_exit() programs the physical timer with zero lock contention.

The next listing is abridged pseudocode. It isolates the new repick branch; the complete implementation, including fair-class accounting and task-group handling, is in the merged commit [7].

static void set_next_task_fair(struct rq *rq, struct task_struct *p, enum snt_e type)
{
    struct sched_entity *se = &p->se;
    struct cfs_rq *cfs_rq = &rq->cfs;
    bool first = (type == SNT_PICK);

    if (type == SNT_REPICK)
        goto repick;

    clear_buddies(cfs_rq, se);
    if (se->on_rq) {
        /* Standard accounting and queue management */
        update_stats_wait_end_fair(cfs_rq, se);
        __dequeue_entity(cfs_rq, se);
        update_load_avg_fair(cfs_rq, se);
    }

    update_misfit_status(p, rq);
    sched_fair_update_stop_tick(rq, p);

repick:
    /*
     * A same-task repick skips put_prev_task_fair(), but
     * pick_task_fair() refreshed the entity hrtick_start_fair() reads
     * before selecting it again. rq->cfs.curr identifies that entity,
     * including under group scheduling hierarchies.
     */
    if (hrtick_enabled_fair(rq))
        hrtick_start_fair(rq, p);
}

Cross-Class Invariance & Real-Time Safety Analysis

A critical requirement of our design is ensuring cross-class safety across all scheduling classes in the Linux kernel:

SCHED_DEADLINE Safety (kernel/sched/deadline.c)

A naive implementation would restart timers uniformly across all scheduling classes. In SCHED_DEADLINE, that would use state whose runtime is not refreshed by the same-task picker. Same-task repicks skip put_prev_task(), and pick_task_dl() has no counterpart to the fair current-runtime update. Restarting start_hrtick_dl() on SNT_REPICK could therefore use stale dl_se->runtime and defer the next runtime-enforcement point:

Δtarmed=dl_se→runtimestalescaling_factor(10)\Delta t_{\mathrm{armed}} = \frac{\mathrm{dl\_se} \to\mathrm{runtime}_{\mathrm{stale}}}{\mathrm{scaling\_factor}} \tag*{(10)}

Consequently, set_next_task_dl() explicitly exits immediately upon SNT_REPICK:

static void set_next_task_dl(struct rq *rq, struct task_struct *p, enum snt_e type)
{
    struct sched_dl_entity *dl_se = &p->dl;
    struct dl_rq *dl_rq = &rq->dl;

    if (type == SNT_REPICK)
return;
p->se.exec_start = rq_clock_task(rq);
if (on_dl_rq(&p->dl))
    update_stats_wait_end_dl(dl_rq, dl_se);

WARN_ON_ONCE(dl_rq->curr);
dl_rq->curr = dl_se;

if (type != SNT_PICK)
    return;

if (rq->donor->sched_class != &dl_sched_class)
    start_hrtick_dl(rq, dl_se);
}

SCHED_RT, SCHED_IDLE, SCHED_EXT, and Stop Task

For rt.c, idle.c, stop_task.c, and the extensible BPF scheduler class ext/ext.c [11], SNT_REPICK returns immediately, preventing redundant accounting and isolating execution benefits strictly to the proportional-share domain.

Evaluation and Scope

Validation Platforms

We used two complementary validation paths. Platform A was an 80-core Arm Neoverse-N1 Ampere Altra server at 3.0 GHz with 128 GB DDR4-3200 memory. It was used for functional validation with fair hrtick and DELAY_DEQUEUE enabled, with base_slice_ns=3000000. Smoke tests exercised deadline hrtick paths, and a build with CONFIG_HIGH_RES_TIMERS=n checked the fallback path. These checks establish configuration compatibility, not a standalone quantitative latency result; we therefore do not report local percentile claims without the corresponding trace data and scripts.

Platform B is the public Intel 0-Day Kernel Test Service result reported for a dual-socket, 192-thread Intel Xeon 6740E (Sierra Forest) system with 256 GB memory [8]. The reported job used stress-ng rawudp, 100% thread count, a 60-second test duration, GCC 14, the performance CPU-frequency governor, the x86_64-rhel-9.4 kernel configuration, and a Debian 13 root filesystem. The service’s job specification and reproduction materials are public [9].

Public 0-Day rawudp Comparison

Table 1 transcribes the metrics reported by the 0-Day comparison. The standard-deviation column uses the rounded percent values displayed by the public report for the patched result; the report does not disclose the number of repetitions. Metric names are retained from stress-ng; in particular, MB_recv’d_per_sec is a tool-reported metric and is not independently interpreted as wire bandwidth.

MetricBaselinePatchedChangePatched std. dev.
packets_32_bytes_received_per_sec395.33530.63+34.2%±3%
ops4,559,0986,112,029+34.1%±3%
ops_per_sec76,041101,916+34.0%±3%
MB_recv’d_per_sec0.010.02+100.0%—
Involuntary context switches2,611,0082,999,104+14.9%±5%
User time (s)47.7069.96+46.7%±8%
Voluntary context switches20,919,23329,638,128+41.7%±2%

Table 1. Public Intel 0-Day Kernel Test Service comparison of Linux baseline a9b3c75705 and commit c72945693b on stress-ng.rawudp [8].

The public comparison reports a 34.2% increase in packets_32_bytes_received_per_sec. It is consistent with the repaired hrtick activation path, but it does not isolate a causal mechanism: the available report does not measure socket-buffer occupancy, packet drops, lock contention, cache behavior, or per-task runqueue delay. Those mechanisms require separate scheduler and network instrumentation and are left as future evaluation work.

Limitations

The patch affects the fair scheduling class only when hrticks are enabled. The conditional timing bound in § 2 does not cover tickless operation, CPUs with a stopped periodic tick, or workloads in which another event invokes scheduling before the next tick. The public rawudp result is one workload on one service configuration; it should not be generalized to end-to-end network throughput, packet loss, or arbitrary parallel workloads. A broader performance study should publish raw traces, experiment scripts, run counts, and confidence intervals for each platform.

Related Work

Proportional-share scheduling traces its lineage to Generalized Processor Sharing (GPS) [1] and Deficit Round Robin [3]. Linux CFS made virtual-runtime scheduling widely deployed, while EEVDF separates eligibility and virtual-deadline selection from the allocation model [4, 2, 6]. The present work concerns the activation path after task selection rather than the EEVDF ordering rule itself.

High-resolution timers provide the infrastructure required for short scheduler timing events [10]. Low-latency RPC systems motivate careful control of scheduling delay [12]. Kernel documentation describes the extensible BPF scheduling class (sched_ext) [11]; kernel-bypass operating systems, including IX [13] and Arrakis [14], pursue different approaches to low-latency networking. To our knowledge, the specific interaction between one-shot fair hrtick expiry and same-task repicks was not documented before the upstream patch [7].

Conclusion

This paper analyzed and repaired a missed fair-hrtick restart after same-task repicks in Linux. The SNT_REPICK activation type makes that path explicit, restarts the fair hrtick from refreshed state, and leaves deadline hrticks untouched when their runtime state is not refreshed. The implementation is merged as commit c72945693b [7]. Functional validation covers fair hrtick, deadline hrtick, and the high-resolution-timer fallback; a public 0-Day comparison reports a 34.2% improvement in one stress-ng.rawudp metric [8]. The result motivates a broader study with per-task traces and repeated, artifact-backed measurements across workloads and tick configurations.

Acknowledgements

The author extends sincere gratitude to Peter Zijlstra (Linux Kernel Scheduler Maintainer, Intel) for valuable technical discussions, design suggestions, and upstream review and integration of the core scheduling patch into the Linux kernel tree. The author also thanks Zhan Xusheng for patch review on the Linux Kernel Mailing List, and the Intel 0-Day Kernel Test Robot engineering team for automated hardware performance validation.

CRediT authorship contribution statement

Shubhang Kaushik: Conceptualization, Methodology, Software, Investigation, Validation, Formal Analysis, Data Curation, Writing - Original Draft, Writing - Review & Editing.

Declaration of Competing Interests

The author declares that they have no known competing financial interests or personal relationships that could have appeared to influence the work reported in this paper.

Declaration of Generative AI and AI-Assisted Technologies

During the preparation of this work, the author used generative AI tools strictly for grammar, style checking, and LaTeX typesetting alignment against the Elsevier Journal of Parallel and Distributed Computing author guidelines. After using this service, the author reviewed and edited the content as needed and takes full responsibility for the content of the published article.

Data Availability Statement

The Linux kernel patch, public performance report, and associated reproduction materials are accessible from the following public records:

  • Mainline Git Commit: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=c72945693b90423f1b46ac2dbc8749c2b7804fc8

  • Upstream Repository: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

  • LKML v4 Submission: https://lore.kernel.org/all/[email protected]/

  • 0-Day Benchmark Result: https://lore.kernel.org/lkml/[email protected]/

  • 0-Day Reproduction Materials: https://download.01.org/0day-ci/archive/20261027/[email protected]/

References

  1. [1]A. K. Parekh and R. G. Gallager, “A generalized processor sharing approach to flow control in integrated services networks: The single-node case,” IEEE/ACM Transactions on Networking, vol. 1, no. 3, pp. 344–357, 1993. https://doi.org/10.1109/90.234856
  2. [2]I. Stoica, H. Abdel-Wahab, K. Jeffay, S. K. Baruah, J. E. Gehrke, and C. G. Plaxton, “A proportional share resource allocation algorithm for real-time, time-shared systems,” in Proceedings of the 17th IEEE Real-Time Systems Symposium, pp. 288–299, 1996. https://doi.org/10.1109/REAL.1996.563725
  3. [3]M. Shreedhar and G. Varghese, “Efficient fair queuing using deficit round-robin,” IEEE/ACM Transactions on Networking, vol. 4, no. 3, pp. 375–385, 1996. https://doi.org/10.1109/90.502236
  4. [4]J.-P. Lozi, B. Lepers, J. Funston, F. Gaud, V. Quéma, and A. Fedorova, “The Linux scheduler: A decade of wasted cores,” in Proceedings of the Eleventh European Conference on Computer Systems, pp. 1–16, 2016. https://doi.org/10.1145/2901318.2901326
  5. [5]J. Corbet, “An EEVDF CPU scheduler for Linux,” LWN.net, Mar. 2023. https://lwn.net/Articles/925371/
  6. [6]P. Zijlstra, “[PATCH 00/15] sched/fair: Complete EEVDF implementation,” Linux Kernel Mailing List, May 2023. https://lore.kernel.org/lkml/[email protected]/
  7. [7]S. Kaushik, “sched: Restart fair hrtick after same-task repicks,” Linux kernel source tree, commit c72945693b90423f1b46ac2dbc8749c2b7804fc8, Sep. 2026. https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=c72945693b90423f1b46ac2dbc8749c2b7804fc8
  8. [8]Kernel Test Robot, “[linux:master] [sched] c72945693b: stress-ng.rawudp.packets_32_bytes_received_per_sec 34.2% improvement,” Linux Kernel Mailing List, Oct. 2026. https://lore.kernel.org/lkml/[email protected]/
  9. [9]Kernel Test Robot, “Reproduction materials for stress-ng rawudp result [email protected],” Oct. 2026. https://download.01.org/0day-ci/archive/20261027/[email protected]
  10. [10]T. Gleixner and D. Niehaus, “Hrtimers and beyond: Transforming the Linux time subsystems,” in Proceedings of the Ottawa Linux Symposium, pp. 333–346, 2006. https://www.kernel.org/doc/ols/2006/ols2006v1-pages-333–346.pdf
  11. [11]The Linux Kernel documentation project, “Extensible Scheduler Class,” 2026. https://docs.kernel.org/scheduler/sched-ext.html
  12. [12]A. Kalia, M. Kaminsky, and D. G. Andersen, “Datacenter RPCs can be general and fast,” in 16th USENIX Symposium on Networked Systems Design and Implementation (NSDI 19), pp. 1–16, 2019. https://www.usenix.org/conference/nsdi19/presentation/kaliaarxiv.org/abs/1806.00680
  13. [13]A. Belay, G. Prekas, A. Klimovic, S. Grossman, C. Kozyrakis, and E. Bugnion, “IX: A protected dataplane operating system for high throughput and low latency,” in 11th USENIX Symposium on Operating Systems Design and Implementation (OSDI 14), pp. 49–65, 2014. https://www.usenix.org/conference/osdi14/technical-sessions/presentation/belayDOI
  14. [14]S. Peter, J. Li, I. Zhang, D. R. K. Ports, D. Woos, A. Krishnamurthy, T. Anderson, and T. Roscoe, “Arrakis: The operating system is the control plane,” in 11th USENIX Symposium on Operating Systems Design and Implementation (OSDI 14), pp. 1–16, 2014. https://www.usenix.org/conference/osdi14/technical-sessions/presentation/peter

Paper details

vlnc:W_73ey2cq2
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 1

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

generative AI tools

View statement
Looking for related papers…
Contents