1 / 27

Illustration of ISP Bug Classes and MPI Happens-Before

Explore various bug classes caught by ISP such as deadlocks and resource leaks, explained using the POE algorithm with MPI happens-before support. Witness GUI display capabilities for intuitive understanding of relaxed HB edges and buffer sensitive deadlocks. Understand MPI's point-to-point non-overtaking guarantees and formalization through matching relations. Dive into non-blocking sends' concurrency and the handling of wildcard dependencies. Learn about the "lazy algorithm" for handling cross-coupled wildcard dependencies. Discover the experimental features of MPI, including communication patterns and receiving before sending requirements.

betty
Download Presentation

Illustration of ISP Bug Classes and MPI Happens-Before

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. Illustration of ISP for each bug-classMPI Happens-before: how MPI supports Out-of-order executionThe POE algorithm of ISP explained using MPI happens-before About 30 minutes – by Ganesh

  2. Bug Classes Caught by ISP • Deadlocks • Show how a collective deadlock is caught • Resource Leaks • Demonstrate MPI_hb_different_comm that shows • Coloration in Java GUI depends on communicators • The relaxed HB edges • None between different sends from the same process • They target the same destination • but use different communicators • Buffer Sensitive Deadlocks • Run MPI_BufferingSensitiveDeadlock • With Windows->Preferences->ISP->Use Blocking Sends = true • With the above = false • Assertion violation • Run MPI_AssertTest (red_blue_assert.c) with 4 procs.

  3. Intuitive GUI Display Capabilities • We have already seen the Internal Issue Order • Witness the experimental Time Order stepping feature • Iprobes are interesting! • We can probe one send / receive • But, we can actually communicate with a different send / receive • The ISP GUI shows this really vividly! • Try out MPI_Iprobeillustration, file i-probe-illustration.c • ISP’s execution is directly guided by MPI-hb • MPI_HappensBeforeIllustration • ISP is very mindful of wildcard dependencies that may arise due to continued execution • Try MPI_CrossCoupledWildcardDependency • Discuss our “lazy algorithm” for handling this (not in ISP now)

  4. Formalization of MPI Happens-before It really is matches-before + completes-before

  5. MPI guarantees point-to-point non-overtaking P0 --- S(to:1, msg1, h1); … S(to:1, msg2, h2); … W(h1); … W(h2); P1 --- R(from:0, buf1, h3); … R(from:0, buf2, h4); … W(h3); … W(h4);

  6. MPI guarantees point-to-point non-overtaking Require S(..msg1..) to match a potential receive from P1 BEFORE S(..msg2..) is allowed to match P0 --- S(to:1, msg1, h1); … S(to:1, msg2, h2); … W(h1); … W(h2); P1 --- R(from:0, buf1, h3); … R(from:0, buf2, h4); … W(h3); … W(h4);

  7. MPI guarantees point-to-point non-overtaking Require S(..msg1..) to match a potential receive from P1 BEFORE S(..msg2..) is allowed to match P0 --- S(to:1, msg1, h1); … S(to:1, msg2, h2); … W(h1); … W(h2); P1 --- R(from:0, buf1, h3); … R(from:0, buf2, h4); … W(h3); … W(h4); Require R(..buf1..) to match a potential send from P0 BEFORE R(..buf2..) is allowed to match

  8. MPI guarantees point-to-point non-overtaking Require S(..msg1..) to match a potential receive from P1 BEFORE S(..msg2..) is allowed to match P0 --- S(to:1, msg1, h1); … S(to:1, msg2, h2); … W(h1); … W(h2); P1 --- R(from:0, buf1, h3); … R(from:0, buf2, h4); … W(h3); … W(h4); Require R(..buf1..) to match a potential send from P0 BEFORE R(..buf2..) is allowed to match Achieved by ensuring the above matches-before relations during scheduling

  9. But, do not enforce matches-before needlessly Must we force sends (S) to finish in order in all cases ? Certainly not! (unless you love poor performance) P0 --- S(to:1, big-message, h1); … S(to:2, small-message, h2); … W(h2); … W(h1); P1 --- R(from:1, buf1, h3); … W(h3); P1 --- R(from:2, buf2, h4); … W(h4);

  10. But, do not enforce matches-before needlessly Must we force sends (S) to finish in order in all cases ? Certainly not! (unless you love poor performance) P0 --- S(to:1, big-message, h1); … S(to:2, small-message, h2); … W(h2); … W(h1); P1 --- R(from:1, buf1, h3); … W(h3); P1 --- R(from:2, buf2, h4); … W(h4); Non-blocking sends (S) allow later actions of the same process (including “unrelated” non-blocking sends) to be concurrent.

  11. But, do not enforce matches-before needlessly Must we force sends (S) to finish in order in all cases ? Certainly not! (unless you love poor performance) P0 --- S(to:1, big-message, h1); … S(to:2, small-message, h2); … W(h2); … W(h1); P1 --- R(from:1, buf1, h3); … W(h3); P1 --- R(from:2, buf2, h4); … W(h4); Non-blocking sends (S) allow later actions of the same process (including “unrelated” non-blocking sends) to be concurrent. Achieved by NOT having matches-before between the S within P0

  12. MPI is tricky… till you see how it really works! Will this single-process example called “Auto-send” deadlock ? P0 : R(from:0, h1); B; S(to:0, h2); W(h1); W(h2);

  13. MPI is tricky… till you see how it really works! Will this single-process example called “Auto-send” deadlock ? P0 : R(from:0, h1); B; S(to:0, h2); W(h1); W(h2); Again no! R (non-blocking receive) only initiates receipt – likewise non-blocking send (S) only initiates sending. These activities go on concurrently within the same process.

  14. How Example Auto-send works P0 : R(from:0, h1); B; S(to:0, h2); W(h1); W(h2);

  15. How Example Auto-send works The HB P0 : R(from:0, h1); B; S(to:0, h2); W(h1); W(h2);

  16. How Example Auto-send works Issue R(from:0, h1), because prior to issuing R, P0 is not at a fence P0 : R(from:0, h1); B; S(to:0, h2); W(h1); W(h2);

  17. How Example Auto-send works Issue B, because after issuing R, P0 is not at a fence P0 : R(from:0, h1); B; S(to:0, h2); W(h1); W(h2);

  18. How Example Auto-send works Form match set; Match-enabled set is {B} P0 : R(from:0, h1); B; S(to:0, h2); W(h1); W(h2);

  19. How Example Auto-send works Fire Match-enabled set {B} P0 : R(from:0, h1); B; S(to:0, h2); W(h1); W(h2);

  20. How Example Auto-send works Issue S(to:0, h2) because since B is gone, P0 is no longer at a fence P0 : R(from:0, h1); B; S(to:0, h2); W(h1); W(h2);

  21. How Example Auto-send works Issue W(h1) because after S(to:0, h2), P0 is not at a fence P0 : R(from:0, h1); B; S(to:0, h2); W(h1); W(h2);

  22. How Example Auto-send works Can’t form a { W(h1) } match set because it has an unmatched ancestor (namely R(from:0, h1) ). P0 : R(from:0, h1); B; S(to:0, h2); W(h1); W(h2);

  23. How Example Auto-send works Form and issue the { R(from:0, h1), S(to:0, h2) } match set, and issue P0 : R(from:0, h1); B; S(to:0, h2); W(h1); W(h2);

  24. How Example Auto-send works Now form and issue the match set { W(h1) } P0 : R(from:0, h1); B; S(to:0, h2); W(h1); W(h2);

  25. How Example Auto-send works Now issue W(h2) P0 : R(from:0, h1); B; S(to:0, h2); W(h1); W(h2);

  26. How Example Auto-send works Form match set { W(h2) } and fire it. Done. P0 : R(from:0, h1); B; S(to:0, h2); W(h1); W(h2);

  27. End of D

More Related