Disjoint- Access Parallelism: Impossibility, Possibility, and Cost of Transactional Memory Implementations

Transcription

1 Disjoint- Access Parallelism: Impossibility, Possibility, and Cost of Transactional Memory Implementations Sebastiano Peluso, Roberto Palmieri, Paolo Romano 2, Binoy Ravindran and Francesco Quaglia ACM Symposium on Principles of Distributed Computing (PODC) 25

2 Degrees of Parallelism [SPAA8, SPAA9] Strict Disjoint-Access Parallelism (S-DAP): Two transactions do not contend on a common base object if they do not access any common transactional object. Weak Disjoint-Access Parallelism (W-DAP): Two transactions do not concurrently contend on a common base object if there is no path between them in the conflict graph. x y z locks clocks versions T 2 T W(x) R(z) R(x) W(z) R(z) T 3 ACM Symposium on Principles of Distributed Computing (PODC) 25 S- DAP: T and T 3 cannot contend on a common base object. W- DAP: T and T 3 can concurrently contend on a common base object.

3 Desirable properties in TM Isolation Level? Non- concurrent txs Parallelism Disjoint- Access parallelism (DAP) Real- time Order (RTO) Update txs Obstruction- free (OFU) ACM Symposium on Principles of Distributed Computing (PODC) 25 Read- only txs Wait- free and Invisible (WFIRO)

4 Existing Impossibility Results Impossibility on Wait- free Invisible Read- Only (WFIRO) [SPAA9, TCS] (Strict) Serializability WFIRO + W-DAP + Opacity Snapshot Isolation Lower Bound: Wait-free Read-only txs should write on at least t- base objects when t+ processes execute. Impossibility on Obstruction- free Updates (OFU) [SPAA8, SPAA4] OFU + S-DAP + ACM Symposium on Principles of Distributed Computing (PODC) 25 Serializability PCL Theorem: No TM can ensure S-DAP, Obstruction-freedom and Weak Adaptive Consistency (weaker than Snapshot Isolation and Processor Consistency).

5 Roadmap of Results Impossibility Results o Real-Time Order + o Wait-free Read-only Txs + WDAP +. Obstruction-free Update Txs 2. Invisible Read-only Txs + Weakly Progressive Update Txs Possibility Result o Witnessable Real-Time Order + o Extended Update Serializability + o SDAP + o Wait-free Invisible Read-only Txs + o Strongly Progressive Update Transactions and corresponding costs o Space Complexity: Ω(min(N o,n p )) per data-version o Time Complexity: Ω(k*N o ) per read operation N p = number of processes N o = number of objects k = number of versions per object

6 What about Preserving Real- Time Order? Real-time order (RTO) relation: T is ordered before T 2 if the commit of T precedes the begin of T 2. Transactions should appear as executed without violating the Real-time order [PPoPP8]. Executions Possible Serialization Orders T T 2 T T 2 T T T 2 T 2 T T 2 T T 2 ACM Symposium on Principles of Distributed Computing (PODC) 25

7 Impossibility Results on Real- Time Order Wait- free Read- only Txs Obstruction- free Update Txs W- DAP Wait- free and Invisible Read- only Txs Weakly Progressive Update Txs We prove that TM cannot preserve Real- time Order (RTO) Visible Read- only Txs enable S- DAP + Opacity [ICDCN] ACM Symposium on Principles of Distributed Computing (PODC) 25

8 Sketch on the Impossibility: What Should a Transaction Read? [Lemma 3 simplified] WDAP TM + WFRO + RTO Read the last committed value! i α R(x) :? β R(x) must return! T j δ W(x,) γ α, β, δ, γ are non- conflicting intervals T is a read- only transaction T cannot abort because of WFRO Indistinguishable to process p i because of WDAP (and Lemmas, 2) T i α R(x) : β T j δ W(x,) γ Otherwise RTO is not preserved ACM Symposium on Principles of Distributed Computing (PODC) 25

9 Sketch on the Impossibility: Violating the Real- Time Order By contradiction we assume that WDAP + WFRO + RTO is possible, then Obstruction- free Update Txs T commits because it runs solo and it cannot wait for T 3 s outcome to commit T 2 commits because it runs solo Weakly Progressive Update Txs & Invisible Read- only Txs T commits because it cannot detect the conflict with T 3 T 2 commits because it does not encounter any conflict i W(y,) T j W(x,2) T k R(y): R(x): 2 R(x) must return 2 because of Lemma 3 Real- Time Order violated: T 2 appears as executed before T! ACM Symposium on Principles of Distributed Computing (PODC) 25

10 Roadmap of Results Impossibility Results o Real-Time Order + o Wait-free Read-only Txs + WDAP +. Obstruction-free Update Txs 2. Invisible Read-only Txs + Weakly Progressive Update Txs Possibility Result o Witnessable Real-Time Order + o Extended Update Serializability + o SDAP + o Wait-free Invisible Read-only Txs + o Strongly Progressive Update Transactions and corresponding costs o Space Complexity: Ω(min(N o,n p )) per data-version o Time Complexity: Ω(k*N o ) per read operation N p = number of processes N o = number of objects k = number of versions per object

