Universal and Asymptotically Optimal Data and Task Allocation in Distributed Computing
Abstract: We study the joint minimization of communication and computation costs in distributed computing, where a master node coordinates $N$ workers to evaluate a function over a library of $n$ files. Assuming that the function is decomposed into an arbitrary subfunction set $\mathbf{X}$, with each subfunction depending on $d$ input files, renders our distributed computing problem into a $d$-uniform hypergraph edge partitioning problem wherein the edge set (subfunction set), defined by $d$-wise dependencies between vertices (files) must be partitioned across $N$ disjoint groups (workers). The aim is to design a file and subfunction allocation, corresponding to a partition of $\mathbf{X}$, that minimizes the communication cost $π{\mathbf{X}}$, representing the maximum number of distinct files per server, while also minimizing the computation cost $δ{\mathbf{X}}$ corresponding to a maximal worker subfunction load. For a broad range of parameters, we propose a deterministic allocation solution, the \emph{Interweaved-Cliques (IC) design}, whose information-theoretic-inspired interweaved clique structure simultaneously achieves order-optimal communication and computation costs, for a large class of decompositions $\mathbf{X}$. This optimality is derived from our achievability and converse bounds, which reveal -- under reasonable assumptions on the density of $\mathbf{X}$ -- that the optimal scaling of the communication cost takes the form $n/N{1/d}$, revealing that our design achieves the order-optimal \textit{partitioning gain} that scales as $N{1/d}$, while also achieving an order-optimal computation cost. Interestingly, this order optimality is achieved in a deterministic manner, and very importantly, it is achieved blindly from $\mathbf{X}$, therefore enabling multiple desired functions to be computed without reshuffling files.
Paper Prompts
Sign up for free to create and run prompts on this paper using GPT-5.
Top Community Prompts
Explain it Like I'm 14
What this paper is about (big picture)
Imagine a teacher (the “master”) has a huge library of n books (data files) and wants N students (workers) to solve a big project (a function). The project can be split into many smaller tasks (subfunctions). Each small task needs exactly d specific books to be done. The teacher’s problem is: how do we split the tasks among the students and hand out as few different books as possible to each student, while keeping the number of tasks per student balanced?
This paper designs a simple, rule-based way to do that splitting so that:
- each student needs to be sent only a small set of books, and
- no student gets overloaded with tasks.
It also proves that this method is about as good as anyone can do, in a broad range of situations.
What questions the paper tries to answer
In plain terms, the paper asks:
- How can we assign tasks and books to many workers so that:
- we send as few different books as possible to any one worker (this is the “communication cost”), and
- we keep the number of tasks per worker as equal as possible (this is the “computation cost”)?
- Can we design one, fixed way to place books on workers that works well for many different projects, without reshuffling books each time?
- What is the best-possible improvement we can ever hope for as we add more workers?
How the method works (explained with everyday ideas)
Think of each task as a “recipe” that needs exactly d ingredients (d specific books). A worker can only cook a recipe if they have all its ingredients. If we give every worker almost every ingredient, they can cook anything—but that’s wasteful. If we give each worker very few ingredients, they might not be able to cook many recipes.
The authors model this as a “connect-the-dots” puzzle:
- Dots = books.
- Each task connects d dots (the books it needs).
- Splitting the tasks among workers is like coloring those connections so each worker gets a set of connections that mostly touch a limited set of dots.
Their solution is called the Interweaved-Cliques (IC) design:
- A “clique” here is just a tightly knit group of connections that mostly touch the same small set of books.
- “Interweaved” means they arrange these cliques across workers in a very regular, overlapping pattern so that:
- each worker focuses on a limited set of books (so we don’t have to send them too many different books), and
- the number of tasks per worker stays balanced.
Two key traits make IC practical:
- It’s deterministic: it’s a clear recipe, not a guess-and-check search.
- It’s “blind”: the book placement does not depend on the exact list of tasks. You can place books once and reuse the same placement for many different projects. For any new project, you just hand each worker the subset of tasks they can do with the books they already have.
A tiny example to visualize:
- Say n = 6 books, d = 2 (each task needs 2 books), N = 3 workers.
- Naively splitting tasks can force one worker to receive all 6 books. A smarter split (like IC) can arrange tasks so each worker only needs 4 books, yet together they cover all tasks.
What the paper found (main results) and why it matters
Here are the main takeaways, phrased simply:
- Near-best possible communication savings: If each task needs d books, and you have N workers, the fewest different books any one worker could hope to receive scales like about n divided by N1/d. The IC design achieves this order of savings (within a constant factor), which is proven to be essentially optimal.
In symbols (just for a feel): the maximum number of different books any worker needs is about n / N1/d.
- Example intuition: If d = 2 and you multiply the number of workers by 100, the “book-load” per worker drops by about 10×. If d = 3, it drops by about 4–5×.
- Balanced workload: The design also keeps the number of tasks per worker reasonably even. Under broad, realistic conditions (when there are lots of tasks spread across the books—not extremely sparse), the busiest worker does at most about 5 times the ideal average. In practice, that means the work is well balanced.
- Universal (“blind”) book placement: You can place books on workers once and then handle many different projects without reshuffling books. Only the task assignment changes. This is very useful if you run many different computations on the same data library (common in data centers, machine learning pipelines, and analytics).
- Solid theory behind it: The paper proves both lower bounds (no one can do much better) and upper bounds (IC achieves it), showing the method is order-optimal. It connects the problem to a well-studied math topic (hypergraph partitioning) and improves understanding there too.
Why this is useful
Many real-world jobs match this “d-books-per-task” pattern:
- Pairwise or triple comparisons in machine learning (e.g., similarity search, kernel methods, triplet loss),
- Statistics (e.g., computing covariances: pairs of variables),
- Scientific simulations (e.g., particle interactions),
- Parts of modern AI like attention mechanisms (which compare pairs of tokens).
In these settings:
- Moving data around (communication) is often the biggest bottleneck.
- Keeping workers equally busy (load balancing) avoids slowdowns.
- Reusing the same data placement for different tasks saves time.
By cutting the book-load per worker to roughly n / N1/d, and keeping work balanced without reshuffling, the IC design can speed up large-scale computing, reduce network congestion, and simplify operations. It’s a practical, easy-to-implement recipe with strong performance guarantees, especially as systems grow bigger and tasks become more numerous.
Knowledge Gaps
Knowledge gaps, limitations, and open questions
Below is a focused list of what remains missing, uncertain, or unexplored in the paper, formulated to be concrete and actionable for future research.
- Deterministic computation-load guarantees for arbitrary subfunction sets: The bound δ ≤ 5 is only shown with high probability under random thinning; provide worst-case (deterministic) δ guarantees or balancing procedures for structured/adversarial task sets X.
- Sparse regime analysis: Characterize optimal communication/computation costs when the normalized size ϕ of X vanishes with n (e.g., ϕ ≪ ln n / n{d/2}); derive tight lower/upper bounds and adapt IC design for very sparse hypergraphs.
- Regime beyond N ≤ (0.9√(n/d))d: Extend achievability/converse results to larger numbers of workers; determine whether the n/N{1/d} scaling persists or saturates, and under what constraints.
- Large-degree regimes: Remove or relax the condition d ≤ n/32; analyze performance and limits when d is a substantial fraction of n.
- Tightening constants in bounds: Bridge the gap between the lower bound ϕ{1/d}·n/N{1/d} and the upper bound (4e)·n/N{1/d}; derive sharper constants (possibly ϕ-dependent) or show optimality of the current constants.
- Near-ideal load balancing: Design schemes that push δ closer to 1 (e.g., δ ≤ 1+ε) and quantify the trade-off between improved δ and π, both in probabilistic and worst-case settings.
- Total communication vs. peak communication: Move beyond minimizing max files per worker (π) to analyze and optimize total traffic (sum of |α(Φ_b)|), including tight Average Replication Factor (ARF) bounds and trade-offs between ARF and π.
- Heterogeneous systems: Generalize the model and IC design to unequal link capacities, heterogeneous worker speeds, and weighted subfunction costs; develop weighted hypergraph formulations and corresponding guarantees for π and δ.
- Network topology and multicast/coding: Study performance under non-parallel links, multi-hop networks, or availability of multicast/coded transmissions; quantify potential gains when moving beyond unicast rank-one assumptions.
- Data already distributed: Incorporate the cost of reshaping existing data placement into the blind IC file allocation; propose online/incremental algorithms and amortization analyses across many functions.
- Straggler resilience and fault tolerance: Integrate redundancy (task replication or coding) into IC; analyze the impact on π and δ and derive straggler/failure-resilient bounds.
- Heterogeneous subfunction complexity: Handle cases where subfunctions have variable computation costs or output sizes; develop weighted load-balancing methods and revised δ metrics.
- Reduce/aggregation phase costs: Include communication/computation costs associated with aggregating ζ_T outputs via Ψ; model inter-worker or master-side reduction overheads and co-optimize with π and δ.
- Memory/storage constraints at workers: Introduce per-worker storage limits and feasibility conditions (π ≤ capacity); study how capacity constraints alter achievable scaling and designs.
- Concurrent multi-function scheduling: Formalize simultaneous computation of multiple functions with different X_i; analyze joint allocation across overlapping task sets and interference in communication/computation.
- Privacy/security/compliance constraints: Extend design to settings with data placement restrictions (e.g., files restricted to certain workers); derive constrained hypergraph partitioning solutions and bounds.
- Algorithmic complexity and scalability: Precisely quantify the complexity of constructing and applying IC partitions for large n,d; propose scalable implementations and evaluate overheads.
- Empirical validation and benchmarking: Provide experimental results on representative applications (pairwise kernels, attention, SNP interactions) and compare against state-of-the-art hypergraph partitioners or distributed computing baselines.
- ARF optimality: Determine whether IC is (near-)optimal in ARF for given (n,N,d,ϕ); develop tighter ARF bounds and compare to π-optimized designs.
- Coded communication integration: Investigate whether coding techniques (beyond data placement) can further reduce communication, and how they interact with IC partitioning.
- Dynamic/streaming task arrival: Design online versions of IC that maintain balance and low π as X evolves (insertions/deletions), with performance guarantees.
- Decomposition selection: Develop algorithms to choose among multiple valid decompositions (varying d and structure) to minimize communication and computation; analyze complexity and approximation guarantees.
- Subpacketization trade-offs: Formalize the impact of subpacketization on n, ϕ, π, and δ; provide design guidelines on when and how to subpacketize for net gains.
- Non-uniform file sizes: Extend metrics and designs to weighted vertices (files with varying sizes); optimize for bytes communicated rather than file counts.
- Adversarial lower bounds independent of randomness: Provide converses that do not rely on density or random thinning assumptions; characterize worst-case X that maximally challenge the IC design.
- Integration with practical frameworks: Explore how IC can be integrated into Hadoop/Spark/Ray-like systems (data placement, scheduling, fault handling) and quantify end-to-end system-level gains.
Practical Applications
Immediate Applications
Below are concrete, deployable use cases that can benefit now from the paper’s Interweaved-Cliques (IC) design and its guarantees on communication and computation costs.
- Covariance and correlation matrix computation at scale
- Sector: Finance, Energy, Operations
- Use case: Build large covariance/correlation matrices (pairwise dot-products; ) over tens of thousands of time series (assets, sensors, KPIs).
- Workflow/product: IC Scheduler for Spark/Dask/Ray that preplaces files (time series) so each worker holds about series; compute assigned pairwise subfunctions locally; aggregate results.
- Benefit: Worst-case data movement per worker scales as ; near-balanced compute load with (under random thinning).
- Assumptions/dependencies: Functions decompose into subfunctions; equal-capacity links; homogeneous workers; (density of required pairs) not vanishing (e.g., ); memory per worker can hold its assigned file set.
- Kernel and distance matrix construction for ML
- Sector: Machine Learning (industry and academia)
- Use case: Compute pairwise kernels (RBF, polynomial) for kernel PCA/SVM and pairwise distances for spectral clustering, KNN graph building, or metric learning ().
- Workflow/product: IC Partitioning plugin for scikit-learn/Dask-ML or a PyTorch/NumPy back-end; files are feature vectors; preplace once and reuse across tasks.
- Benefit: Reduced data shuffles and predictable memory footprint per worker; near-order-optimal communication cost and balanced subfunction counts.
- Assumptions/dependencies: Pairwise decomposition (); dense or semi-dense evaluation set ; workers with similar compute and memory; unicast links.
- Contrastive and triplet-loss training pipelines
- Sector: ML training (vision/NLP/recsys)
- Use case: Distributed training requiring pairwise or triplet sampling ( or ), e.g., SimCLR, FaceNet, metric-learning negatives/positives across large datasets.
- Workflow/product: IC-aware DataLoader/Sampler for PyTorch or TensorFlow; preplace examples on workers according to IC; generate batch pairs/triplets locally to minimize cross-worker fetches.
- Benefit: Lower inter-worker I/O during training, improved throughput; blind placement reusable across different objectives with the same without reshuffling.
- Assumptions/dependencies: Batch construction compatible with -wise structure; sufficient dataset density ; workers homogeneous; memory constraints satisfied.
- Genomics: exhaustive SNP–SNP or triplet interactions
- Sector: Healthcare/Genomics
- Use case: Epistasis scans, GWAS interaction terms, pairwise/triple sequence comparisons ( or ).
- Workflow/product: IC-based partitioner for PLINK-like pipelines or custom HPC workflows; stage genotype files per worker; assign subfunction sets via IC groups.
- Benefit: Significant reduction in network-bound time for large-scale interaction scans; deterministic load balancing; blind placement supports multiple analyses sequentially.
- Assumptions/dependencies: Data decomposes into fixed -way subfunctions; dense interaction sets ( not negligible); homogeneous compute nodes.
- Molecular dynamics and N-body simulations
- Sector: Scientific computing/Robotics
- Use case: Distributed pairwise force evaluations () among particles or atoms.
- Workflow/product: MPI-based IC allocation library that assigns particle states to workers such that required pairwise interactions are local.
- Benefit: Reduced master-to-worker communication; per-worker memory scales as ; deterministic scheduling avoids search-based overhead.
- Assumptions/dependencies: Pairwise force model; domain decomposition compatible with IC grouping; synchronization/aggregation layers handled separately.
- Large-scale similarity search and index building
- Sector: Software/Search/Recsys
- Use case: Offline pairwise similarity computation between embeddings for deduplication, clustering, or building candidate lists ().
- Workflow/product: IC integration with FAISS/HNSW pipelines to distribute pairwise computations; preplace embeddings on workers and compute assigned pairs locally.
- Benefit: Faster index building with less network traffic; reusable placement for various similarity metrics.
- Assumptions/dependencies: Pairwise computation structure; sufficient memory per worker; dense evaluation set.
- Multi-function analytics on shared data lakes without reshuffling
- Sector: Enterprise data platforms
- Use case: Sequential or concurrent analytics functions with fixed (e.g., covariance one week, pairwise similarity next) on the same data library.
- Workflow/product: IC “blind placement” layer in a data platform; files pre-staged to workers once; task sets restricted to IC groups per function.
- Benefit: Eliminates recurrent data reshuffling; maintains order-optimal communication cost and balanced compute loads for each function.
- Assumptions/dependencies: Same across functions; unicast links; homogeneous workers.
- Cluster sizing and procurement guidance
- Sector: Policy/IT governance
- Use case: Use the scaling law to inform capacity planning: for , communication cost reduces like ; doubling N yields ~ improvement in data movement.
- Workflow/product: Cost–benefit calculator using to forecast network and memory footprints per worker for targeted analytical workloads.
- Benefit: Evidence-based procurement and budgeting decisions for HPC/analytics clusters.
- Assumptions/dependencies: Workloads decomposable into -wise subfunctions with non-vanishing density; homogeneous nodes; master–worker topology.
- Personal-scale deduplication or photo similarity
- Sector: Daily life
- Use case: Pairwise image similarity across large personal collections using a local multi-core machine or a small NAS cluster ().
- Workflow/product: Lightweight IC script to split image feature files across processes/nodes, compute assigned pairwise comparisons, then merge results.
- Benefit: Less RAM pressure per process and fewer cross-process data transfers.
- Assumptions/dependencies: Pairwise computations; local unicast; enough memory for assigned file chunk.
Long-Term Applications
These applications need further research, scaling, or system adaptation beyond the paper’s current assumptions (e.g., heterogeneity, topology, straggler resilience).
- Parallel training of Transformer-style attention
- Sector: ML/LLM training
- Use case: Attention involves pairwise token dependencies () but with tight sequence/time coupling and GPU memory constraints.
- Potential product/workflow: IC-inspired shard placement for attention blocks to co-locate token groups and reduce inter-GPU traffic; integrated with pipeline/tensor/model parallelism.
- Dependencies/assumptions: Extend IC to heterogeneous GPUs, non-uniform link capacities (PCIe/NVLink/Infiniband), dynamic sequence lengths; handle synchronization semantics and activation checkpointing.
- Heterogeneous clusters and non-star topologies
- Sector: Cloud/HPC infrastructure
- Use case: Optimize in the presence of varying link capacities, latencies, and non-unicast/multicast capabilities; hierarchical (rack–pod–region) layouts.
- Potential product/workflow: Topology-aware IC variants with weighted worker assignments; hierarchical IC for multi-level clusters; integration with software-defined networking.
- Dependencies/assumptions: Generalize cost metric beyond worst-case file count; incorporate link heterogeneity and multicast; extend proofs to new models.
- Straggler resilience and fault tolerance
- Sector: Distributed systems
- Use case: Real deployments must tolerate slow/failing workers; coded computing techniques commonly used in MapReduce.
- Potential product/workflow: Hybrid IC with redundancy or coded subfunction assignments; dynamic rebalancing and work-stealing compatible with IC’s structure.
- Dependencies/assumptions: Extend IC to incorporate replication and recovery while preserving communication gains; adaptive scheduling policies.
- Sparse and adversarial subfunction sets
- Sector: Algorithms/Combinatorics
- Use case: When is very small or adversarially patterned, load balance and communication guarantees may degrade.
- Potential product/workflow: Density-aware IC extensions with adaptive grouping or additional preprocessing to equalize group sizes; hybrid deterministic–heuristic methods.
- Dependencies/assumptions: New converse/achievability bounds for extremely sparse ; robust handling of degenerate hypergraph structures.
- Streaming/online data and evolving task sets
- Sector: Real-time analytics
- Use case: Data arrives continuously; task sets change over time; need incremental recomputation with minimal movement.
- Potential product/workflow: Online IC that maintains placements and updates groups with bounded migration; change-aware schedulers.
- Dependencies/assumptions: Online algorithm design and amortized bounds; state consistency and backpressure control.
- Privacy, security, and cross-silo computation
- Sector: Federated learning/Regulated industries
- Use case: Datasets cannot be centrally pooled; task/data placement constrained by privacy policies and data locality.
- Potential product/workflow: Privacy-preserving IC that respects silo boundaries (e.g., hospitals/banks), with secure multi-party protocols for cross-silo subfunction aggregation.
- Dependencies/assumptions: Policy constraints and cryptographic primitives; performance impact assessment under restricted data movement.
- Memory-bound and accelerator-aware scheduling
- Sector: GPU/TPU clusters
- Use case: Optimize file placement under strict device memory budgets; tradeoffs between compute, memory, and communication.
- Potential product/workflow: IC variants tuned for memory footprints and accelerator throughput; joint scheduling of compute kernels with IC groups.
- Dependencies/assumptions: Device-level constraints; unified memory/pinned memory strategies; model-specific profiling.
- Integration with coded caching and broadcast channels
- Sector: Communications/Systems
- Use case: Exploit multicast/broadcast (where available) to further reduce communication beyond unicast assumptions.
- Potential product/workflow: IC + coded caching hybrid that aligns interweaved cliques with multicast opportunities; network coding in master–worker phases.
- Dependencies/assumptions: Network support for multicast; new cost models and code designs aligned with IC structure.
- Graph analytics motifs beyond simple -wise pairs
- Sector: Data mining
- Use case: Triangle/motif counting, higher-order structures in large graphs.
- Potential product/workflow: Generalize file/subfunction mapping to capture composite motifs (e.g., triangles as subfunctions over vertex neighborhoods); IC-adapted motif schedulers.
- Dependencies/assumptions: Careful encoding of “files” and “subfunctions” for graph tasks; extension of IC combinatorics to these structures.
Notes on Core Assumptions and Dependencies
- Function structure: Subfunctions must depend on exactly input files (hypergraph edges of size ).
- Density: The performance guarantees (e.g., ) rely on non-vanishing subfunction density ; the paper provides thresholds like .
- Scale: For , the order-optimal bound is achievable deterministically.
- System model: Equal-capacity parallel links, unicast communication, homogeneous workers; computation cost measured via maximum subfunction load per worker.
- Blind placement: File placement is independent of the specific subfunction set (as long as is fixed), enabling multiple functions to be computed without reshuffling.
These applications—near-term and long-term—translate the paper’s theoretical contributions into practical tools, schedulers, and workflows that reduce communication bottlenecks and balance compute loads across distributed systems, while highlighting where additional engineering or theory is needed for broader deployment.
Glossary
- Achievability bounds: Information-theoretic guarantees that a performance target can be met by a specific construction or scheme. "This optimality is derived from our achievability and converse bounds,"
- Average Replication Factor (ARF): A metric in hypergraph partitioning that measures the average number of groups in which a vertex appears. "a closely related objective that has been extensively studied in the literature, is the minimization of the Average Replication Factor ($\mathrm{ARF$)} of vertices"
- Blind Resource Allocation: An allocation strategy that does not depend on the specific task set, enabling reuse across different computations. "Blind Resource Allocation"
- Coded Caching: A technique using coding and prefetching to reduce communication by exploiting shared side-information. "borrowing clique-inspired tools from coded caching and broadcast networks"
- Coded MapReduce: A variant of MapReduce that uses coding during the shuffle phase to reduce communication. "originating from the work on Coded MapReduce in~\cite{LMYA}"
- Concentration bounds: Probabilistic bounds ensuring random variables (e.g., group sizes) are close to their expected values with high probability. "Detailed concentration bounds, sampling thresholds, and proofs are provided in Section~\ref{sec: Random task}."
- Converse bounds: Information-theoretic lower bounds that limit the best achievable performance of any scheme. "This optimality is derived from our achievability and converse bounds,"
- Covering-code constructions: Coding-theoretic designs that use covering codes to structure allocations or communications. "Taking a novel approach that involves covering-code constructions and tessellation-based tilings"
- d-uniform hypergraph: A hypergraph where every hyperedge connects exactly d vertices. "we consider a -uniform hypergraph "
- Finite projective geometry: A branch of finite geometry used to design graph partitions with favorable replication properties. "The work in~\cite{ProjectivePlane} employs finite projective geometry to partition the edges of graphs"
- Finite projective planes: Specific finite geometric structures that exist for certain parameters and underpin some partitioning designs. "This constraint arises from the limited existence of finite projective planes."
- Hyperedge: A generalization of an edge that can connect more than two vertices in a hypergraph. "each hyperedge is retained with probability "
- Hypergraph edge partitioning: The problem of dividing hyperedges into groups to optimize communication or replication metrics. "can be equivalently formulated as a hypergraph edge partitioning problem."
- Hypergraph partitioning: The broader task of partitioning a hypergraph (often by edges) for load balancing and communication efficiency. "the problem of resource and task allocation via hypergraph partitioning represents a vast and mature field of scientific inquiry"
- Interweaved-Cliques (IC) design: The proposed deterministic allocation framework using interweaving of clique structures to achieve near-optimal costs. "we propose a deterministic allocation solution, the Interweaved-Cliques (IC) design"
- Lexicographic partition: A partition formed by ordering elements lexicographically and grouping them accordingly. "Let us first consider the lexicographic partition"
- NP-hard: A classification of computational problems for which no known polynomial-time algorithm exists and which are at least as hard as any problem in NP. "is known to be NP-hard even for graphs ()"
- Order-optimal: Achieving the correct scaling law (up to constant factors) for performance metrics as system size grows. "simultaneously achieves order-optimal communication and computation costs"
- Partitioning gain: The improvement factor in communication cost achieved by partitioning, typically measured as n divided by the maximal per-group file count. "achieves the order-optimal partitioning gain that scales as "
- Random thinning: A process of independently sampling elements (e.g., d-tuples) with a fixed probability to form a subset. "obtained from a random thinning of "
- Rank-one (bottleneck) communication links: Communication channels modeled as single shared links that constrain throughput, motivating coded strategies. "under rank-one (bottleneck) communication links."
- Ramsey theory: A field in combinatorics studying order and structure that arises in large systems, relevant to combinatorial limits of partitioning. "connecting NP-hard optimization challenges to complex combinatorial structures, Ramsey theory, and finite geometry"
- Sampling thresholds: Minimum sampling rates needed to ensure desired probabilistic guarantees (e.g., balanced loads). "Detailed concentration bounds, sampling thresholds, and proofs are provided in Section~\ref{sec: Random task}."
- Straggler resilience: The capability of a system or scheme to tolerate slow or failed workers without significant performance degradation. "various degrees of straggler resilience."
- Subpacketization: Splitting datasets into many smaller packets to enable structured coding or placement strategies. "highlighting the role of dataset subpacketization in reducing server-to-server communication under rank-one (bottleneck) communication links."
- Tessellation-based tilings: Geometric tiling methods used to structure task assignment and communication in distributed systems. "covering-code constructions and tessellation-based tilings"
- Universal design: A scheme that remains effective across a wide set of functions and decompositions without reconfiguring file placements. "we see that the new IC design is a universal design"
Collections
Sign up for free to add this paper to one or more collections.