Pith. sign in

REVIEW 7 minor 33 references

Resolvable Designs for Speeding up Distributed Computing

T0 review · 0 major / 7 minor · reviewed 2026-08-14 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read Coded MapReduce gets practical with far fewer files and jobs

desk verdict The central claim survives a careful check — same load as CCDC with exponentially fewer jobs — and the real new value is the EC2 validation; minor consistency fixes and an inline proof for Lemma 3 are needed before acceptance. read the letter →

arxiv 1908.05666 v3 pith:SKHYGKWD submitted 2019-08-14 cs.DC cs.DScs.ITcs.LGmath.IT

Konstantinos Konstantinidis , Aditya Ramamoorthy This is my paper · ORCID
classification cs.DCcs.DScs.ITcs.LGmath.IT MSC 05B0594B05
keywords codeddistributedcomputingcommunicationloadresolvabledesignssingleparity-checkcodesMapReducemulticastingaggregatefunctionsshufflephase
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper tries to establish that resolvable designs—combinatorial arrangements of points into parallel blocks, generated from single parity-check codes—can make coded MapReduce practical by drastically reducing the number of files a job must be split into and the number of jobs a batch must contain. For a single job, the proposed scheme needs $N = q^{k-1}$ files and cuts the shuffle load by a factor of $r-1$ relative to uncoded transmission, whereas the prior coded scheme required a combinatorial number of files to reach its lower load. For multiple jobs whose functions can be aggregated, the CAMR scheme achieves exactly the communication load of the compressed coded distributed computing scheme, $L = [k(q-1)+1]/[q(k-1)]$, while requiring only $q^{k-1}$ jobs instead of $\binom{K}{\mu K+1}$. The paper supports this with theory and with cluster experiments reporting speedups of $4.69\times$ for TeraSort and $4.31\times$ for distributed matrix-vector multiplication over uncoded baselines.

What carries the argument

The central object is the resolvable design $(X,\mathcal{A})$ obtained from the codewords of a $(k,k-1)$ single parity-check code over $\mathbb{Z}_q$: the point set $X = [q^{k-1}]$ indexes files or jobs, and each block $B_{i,l}$ collects the points whose $i$-th codeword coordinate equals $l$. The blocks split into $k$ parallel classes of $q$ blocks each, and the crucial combinatorial property (Lemma 3) is that any $k-1$ blocks chosen from distinct parallel classes intersect in exactly one point. This property guarantees that in every $k$-server communication group, each server is missing a unique chunk that all other servers hold, so the paper's Algorithm 1—splitting each chunk into $k-1$ packets and having each server broadcast an XOR of the packets it can provide—delivers all missing chunks in $k$ transmissions of total size $Bk/(k-1)$. The same machinery is reused in stage 1 and stage 2 of the multi-job CAMR protocol.

What would settle it

Enumerate all choices of $k-1$ blocks from distinct parallel classes for the SPC-code design with small composite parameters such as $q=4, k=3$; if any intersection has size different from 1, the Lemma 3-based correctness argument fails. For prime $q$, a brute-force check over small $k$ and $q$ would confirm the property computationally and isolate where a proof is needed.

Watch

Extended reading notes

Core claim

On its own terms, the paper claims that a resolvable design built from a $(k,k-1)$ single parity-check code over $\mathbb{Z}_q$ simultaneously dictates file placement and defines the multicast groups for the shuffle phase. In the single-job case each server group of size $k$ has the property that every server misses exactly one data chunk that the other $k-1$ servers share; using XOR-based coded multicast, $k$ transmissions of size $B/(k-1)$ let each server recover its missing chunk, giving communication load $L = \frac{1}{k-1}\left(1-\frac{k}{K}\right)$ with only $N = q^{k-1}$ files. In the multi-job case, associating jobs with design points and servers with blocks yields a three-stage protocol whose total load is $L_{\mathrm{CAMR}} = \frac{k(q-1)+1}{q(k-1)}$, identical to the load of prior compressed coded distributed computing for the same storage fraction $\mu = (k-1)/K$, but with exponentially fewer jobs. The paper further claims that this translates into measured speedups of $4.69\times$ over uncoded TeraSort and $4.31\times$ over uncoded matrix-vector multiplication.

Load-bearing premise