11 A Strictly DAP TM Design PARALLELISM S-DAP W-DAP NO DAP READ-ONLY Wait-free Invisible Wait-free Visible and No Wait-free UPDATES ACM Symposium on Principles of Distributed Computing (PODC) 25 Obstructionfree Strongly Progressive Weakly Progressive Properties of Extended Update Serializability: ISOLATION o All transactions observe a serializable history (like Opacity!) Opacity Serializability Extended Update Serializability Witnessable Real-Time Order (WRTO) Real-Time Order preserved only among directly conflicting transactions, and transactions executed by the same process o Committed Update Transactions are serializable (like Opacity!) o Two transactions T, T 2 can observe two non-compatible serialization orders o but only if T and T 2 will never commit any write operation Consistent View

12 Roadmap of Results Impossibility Results o Real-Time Order + o Wait-free Read-only Txs + WDAP +. Obstruction-free Update Txs 2. Invisible Read-only Txs + Weakly Progressive Update Txs Possibility Result o Witnessable Real-Time Order + o Extended Update Serializability + o SDAP + o Wait-free Invisible Read-only Txs + o Strongly Progressive Update Transactions and corresponding costs o Space Complexity: Ω(min(N o,n p )) per data-version o Time Complexity: Ω(k*N o ) per read operation N p = number of processes N o = number of objects k = number of versions per object

13 N p = number of processes N o = number of objects k = number of versions per object Detected Costs The TM requires to store a vector clock of size N p per data-version. A read operation by a read-only T may validate T s read-set to check if it can return a data-version. Space Complexity O(N p ) integers for each version of a transactional object Time Complexity O(k*N o ) steps to execute a read operation of a read- only tx Are these costs necessary? ACM Symposium on Principles of Distributed Computing (PODC) 25

14 Consistent View Consistent View: all transactions read from a causally consistent snapshot. It is weaker than EUS. Opacity [PPoPP8] Strict Serializability Serializability Snapshot Isolation [Adya99] Forward Consistent View Consistent View ACM Symposium on Principles of Distributed Computing (PODC) 25 (Extended) Update Serializability

15 Lower Bound on the Space Complexity Implementation of reads: return version V if V does not depend on a version V* that overwrites the read-set. W(x, A) x y overwrites Intuition on possible S- DAP implementations R(x): A R(y):? T 2 Status of the memory per data- version W(x, B) W(y, C) x 2 y x 2 y W(x, A) p p p 2 ACM Symposium on Principles of Distributed Computing (PODC) 25 R(x): A R(y):? T 2 overwrites W(x, B) W(y, C) p p p 2 Vector clock of size N p per data- version p p p 2 Theorem. SDAP TM that guarantees WFIRO, Consistent View, WRTO and either obstruction- free or weakly progressive update transactions The space complexity for each version of a transactional object is Ω(min(N o,n p ))

16 Proving the Time Complexity Read s objects R(x ): R(x s ): R(x No ):? W(x s ): W(x s+ ): W(x No,) Read s objects Write N o - s objects R(x ): R(x s ): R(x No ):? W(x s- ): W(x s+ ): W(x No,) Read s objects Write N o - s objects R(x ): R(x s ): R(x No ):? W(x s+ ): W(x No,) W(x s- 2 ): s histories Read s objects Write N o - s objects R(x ): R(x s ): R(x No ):? W(x s+ ): W(x No,) W(x ): Write N o - s objects ACM Symposium on Principles of Distributed Computing (PODC) 25

17 Lower Bound on the Time Complexity In a WDAP TM with invisible read-only transactions R(x No ) cannot distinguish the s histories unless it analyzes T s read-set. Consistent View + WRTO + WFIRO: T has to perform s steps to check if R(x No ) can return. s can be equal to N o - and a read can check k versions Theorem. WDAP multi- version TM that guarantees WFIRO, Consistent View, WRTO and either obstruction- free or weakly progressive update transactions The read- only time complexity is Ω(k*N o ) Read- only time complexity: the maximum number of steps performed by any read operation of any read- only transaction ACM Symposium on Principles of Distributed Computing (PODC) 25

18 Related Results Lower Bound on the Number of Visible Reads [SPAA9, TCS] Hypothesis: WDAP TM + Strict Serializability + Minimal Progressive Update txs. Result: Wait-free Read-only txs should write on at least t- base objects when t+ processes execute in a WDAP TM. Relation: The result is only a necessary condition in case Update txs are Obstruction-free since RTO cannot be preserved. The result is sufficient in case Update txs are Weakly Progressive [ICDCN]. Impossibility Result in Multi- Version- Permissive TM [PODC] Hypothesis: WDAP TM + MV-Permissiveness Result: No Strict Serializability. Relation: In a parasitic-free environment MV- Permissiveness could provide Wait- free and Invisible Read- only txs and Weakly Progressive Update Txs. In that case RTO cannot be preserved. Time Complexity in Progressive TM [PPoPP8] Hypothesis: Progressive single-version TM + Opacity Result: The maximum number of steps performed by any operation is Ω(Ν ο ) Relation: Same cost to check if a version is observable in a multi-version WDAP TM with WRTO, wait-free and invisible read-only txs and Consistent View. ACM Symposium on Principles of Distributed Computing (PODC) 25

