Tag

scheduling

50 articles

Oct 12, 2026 Issue Queue Wakeup and Select: The Scheduler Inside the Window How a queue of waiting instructions learns that its operands are ready, how one instruction per port is chosen each cycle, and why the broadcast network is the hard part. computer architecture
Oct 7, 2026 OFDMA Scheduling and Multi-User Transmission in Wi-Fi How a 20 MHz channel is split into resource units, how a trigger frame coordinates simultaneous uplinks, and what the scheduling overhead costs. networking
Sep 25, 2026 Topological Readiness in Workflow Dependency Graphs How a scheduler decides which task may start, why the dependency edge carries ordering rather than data, and what the critical path bounds. data engineering
Sep 6, 2026 Priority and Fair Queueing for Mixed Traffic How strict priority starves low classes, how deficit round robin allocates bandwidth by packet size, and how the two combine on an access link. networking
Aug 21, 2026 Scheduling Batch Training Against Shared Accelerator Capacity Gang scheduling, quota partitioning, and preemption for training jobs: why a GPU job is not a long-running process, and what fair sharing costs. machine learning
Aug 20, 2026 Time-Slicing and What a GPU Context Switch Costs Preemption on a GPU is not one operation but several, each at a different granularity, and the cost of switching decides whether oversubscription is worth it. gpu computing
Jul 29, 2026 Rotation Coverage Math and the Handoff Contract How 168 hours of weekly coverage divide across a team, what shift length costs, and what has to cross the boundary at every handoff. devops
Jul 8, 2026 Growable Stacks and Reduction Budgets in Coroutine Runtimes How a runtime gives each coroutine its own stack segment, why segmented and copied stacks differ, and how a preemption counter bounds the work a coroutine can do. programming languages
Jun 22, 2026 CPU Affinity Masks and What Pinning Actually Costs How a task affinity mask restricts the scheduler, why pinning a thread can lower latency and raise queueing at the same time, and what the load balancer does when every task is pinned. memory systems
Jun 18, 2026 Iteration-Level Batching and the Cost of a Fixed Batch Why a batch fixed at admission time strands accelerator capacity, and how re-deciding the batch at every decode step changes the cost of a token. inference systems
Jun 17, 2026 Work Stealing and the Cost of Task Granularity How per-worker deques with stealing keep locality for producers and absorb imbalance, why the victim is chosen at the tail, and where the stealing overhead overtakes the gain. performance engineering
May 30, 2026 Deadline-Aware Batching and Tenant Fairness When a batch is full, admission becomes an arbitration problem. Deadline slack, tenant shares, and starvation bounds each answer a different question about who gets the next slot. inference systems
May 22, 2026 Aggregating Task Estimates: Why Summed Ranges Come Out Too Narrow Why adding per-task ranges produces an interval that is too tight for the whole job, how skew and correlation break the diversification argument, and what to compute instead. software engineering
Apr 9, 2026 Requests, Limits, and the Two Different Jobs They Do A request is a scheduling promise and a limit is an enforcement ceiling; conflating them produces nodes that look full but throttle, and pods that are evicted for reasons nobody expected. cloud infrastructure
Apr 6, 2026 Threads, Scheduler Activations and the Failed Promise of User-Level Scheduling How user-level threads multiplex onto kernel threads, what scheduler activations promised in exchange for replacing the kernel scheduler, and why the mechanism was displaced by kernel-managed blocking without ever being implemented widely. computing history
Mar 12, 2026 Scheduling and Preemption on Accelerator Queues Why a device queue is a scheduling entity, how hardware contexts make preemption possible, and what mid-kernel eviction costs when the device has no save state. computer architecture
Mar 3, 2026 Logical Dates, Interval Boundaries, and Catchup Semantics Why a scheduled run carries a date it did not start on, how intervals are made half-open, and what happens when the schedule falls behind. data engineering
Feb 25, 2026 Heterogeneous Cores and the Area-Performance Frontier Why a large core and a small core can be combined to beat either alone, how area efficiency curves determine the mix, and what thread migration costs. computer architecture
Jan 13, 2026 Measuring Time a Thread Spends Blocked Instead of Running on-CPU sampling cannot see waiting; reconstructing blocked time requires scheduler tracepoints, state transitions, and a model of what "running" excludes. performance engineering
Jan 12, 2026 Deadline-Aware Batch Assembly Turning latency targets into per-step scheduling decisions: slack, remaining-work estimates, and why maximising throughput and meeting deadlines diverge. inference systems
Jan 10, 2026 Liveness and Fairness in Temporal Specifications Why safety properties need only one bad state to fail while liveness needs an infinite execution, and how a fairness assumption turns a starving scheduler into a specification bug. software engineering
Jan 5, 2026 Preemption by Swap Versus Recomputation When the cache pool cannot serve a running sequence, the scheduler must take memory back; the two recovery strategies have different costs that depend on sequence length. inference systems
Dec 31, 2025 Airtime Fairness and Why One Slow Client Halves a Cell How per-station throughput diverges from per-station airtime, how frame duration is computed from rate and size, and what a scheduler can do about it. networking
Dec 30, 2025 Timer Coalescing and the Deferrable Work Budget How a kernel batches timer expiries, how slack and tolerance let a deadline drift, and why a wakeup that can wait is worth more than one that cannot. mobile computing
Dec 19, 2025 Cron Triggers, Misfire Policy, and the Runs That Never Happen Turning a recurrence expression into at-most-one job per period, choosing what to do with slots missed during downtime, and why a schedule that never fires is invisible without an external expectation. backend systems
Dec 8, 2025 Power of Two Choices and the Cost of a Random Probe Why sampling two backends and picking the less loaded one beats both random assignment and global state, and how stale or misleading load signals degrade the guarantee. backend systems
Oct 8, 2025 Critical Sections, Futexes, and What a Mutex Really Costs The path a mutex takes from uncontended atomic to sleeping thread, how Linux futexes avoid a syscall in the common case, and why uncontended cost predictions fail under contention. performance engineering
Oct 8, 2025 Pipeline Parallelism: Filling the Bubble and Paying for It Micro-batch pipelining lets layers be split across devices, but the schedule leaves idle slots. How bubble fraction scales with depth and why interleaved schedules help. deep learning
Oct 3, 2025 Holding Delayed Jobs: Buckets, Timers, and the Cost of Time-Ordered Scans Why millions of future-dated jobs concentrate contention on one index page, how time bucketing and a separate promotion step spread it, and where in-memory timer wheels fit. backend systems
Sep 17, 2025 Cold Start Anatomy: What Happens Between a Request and the First Instruction The stages a function invocation passes through before user code runs, which stages dominate the delay, and why warm pools change the shape of the curve. cloud infrastructure
Sep 3, 2025 High-Level Synthesis: Scheduling, Binding, and the Latency-Area Trade How a C-level description becomes a datapath through dependency scheduling and resource binding, why the loop and array decisions dominate the result, and where the generated hardware diverges from the source. hardware engineering
Aug 1, 2025 The Main Thread Message Queue and Why a Single Long Task Delays Frames How a looper serializes work onto one thread, how synchronization barriers let frame callbacks overtake queued messages, and what makes a task on the queue expensive beyond its own duration. mobile computing
Apr 8, 2025 Placement as Bin Packing: Multi-Dimensional Fit and the Fragmentation It Creates Why a scheduler with free cores and free memory can still refuse a pod, how multi-dimensional packing produces unusable holes, and which scoring functions trade density against headroom. cloud infrastructure
Mar 26, 2025 The URL Frontier: Priority Queues Behind Per-Host Politeness How a crawler satisfies two conflicting orderings at once, using a randomized priority front end and a back end of per-host queues keyed by ready time. information retrieval
Jan 14, 2025 Head-of-Line Blocking in a Shared Worker Pool Why one slow request class poisons the latency of every class behind it in a FIFO queue, and which partitioning or scheduling schemes actually remove the convoy. backend systems
Dec 30, 2024 Quota Arithmetic: Why a Shared Pool Cannot Promise Every Tenant Its Share Requests, limits, and overcommit interact through the scheduler and the cgroup hierarchy. How to compute whether a set of quotas fits a pool, and where the arithmetic stops being safe. virtualization
Dec 26, 2024 Filtering and Scoring: How a Scheduler Picks One Node Out of Thousands The two-phase placement cycle, why feasibility is computed per node instead of per constraint, and how scoring turns a set of legal nodes into a single binding decision. virtualization
Nov 29, 2024 Timer Clamping, Background Throttling, and Cooperative Yielding The integer arithmetic and nesting rules behind setTimeout, why intervals do not catch up, and how scheduler priority levels change when a callback runs. web platform
Nov 23, 2024 Frame Budgets, Long Tasks, and Where Input Latency Comes From How the main thread allocates work to a frame, why a 50 ms task delays the next interaction by more than 50 ms, and which scheduling primitives actually yield. web platform
Sep 16, 2024 Task Sources and the Ordering Guarantees of the Event Loop Why the browser runs callbacks from several independent queues, what ordering the specification actually promises, and where cross-queue assumptions break. web platform
Sep 12, 2024 Multiplexing Green Threads onto Kernel Threads How an M:N scheduler maps lightweight tasks onto a fixed pool of OS threads, what work stealing does to locality, and where a blocking call forces the scheduler to compensate. programming languages
Feb 2, 2024 Automatic NUMA Balancing and Its Failure Modes How the kernel samples faults to discover which node a task is really using, moves pages toward the task, and why the mechanism sometimes makes a workload slower than leaving it alone. memory systems
Jan 19, 2024 Deterministic Replay: Recording a Thread Schedule and Playing It Back What must be captured to reproduce an execution exactly, why recording the interleaving is not enough, and how replay trades observability for the ability to repeat a failure. systems programming
Oct 26, 2023 Scheduling a Job Graph Around Its Critical Path The longest path through the dependency graph bounds pipeline latency regardless of machine count, and the cost of fan-out decides whether widening the graph helps at all. devops
Sep 14, 2023 Work Stealing: Per-Processor Deques and Why Thieves Take the Oldest Task How a work-stealing scheduler keeps locality by pushing and popping on one end of a deque while idle processors take from the other, and where the contention lands. algorithms
Aug 30, 2023 High-Level Synthesis: Scheduling, Binding, and Inferred Hardware How a C function becomes a datapath, why the clock period constraint drives scheduling decisions, and what the interface protocol synthesis chooses on the designer's behalf. hardware engineering
Feb 22, 2023 Sequencing Work by Cost of Delay Under Precedence Constraints Why the weight-over-duration ratio is the exact ordering rule for one machine, what changes when dependencies and deadlines enter the model, and where the ratio becomes numerically fragile. software engineering
Feb 15, 2023 Scheduling a Parallel Build from a Dependency Graph A build is a DAG of commands with known costs and unknown costs alike. Choosing what to run next determines both wall-clock time and how badly a late-discovered dependency hurts. compilers
Dec 20, 2022 Critical Path, Float, and Why the Longest Chain Sets the Date How the forward and backward passes compute earliest and latest dates, what total float measures, and why a zero-float path is not necessarily the riskiest one. software engineering
Oct 18, 2022 Admission Control and the Memory Watermark Reserving headroom so that growth does not become preemption: how watermarks, reservation bounds, and head-of-line blocking interact in a cache pool. inference systems