The load-bearing premise is Lemma 3, stated without proof and cited from earlier work, that any $k-1$ blocks chosen from $k-1$ distinct parallel classes of the SPC-code resolvable design intersect in exactly one point; if that intersection ever has a different size, the single-job and multi-job shuffle protocols lose their guarantee that each server misses a unique shared batch.

Editorial extensions

If this is right

  • A single MapReduce job can be processed with $N = q^{k-1}$ files instead of the combinatorial $\binom{K}{r}\eta$ files required by prior coded schemes, removing a major practical obstacle to coded shuffling.
  • For a batch of aggregatable jobs, the same communication load as compressed coded distributed computing is achievable with $q^{k-1}$ jobs rather than $\binom{K}{\mu K+1}$, so the method works when only modest numbers of jobs are submitted.
  • The communication load of the multi-job scheme is $L = \frac{k}{k-1} - \frac{1}{q}$, so increasing $q$ at fixed $k$ smoothly trades more jobs for lower shuffle traffic.
  • In the measured TeraSort runs, the single-job scheme achieved up to $4.69\times$ total speedup over uncoded sorting, and the multi-job matrix-vector experiments reached $4.31\times$ over the uncoded baseline.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Beyond the paper: because the design construction works for any modulus $q$ (not necessarily prime), the same protocol could be instantiated at parameter values matched to specific cluster sizes or communicator limits, with the load and subpacketization tradeoff controlled by $q$.
  • Beyond the paper: the Lemma 3 intersection property is the foundation of both correctness proofs and is imported without proof; an independent proof or exhaustive enumeration for small composite $q$ would make the scheme self-contained and reveal whether the property extends beyond the parity-check construction.
  • Beyond the paper: the practical speedups depend on multicast being close to a linear broadcast; on clusters where tree or hardware multicast is much cheaper, the observed gains could be larger than the load analysis predicts, while on networks with high per-group setup costs the advantage of fewer groups would grow further.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

0 major / 7 minor

Summary. The paper proposes two coded distributed computing schemes based on resolvable designs generated from single parity-check (SPC) codes. For a single job with K = k q servers, the data set is split into N = q^{k-1} files assigned to servers according to the block incidence of the design; the scheme achieves communication load L = 1/(k-1) * (1 - k/K) with computation load r = k, giving a factor r-1 reduction relative to an uncoded scheme with the same redundancy, while using far fewer files than the CDC scheme. For multiple jobs with aggregatable functions, the CAMR scheme uses J = q^{k-1} jobs and storage fraction μ = (k-1)/K, and its three-stage shuffle protocol attains load L = [k(q-1)+1]/[q(k-1)], which is shown to equal the CCDC load in Eq. (8) with an exponentially smaller number of jobs. The paper presents EC2 TeraSort experiments (up to 4.69x over the uncoded baseline) and matrix-vector multiplication experiments (up to 4.31x), with code made publicly available.

Significance. If the results hold, the main contribution is practical: CAMR matches CCDC's communication load with an exponentially smaller number of jobs, and the single-job scheme obtains a substantial fraction of CDC's gain with tractable subpacketization (e.g., N = 128 for K = 16, r = 8 versus 12870 files for the prior scheme). The load derivations are carried out by exact counting, are parameter-free, and are verified against the external CCDC expression; no curve fitting is involved. The experimental section is unusually thorough for this line of work, including code release, memory-allocation accounting, and a discussion of MPI communicator overhead. The main caveats are presentation issues and the reliance on a cited combinatorial lemma rather than an in-paper proof, neither of which undermines the central claims.

