1 / 32

Dealing with the scale problem

This study explores innovative solutions to the scale problem in computing, focusing on the runtime scalability of binomial graphs and uncoordinated checkpointing for fault tolerance. The MPI team presents a methodology to enhance collective communications efficiency while optimizing fault tolerance mechanisms, ensuring effective self-healing in dynamic environments. By deploying platform-specific decision functions and performance models, the study achieves efficient runtime scalability and tuning of collective communications applications, enhancing fault-tolerant linear algebra operations and uncoordinated checkpointing. The research delves into the intricacies of routing costs, link and node connectivity, and self-healing capabilities within the network topology, showcasing the benefits of fault-tolerant strategies and collective communication models in the context of parallel computing environments.

ethelellis
Download Presentation

Dealing with the scale problem

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Dealing with the scale problem Innovative Computing Laboratory MPI Team

  2. Runtime ScalabilityCollective CommunicationsFault Tolerance

  3. Binomial Graph (BMG) Undirected graph G:=(V, E), |V|=n(any size) Node i={0,1,2,…,n-1} has links to a set of nodes U U={i±1, i±2,…, i±2k | 2k ≤ n} in a circular space U={ (i+1)mod n, (i+2)mod n,…, (i+2k)mod n | 2k ≤ n } and { (n+i-1)mod n, (n+i-2)mod n,…, (n+i-2k)mod n | 2k ≤ n } Merging all links create binomial graph from each node of the graph Broadcast from any node in Log2(n) steps Runtime Scalability

  4. Diameter Average Distance Node-Connectivity (κ) Link-Connectivity (λ) Optimally Connected κ = λ =δmin BMG properties Degree = number of neighbors = number of connections = resource consumption Runtime Scalability

  5. Routing Cost • Because of the counter-clockwise links the routing problem is NP-complete • Good approximations exists, with a max overhead of 1 hop • Broadcast: optimal in number of steps log2(n) (binomial tree from each node) • Allgather: Bruck algorithm log2(n) steps • At step s: • Node i send data to node i-2s • Node i receive data from node i+2s Runtime Scalability

  6. # of new connections Self-Healing BMG # of added nodes # of nodes Dynamic Environments Runtime Scalability

  7. Runtime ScalabilityCollective CommunicationsFault Tolerance

  8. Optimization process • Run-time selection process • We use performance models, graphical encoding, and statistical learning techniques to build platform-specific, efficient and fast runtime decision functions Collective Communications

  9. Model prediction Collective Communications

  10. Model prediction Collective Communications

  11. Tuning broadcast 64 Opterons with1Gb/s TCP Collective Communications

  12. Tuning broadcast Collective Communications

  13. Application Tuning • Parallel Ocean Program (POP) on a Cray XT4 • Dominated by MPI_Allreduce of 3 doubles • Default Open MPI select recursive doubling • similar with Cray MPI (based on MPICH) • Cray MPI has better latency • i.e. POP using Open MPI is 10% slower on 256 processes • Profile the system for this specific collective and determine that “reduce + bcast” is faster • Replace the decision function • New POP performance is about 5% faster than Cray MPI Collective Communications

  14. Runtime ScalabilityCollective CommunicationsFault ToleranceFault Tolerant Linear AlgebraUncoordinated checkpoint Sequential debugging of parallel applications

  15. P1 P2 P3 P4 Diskless Checkpointing 4 available processors Fault Tolerance

  16. P1 P2 P3 P4 Diskless Checkpointing 4 available processors Add a fifth and perform a checkpoint(Allreduce) P1 P2 P3 P4 P4 P5 + + + = Fault Tolerance

  17. P1 P2 P3 P4 Diskless Checkpointing 4 available processors Add a fifth and perform a checkpoint(Allreduce) P1 P2 P3 P4 P4 P5 + + + = P1 P2 P3 P4 P4 P5 Ready to continue Fault Tolerance

  18. P1 P2 P3 P4 Diskless Checkpointing 4 available processors Add a fifth and perform a checkpoint(Allreduce) P1 P2 P3 P4 P4 P5 + + + = P1 P2 P3 P4 P4 P5 Ready to continue .... P1 P2 P3 P4 P4 P5 Failure Fault Tolerance

  19. P1 P2 P3 P4 Diskless Checkpointing 4 available processors Add a fifth and perform a checkpoint(Allreduce) P1 P2 P3 P4 P4 Pc + + + = P1 P2 P3 P4 P4 Pc Ready to continue .... P1 P2 P3 P4 P4 Pc Failure P1 P3 P4 P4 Pc Ready for recovery Pc P1 P3 P4 P2 - - - = Recover the processor/data Fault Tolerance

  20. Diskless Checkpointing • How to checkpoint ? • either floating-point arithmetic or binary arithmetic will work • If checkpoints are performed in floating‐point arithmetic then we can exploit the linearity of the mathematical relations on the object to maintain the checksums • How to support multiple failures ? • Reed-Salomon algorithm • support p failures require p additional processors (resources) Fault Tolerance

  21. PCG • Fault Tolerant CG • 64x2 AMD 64 connected using GigE Performance of PCG with different MPI libraries For ckpt we generate one ckpt every 2000 iterations Fault Tolerance

  22. PCG Checkpoint overhead in seconds Fault Tolerance

  23. Fault ToleranceUncoordinated checkpoint Fault Tolerance

  24. Detailing event types to avoid intrusiveness • promiscuous receptions (i.e. ANY_SOURCE) • Non blocking delivery tests (i.e. WaitSome, Test, TestAny, iProbe…) Fault Tolerance

  25. Interposition in Open MPI • We want to avoid tainting the base code with #ifdef FT_BLALA • Vampire PML loads a new class of MCA components • Vprotocols provide the entire FT protocol (only pessimistic for now) • You can use yourself the ability to define subframeworks in your components ! :) • Keep using the optimized low level and zero-copy devices (BTL) for communication • Unchanged message scheduling logic Fault Tolerance

  26. Performance Overhead • Myrinet 2G (mx 1.1.5) - Opteron 146x2 - 2GB RAM - Linux 2.6.18 - gcc/gfortran 4.1.2 - NPB3.2 - NetPIPE • Only two application kernels shows non-deterministic events (MG, LU) Fault Tolerance

  27. Fault ToleranceSequential debugging of parallel applications Fault Tolerance

  28. Debugging Applications • Usual scenario involves • Programmer design testing suite • Testing suite shows a bug • Programmer runs the application in a debugger (such as gdb) up to understand the bug and fix it • Programmer runs again the testing suite • Cyclic Debugging Testing Design and code Release Interactive Debugging Fault Tolerance

  29. Interposition Open MPI • Events are stored (asynchronously on disk) during initial run • Keep using the optimized low level and zero-copy devices (BTL) for communication • Unchanged message scheduling logic • We expect low impact on application behavior Fault Tolerance

  30. Performance Overhead • Myrinet 2G (mx 1.0.3) - Opteron 146x2 - 2GB RAM - Linux 2.6.18 - gcc/gfortran 4.1.2 - NPB3.2 - NetPIPE • 2% overhead on bare latency, no overhead on bandwidth • Only two application kernels shows non-deterministic events • Receiver-based have more overhead, moreover it incurs large amount of logged data - 350MB on simple ping-pong (this is beneficial it is enabled on-demand) Fault Tolerance

  31. Log size per process on NAS Parallel Benchmarks (kB) Log Size on NAS Parallel Benchmarks • Among the 7 NAS kernels, only 2 NPB generates non deterministic events • Log size does not correlate with number of processes • The more scalable is the application, the more scalable is the log mechanism • Only 287KB of log/process for LU.C.1024 (200MB memory footprint/process) Fault Tolerance

More Related