19 Conclusions Two impossibility results ruling DAP TM that guarantees Real-Time Order and a set of desirable progress properties. Possibility result: an SDAP TM that provides a strong correctness property (i.e., EUS), Witnessable Real- Time Order, and the same set of progress properties as before. Lower bounds on the space and time complexity of such a DAP TM. Our Message In a DAP TM lowering the consistency property is not enough. Rather either invisible reads or wait-freedom must be sacrificed! ACM Symposium on Principles of Distributed Computing (PODC) 25

20 Thanks for the attention ACM Symposium on Principles of Distributed Computing (PODC) 25

21 References [Adya99] A. Adya. Weak Consistency: A Generalized Theory and Optimistic Implementations for Distributed Transactions. PhD thesis, 999. AAI8775. [ICDCN] H. Attiya and E. Hillel. Single version STMs can be multi-version permissive. In proc. of the 2th International Conference on Distributed Computing and Networking, ICDCN, 2. [PODC] [POPL9] R. Guerraoui and M. Kapalka. The Semantics of Progress in Lock-based Transactional Memory. In proc. of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages (POPL), 29. [PPoPP8] R. Guerraoui and M. Kapalka. On the Correctness of Transactional Memory. In proc. of the 3th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP), 28. [SPAA8] R. Guerraoui and M. Kapalka. On Obstruction-free Transactions. In proc. of the 2th annual Symposium on Parallelism in Algorithms and Architectures (SPAA), 28. [SPAA9] Hagit Attiya, Eshcar Hillel, and Alessia Milani. Inherent limitations on disjoint-access parallel implementations of transactional memory. In proc. of the 2st annual Symposium on Parallelism in Algorithms and Architectures (SPAA), 29. [SPAA4] Victor Bushkov, Dmytro Dziuma, Panagiota Fatourou, Rachid Guerraoui, The PCL Theorem. Transactions cannot be Parallel, Consistent and Live.. In proc. of the 26th annual Symposium on Parallelism in Algorithms and Architectures (SPAA), 24. [TCS] Hagit Attiya, Eshcar Hillel, and Alessia Milani. Inherent limitations on disjointaccess parallel implementations of transactional memory. Theory Comput. Syst., 49(4):698 79, 2. ACM Symposium on Principles of Distributed Computing (PODC) 25

22 Backup slides ACM Symposium on Principles of Distributed Computing (PODC) 25

23 Seeking a Sweet Spot in Disjoint- Access Parallel TM Objective: S-DAP + WFIRO Isolation Levels Progress Guarantees for Update Txs Opacity [PPoPP8] Strict Serializability Obstruction-free Snapshot Isolation [Adya99] Serializability Forward Consistent View (Extended) Update Serializability Strongly progressive [POPL9] Weakly progressive Consistent View ACM Symposium on Principles of Distributed Computing (PODC) 25

24 What about Preserving Real- Time Order? Real-time order (RTO) relation: T is ordered before T 2 if the commit of T precedes the begin of T 2. Transactions should appear as executed without violating the Real-time order [PPoPP8]. Examples T W(x,) T 2 W(x,2) T 3 R(x) :? T W(y,) T 2 R(y) : T 3 W(x,) R(x) :? Real-time order violated if R(x) returned. ACM Symposium on Principles of Distributed Computing (PODC) 25

25 Details about the SDAP TM N p processes = N p elements per vector clock R(x): A W(x,D) W(y,E) Committed Snapshot W(y,G) Abor t Serializable updates: locks and validation at commit- time T 2 W(z,F) T 3 R(x): A R(y): B R(z): F Current Visible Snapshot Maximum Visible Snapshot Committed Snapshot Revalidate and find that: - D invalidates the read- set - D and E are dependent Revalidate and find that: - D, E invalidate the read- set - D, E and F are concurrent x p A p D y p B p E z p C p F Causally dependent ACM Symposium on Principles of Distributed Computing (PODC) 25 Causally dependent

26 Consistent View Consistent View: all transactions read from a causally consistent snapshot. It is weaker than EUS. Forbidden Read: the read creates an oriented cycle with exactly one write-after-read edge in the conflict graph [Adya99]. Example R(x): R(z): 4 T 2 W(x,2) W(y,3) T 3 R(y): 3 W(z,4) T WR T 2 T 3 WR ACM Symposium on Principles of Distributed Computing (PODC) 25