minor comments (7)
  1. [Abstract; §IV-E] The abstract's claim of a '2.6x over prior work' speedup does not match Section IV-E, which reports a maximum gain over the prior coded TeraSort of 3.01x when memory allocation is included and 2.4x when it is excluded. Please reconcile these numbers or remove the unsubstantiated 2.6x figure.
  2. [§IV-D; §V-C] Lemma 3, the intersection property of k-1 blocks from distinct parallel classes, is stated as 'proved in [26]' and is the load-bearing combinatorial fact for both the single-job correctness proof and the multi-job Stage 2/Stage 3 protocols. Since the proof is short and the lemma is central, the journal version should include it in the appendix or restate the exact theorem from [26] with a proof, rather than only citing the prior paper.
  3. [§V-F] The discussion around inequality (a) is confusing: the displayed lower bound binom(kq,k) ≥ q^k is monotone increasing in q, so the statement that '(a) is maximum when q = 2' is not accurate as written. The conclusion q^k > q^{k-1} is correct regardless, but the sentence should be rephrased.
  4. [§IV-D; §IV-E] The claim that the proposed scheme reduces the communication load by a factor of r-1 should state explicitly that the comparison is against an uncoded scheme with the same computation load r. The experimental discussion compares against the uncoded r = 1 baseline and reports a Shuffle-time gain of 13.125 for r = 8, which is a different ratio and may confuse readers.
  5. [Appendix; Algorithm 1] The proof of Lemma 2 refers to a 'complete graph' on G\{U_j} and C, while Algorithm 1 specifies a complete bipartite graph; the terminology should be fixed.
  6. [Fig. 1] Figure 1, the MPI_Comm_Split execution time plot, lacks axis labels, units, and a precise description of the benchmark configuration; please add these details.
  7. [§V-H] In the sentence 'that speedup would be 169.1/90.857.74 = 14.41', the multiplication sign between 90.85 and 7.74 is missing; please fix the typo.

Circularity Check

0 steps flagged · score 2.0 of 10

No significant circularity: the CAMR load formula is derived by explicit bit-counting; cited design lemmas are parameter-free and externally checkable.

full rationale

The claimed load equality is not assumed as input. Section V-E independently counts the three stages: J groups of k transmissions of size B/(k-1) for stage 1, q^{k-1}(q-1) groups of k transmissions of size B/(k-1) for stage 2, and K(J-q^{k-2}) transmissions of size B for stage 3; the sum, divided by JKB with J=q^{k-1} and K=kq, is exactly Eq. (7). The CCDC comparison substitutes mu=(k-1)/K into the external formula Eq. (8) and obtains the same rational expression; this is an algebraic match, not a fitted equality. The single-job load L = 1/(k-1)(1-k/K) is likewise obtained by counting q^{k-1}(q-1) groups and using Lemma 2's Bk/(k-1) transmission bound, both specified and proved in the paper. Lemma 3, which the correctness arguments invoke, is cited to the authors' earlier paper [26]; although this is a self-citation and the lemma is load-bearing, it is a parameter-free combinatorial statement about SPC-code resolvable designs whose assumptions do not include the target load formulas, and it can be verified directly from the parity-check construction. It is therefore independent mathematical support under the stated rules. The experimental sections compare measured times to these derived loads and do not rename fitted parameters as predictions. The inconsistency between the abstract's 2.6x speedup over prior work and the body's 2.4x/3.01x figures is a reporting issue, not a circular step.

Assumptions & free parameters 2 free parameters · 7 assumptions · 0 invented entities

The central claims rest on standard combinatorial facts about resolvable designs from SPC codes (Lemmas 1 and 3, both cited from the same group's [26]) and on the MapReduce modeling assumptions inherited from [9] (equal-size files, B-bit intermediates, homogeneous mappers) plus the aggregation property from [1]. No data-fitted constants appear: the parameters k, q, and gamma are user-chosen design freedoms. The counted loads are exact under the basic-linear-broadcast model, which the authors explicitly flag.

free parameters (2)
  • design parameters (k, q) with K = k q = (k,q) = (4,4), (4,8) for TeraSort; (10,2) for matrix-vector; (2,25), (5,10) discussed for communicator limits
    Chosen by the designer to meet the cluster size K and to control subpacketization N = q^{k-1} or J = q^{k-1}. They are not fitted to experimental data.
  • batch size gamma = gamma=1 in single-job scheme; gamma=2 in Example 5; gamma=n/k in the MVM experiment
    Controls subpacketization in multi-job file placement (Algorithm 3); any positive integer with k | N. It is a free design choice, not fitted to data.
assumptions (7)
  • standard math Lemma 1: the SPC code construction always yields a resolvable design.
    Cited from [26]; used in Section III-A to build the file/server assignment from the parity-check code.
  • standard math Lemma 3: the intersection of any k-1 blocks from k-1 distinct parallel classes has size exactly 1.
    Cited from [26]; used in Sections IV-D and V-C to show that each server group has a unique shared missing file or batch.
  • domain assumption MapReduce model of [9]: each output function decomposes as h_j(g_{j,1}(w_1),...,g_{j,N}(w_N)) with equal-size intermediate values of B bits.
    Section IV-B; the whole load analysis counts B-bit packets and assumes homogeneous mappers and reducers.
  • domain assumption Aggregation property: an aggregate of m intermediate values of the same function and job still has size B bits.
    Section V; needed for the multi-job load formulas and the claimed equivalence with CCDC.
  • domain assumption Q is divisible by K.
    Stated in Sections IV-C and V; used to balance reduce functions across servers.
  • domain assumption Shuffle cost is proportional to bits transmitted under basic linear broadcast.
    Section IV-E; the authors acknowledge MPI may use tree or other broadcast modes and present this as the worst-case load metric.
  • domain assumption For TeraSort and distributed matrix-vector multiplication, data skewness is negligible and mapper/reducer times are homogeneous.
    Section IV-B, attributed to [29]; justifies equal-size file splits and the comparison methodology.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Resolvable Designs for Speeding up Distributed Computing." pith.science (2026). https://pith.science/paper/SKHYGKWD

@misc{pith2026190805666,
  author       = {Pith},
  title        = {Pith review of: Resolvable Designs for Speeding up Distributed Computing},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/SKHYGKWD}},
  note         = {Machine review of arXiv:1908.05666}
}
read the original abstract

