1 / 24

Towards Automating the Redesign of the Synchronization Skeletons of UPC Programs

This project aims to automate the redesign of synchronization skeletons of UPC programs for efficient multithreaded execution. The proposed solution involves transforming synchronization skeletons into guarded commands to ensure properties like deadlock-freedom and mutual exclusion. By generating reachability graphs and finite models, we can automate the revision process to enhance program performance.

pascal
Télécharger la présentation

Towards Automating the Redesign of the Synchronization Skeletons of UPC Programs

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. Towards Automating the Redesign of the Synchronization Skeletons of UPC Programs Presenter: Amin Alipour Adviser: Ali Ebnenasir

  2. Motivations • Help developers in • automated behavioral debugging, and • design of synchronization mechanisms of multithreaded programs, i.e., synchronization skeleton

  3. Example: A UPC Program

  4. Problem • Deadlock • Need deadlock-freedom

  5. Outline • Problem Statement • Proposed Solution • Case Study

  6. Problem Statement • Input: • A UPC program P • A desired mutual exclusion (e.g., lack of data race) or progress property (e.g., deadlock-freedom), denoted L • P does not meet L • Output: • A revised version of P, denoted P_r • Constraints: • P_r meets L • P_r does not violate other properties of P

  7. Proposed Solution UPC Program Revised UPC Program

  8. Synchronization Skeleton of the UPC Program Synch. Skeleton of thread i // Generate an array element index 0/1 TS_i: { upc_lock(lk[i]); upc_lock(lk[s]); } CS_i: { // Swap ... } // Dont forget to unlock upc_unlock(lk[i]); upc_unlock(lk[s]);

  9. Transforming Synchronization Skeleton to Guarded Commands

  10. Guarded Commands • State: snapshot valuation to program variables • Guarded command: • <grd_1>  stmt_1; • [] <grd_2>  stmt_2; • [] … • [] <grd_n>  stmt_n; • Example: • (x > y)  x := x - y; • [] (y > x)  y := y - x; • A set of transitions (s0, s1)‏ • grd is true in s0, and • s1 is reach by atomic execution of stmt

  11. Canonical UPC Programs • For simplicity, we consider a canonical version of the program with • 2 threads • An array with size 2

  12. Case Study-State TSi Trying Section Thread i CSi Critical SectionThread i LKi Lock of Thread i GLKi Lock for Intra-thread Serialization Thread i Si random value selected by Thread i SSi Whether Thread i has selected a random value

  13. Translation of Synchronization Skeleton to Guarded Commands Initial state values: TS_i := true; CS_i := false; sSet_i = false; Ai1: (sSet_i = false) -> s_i := 0|1; sSet_i := true; Ai2: (sSet_i = true) /\ (TS_i = true) /\ (lk[i] = true) /\ (gotLock_i = false) -> lk[i] := false; gotLock_i := true; Ai3: (sSet_i = true) /\ (TS_i = true) /\ (lk[s_i] = true) /\ gotLock_i = true -> lk[s_i] := false; gotLock_i :=false; TS_i := false; CS_i := true; Ai4: (sSet_i = true) /\ (CS_i = true) /\ (lk[i] = false) /\ (lk[s_i] = false) -> lk[i] := true; lk[s_i] := true; CS_i := false;TS_i := true; sSet_i := false;

  14. Generating Reachability Graph for the program

  15. Reachability Graph Generation • Start with initial states • Check applicable commands • Generate new reachable states • run Steps 1 and 2 until no new state is generated

  16. Finite Model

  17. Finite Model

  18. Finite Model

  19. Finite Model

  20. Automatic Revision

  21. Revised Model

  22. Revised Thread 1 Thread 1 { A11: (!SS1  !S2)  (!SS2 || !S1) ->S1=1; SS1 = true; A12: (TS1 !CS1  LK[0] !GLK1 (S1)  SS1)->LK[0] = false;GLK1 = true; A13: (TS1 !CS1 !LK[0]  GLK1 (S1)  SS1)->LK[1] = false; GLK1=false;TS1 = false;CS1 = true; A14: (!TS1  CS1 !LK[0] !GLK1 (S1)  SS1  SS2)->LK[0] = true; LK[1] = true; CS1 = false;TS1 = true;SS1= false; } Avoid s Deadlock Ai1: (sSet_i = false) -> s_i := 0|1; sSet_i := true; Ai2: (sSet_i = true)  (TS_i = true)  (lk[i] = true)  (gotLock_i = false) -> lk[i] := false; gotLock_i := true; Ai3: (sSet_i = true)  (TS_i = true)  (lk[s_i] = true)  gotLock_i = true -> lk[s_i] := false; gotLock_i :=false;TS_i := false;CS_i := true; Ai4: (sSet_i = true)  (CS_i = true)  (lk[i] = false)  (lk[s_i] = false) -> lk[i] := true; lk[s_i] := true; CS_i := false;TS_i := true; sSet_i := false;

  23. Avoids Deadlock Thread 2‏ { A21: !SS2 ->S2=0; SS2 = true; A22: TS2  !CS2  LK[1]  !GLK2  !(S2)  S1  SS2  !SS1 ->LK[1] = false;GLK2 = true; A23: TS2  !CS2  !LK[1]  GLK2  !(S2)  SS2 ->LK[0] = false; GLK2=false;TS2 = false;CS2 = true; A24: !TS2  CS2  !LK[1]  !GLK2  !(S2)  SS2 ->LK[0] = true; LK[1] = true; CS2 = false;TS2 = true;SS2= false; } Imposes sequential execution Ai1: (sSet_i = false) -> s_i := 0|1; sSet_i := true; Ai2: (sSet_i = true)  (TS_i = true)  (lk[i] = true)  (gotLock_i = false) -> lk[i] := false; gotLock_i := true; Ai3: (sSet_i = true)  (TS_i = true)  (lk[s_i] = true)  gotLock_i = true -> lk[s_i] := false; gotLock_i :=false;TS_i := false; CS_i := true; Ai4: (sSet_i = true)  (CS_i = true)  (lk[i] = false)  (lk[s_i] = false) -> lk[i] := true; lk[s_i] := true; CS_i := false;TS_i := true; sSet_i := false;

  24. Questions

More Related