Distributed computing frameworks such as MapReduce are often used to process large computational jobs. They operate by partitioning each job into smaller tasks executed on different servers. The servers also need to exchange intermediate values to complete the computation. Experimental evidence suggests that this so-called Shuffle phase can be a significant part of the overall execution time for several classes of jobs. Prior work has demonstrated a natural tradeoff between computation and communication whereby running redundant copies of jobs can reduce the Shuffle traffic load, thereby leading to reduced overall execution times. For a single job, the main drawback of this approach is that it requires the original job to be split into a number of files that grows exponentially in the system parameters. When extended to multiple jobs (with specific function types), these techniques suffer from a limitation of a similar flavor, i.e., they require an exponentially large number of jobs to be executed. In practical scenarios, these requirements can significantly reduce the promised gains of the method. In this work, we show that a class of combinatorial structures called resolvable designs can be used to develop efficient coded distributed computing schemes for both the single and multiple job scenarios considered in prior work. We present both theoretical analysis and exhaustive experimental results (on Amazon EC2 clusters) that demonstrate the performance advantages of our method. For the single and multiple job cases, we obtain speed-ups of 4.69x (and 2.6x over prior work) and 4.31x over the baseline approach, respectively.

Figures

Figures reproduced from arXiv: 1908.05666 by the authors.

Figure 1
Figure 1. MPI_Comm_Split execution time. perform all transmissions of a tree level in parallel. However, it will prioritize them such that one child of each transmitter is serviced first while the other is waiting and it will maximize the bandwidth of the connections of the transmitter-receiver pairs which are serviced first. The overhead of setting the connections is much lesser in our protocol due to the reduced number of g… view at source ↗
Figure 2
Figure 2. Proposed placement scheme for K = 6 servers and N = 6 files per computing job for J = 4 jobs. The dotted lines show the partition of the servers into parallel classes. on a simple rule. We choose a group of servers G = {B1,j1 , B2,j2 , . . . , Bk,jk } such that ∩ k `=1B`,j` = ∅. Without loss of generality, assume that Uk0 ∈ G. If we remove Uk0 from G, the servers in the corresponding subset P = G\{Uk0} of cardinalit… view at source ↗
Figure 3
Figure 3. Stage 1 coded multicasts among owners of [PITH_FULL_IMAGE:figures/full_fig_p011_3.png] view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

33 extracted references · 33 canonical work pages

  1. [20]

    Leveraging coding techniques for speeding up distributed computing,

    K. Konstantinidis and A. Ramamoorthy, “Leveraging coding techniques for speeding up distributed computing,” in IEEE Global Communica- tions Conference (GLOBECOM) , December 2018, pp. 1–6

    work page 2018

  2. [21]

    CAMR: Coded Aggregated MapReduce,

    ——, “CAMR: Coded Aggregated MapReduce,” in IEEE International Symposium on Information Theory (ISIT) , June 2019

    work page 2019

  3. [26]

    Coded caching schemes with reduced subpacketization from linear block codes,

    L. Tang and A. Ramamoorthy, “Coded caching schemes with reduced subpacketization from linear block codes,” IEEE Transactions on Infor- mation Theory, vol. 64, no. 4, pp. 3099–3120, April 2018

    work page 2018

  4. [1]

    Compressed coded dis- tributed computing,

    S. Li, M. A. Maddah-Ali, and A. S. Avestimehr, “Compressed coded dis- tributed computing,” in IEEE International Symposium on Information Theory (ISIT), June 2018, pp. 2032–2036

    work page 2018

  5. [2]

    Deep residual learning for image recognition,

    K. He, X. Zhang, S. Ren, and J. Sun, “Deep residual learning for image recognition,” inIEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2016, pp. 770–778

    work page 2016

  6. [3]

    Coded computing for distributed graph analytics,

    S. Prakash, A. Reisizadeh, R. Pedarsani, and A. S. Avestimehr, “Coded computing for distributed graph analytics,” in IEEE International Sym- posium on Information Theory (ISIT) , June 2018, pp. 1221–1225

    work page 2018

  7. [4]

    Manag- ing data transfers in computer clusters with orchestra,

    M. Chowdhury, M. Zaharia, J. Ma, M. I. Jordan, and I. Stoica, “Manag- ing data transfers in computer clusters with orchestra,” ACM SIGCOMM Computer Communication Review , vol. 41, no. 4, pp. 98–109, August 2011

    work page 2011

  8. [5]

    ishuffle: Improving hadoop performance with shuffle-on-write,

    Y . Guo, J. Rao, and X. Zhou, “ishuffle: Improving hadoop performance with shuffle-on-write,” in 10th International Conference on Autonomic Computing (ICAC), June 2013, pp. 107–117

    work page 2013

Show all 33 references
  1. [6]

    Breaking the mapreduce stage barrier,

    A. Verma, B. Cho, N. Zea, I. Gupta, and R. H. Campbell, “Breaking the mapreduce stage barrier,” Cluster Computing , vol. 16, no. 1, pp. 191–206, March 2013

    2013

  2. [7]

    Communication vs distributed computation: An alternative trade-off curve,

    Y . H. Ezzeldin, M. Karmoose, and C. Fragouli, “Communication vs distributed computation: An alternative trade-off curve,” in 2017 IEEE Information Theory Workshop (ITW) , November 2017, pp. 279–283

    2017

  3. [8]

    Computa- tion and communication efficient graph processing with distributed im- mutable view,

    R. Chen, X. Ding, P. Wang, H. Chen, B. Zang, and H. Guan, “Computa- tion and communication efficient graph processing with distributed im- mutable view,” in 23rd International Symposium on High-performance Parallel and Distributed Computing (HPDC) , June 2014, pp. 215–226

    2014

  4. [9]

    A fundamental tradeoff between computation and communication in distributed com- puting,

    S. Li, M. A. Maddah-Ali, Q. Yu, and A. S. Avestimehr, “A fundamental tradeoff between computation and communication in distributed com- puting,” IEEE Transactions on Information Theory , vol. 64, no. 1, pp. 109–128, January 2018

    2018

  5. [10]

    Shufflewatcher: Shuffle-aware scheduling in multi-tenant mapreduce clusters,

    F. Ahmad, S. T. Chakradhar, A. Raghunathan, and T. N. Vijaykumar, “Shufflewatcher: Shuffle-aware scheduling in multi-tenant mapreduce clusters,” in USENIX Annual Technical Conference (ATC) , June 2014, pp. 1–13. 4In the shuffling phase of the uncoded case, each server unicasts da...

    2014

  6. [11]

    Accelerating data shuffling in mapreduce framework with a scale-up numa computing architecture,

    X. Cao, K. K. Panchputre, and D. H.-C. Du, “Accelerating data shuffling in mapreduce framework with a scale-up numa computing architecture,” in 24th High Performance Computing Symposium, April 2016, pp. 17:1– 17:8

    2016

  7. [12]

    Optas: Optimal data placement in mapreduce,

    C. Wang, Y . Qin, Z. Huang, Y . Peng, D. Li, and H. Li, “Optas: Optimal data placement in mapreduce,” in International Conference on Parallel and Distributed Systems , December 2013, pp. 315–322

    2013

  8. [13]

    Coded mapreduce,

    S. Li, M. A. Maddah-Ali, and A. S. Avestimehr, “Coded mapreduce,” in 53rd Annual Allerton Conference on Communication, Control, and Computing (Allerton), 2015, pp. 964–971

    2015

  9. [14]

    Coded terasort,

    S. Li, S. Supittayapornpong, M. A. Maddah-Ali, and S. Avestimehr, “Coded terasort,” in IEEE International Parallel and Distributed Pro- cessing Symposium Workshops (IPDPSW) , May 2017, pp. 389–398

    2017

  10. [15]

    Gradient coding: Avoiding stragglers in distributed learning,

    R. Tandon, Q. Lei, A. G. Dimakis, and N. Karampatziakis, “Gradient coding: Avoiding stragglers in distributed learning,” in34th International Conference on Machine Learning (ICML), August 2017, pp. 3368–3376

    2017

  11. [16]

    High-performance hardware for machine learning,

    W. Dally, “High-performance hardware for machine learning,” in 29th Conference on Neural Information Processing Systems (NIPS) Tutorial , December 2015

    2015

  12. [17]

    Mapreduce: Simplified data processing on large clusters,

    J. Dean and S. Ghemawat, “Mapreduce: Simplified data processing on large clusters,”Communications of the ACM, vol. 51, no. 1, pp. 107–113, January 2008

    2008

  13. [18]

    A new combinatorial design of coded distributed computing,

    N. Woolsey, R. Chen, and M. Ji, “A new combinatorial design of coded distributed computing,” in 2018 IEEE International Symposium on Information Theory (ISIT) , June 2018, pp. 726–730

    2018

  14. [19]

    The benefit of being flexible in distributed computation,

    L. Song, S. R. Srinivasavaradhan, and C. Fragouli, “The benefit of being flexible in distributed computation,” in 2017 IEEE Information Theory Workshop (ITW), November 2017, pp. 289–293

    2017

  15. [22]

    D. R. Stinson, Combinatorial Designs: Constructions and Analysis . Springer, 2004

    2004

  16. [23]

    SPC Coded TeraSort repository

    “SPC Coded TeraSort repository.” [Online]. Available: https://bitbucket. org/kkonstantinidis/codedterasort

  17. [24]

    Aggregated MapReduce code repository

    “Aggregated MapReduce code repository.” [Online]. Available: https: //bitbucket.org/kkonstantinidis/camrmm

  18. [25]

    Lin and D

    S. Lin and D. J. Costello, Error Control Coding, 2nd Ed. Prentice Hall, 2004

    2004

  19. [27]

    Repository of TeraSort for prior implementation

    “Repository of TeraSort for prior implementation.” [Online]. Avail- able: https://github.com/AvestimehrResearchGroup/Coded-TeraSort/ tree/IgnoreMemoryTime

  20. [28]

    Skewtune: Mitigating skew in mapreduce applications,

    Y . Kwon, M. Balazinska, B. Howe, and J. Rolia, “Skewtune: Mitigating skew in mapreduce applications,” in Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data, May 2012, pp. 25–36

    2012

  21. [29]

    Managing skew in hadoop,

    Y . Kwon, K. Ren, M. Balazinska, and B. Howe, “Managing skew in hadoop,” IEEE Data Eng. Bull. , vol. 36, no. 1, pp. 24–33, March 2013

    2013

  22. [30]

    A practically constant-time mpi broadcast algorithm for large-scale infiniband clusters with multicast,

    T. Hoefler, C. Siebert, and W. Rehm, “A practically constant-time mpi broadcast algorithm for large-scale infiniband clusters with multicast,” in 2007 IEEE International Parallel and Distributed Processing Sympo- sium, March 2007, pp. 1–8

    2007

  23. [31]

    A scalable mpi comm split algorithm for exascale computing,

    P. Sack and W. Gropp, “A scalable mpi comm split algorithm for exascale computing,” in Recent Advances in the Message Passing Interface, vol. 6305, September 2010, pp. 1–10

    2010

  24. [32]

    T. H. Cormen, C. E. Leiserson, R. L. Rivest, and C. Stein, Introduction to Algorithms, Third Edition , 2009

    2009

  25. [33]

    Goodfellow, Y

    I. Goodfellow, Y . Bengio, A. Courville, and Y . Bengio, Deep learning. MIT Press, 2016. 14

    2016

Pith tools

Reviewed August 14, 2026 · model on record in the stance chip above.