DMCA
Memoizing Multi-Threaded Transactions
Cached
Download Links
| Citations: | 1 - 0 self |
BibTeX
@MISC{Ziarek_memoizingmulti-threaded,
author = {Lukasz Ziarek and Suresh Jagannathan},
title = {Memoizing Multi-Threaded Transactions},
year = {}
}
Share
 |
 |
 |
 |
||
OpenURL
Abstract
Abstract. There has been much recent interest in using transactions to simplify concurrent programming, improve scalability, and increase performance. When a transaction must abort due to a serializability violation, deadlock, or resource exhaustion, its effects are revoked, and the transaction re-executed. For long-lived transactions, however, the cost of aborts and subsequent re-executions can be prohibitive. To ensure performance, programmers are often forced to reason about transaction lifetimes and interactions while structuring their code, defeating the simplicity transactions purport to provide. One way to reduce the overheads of re-executing a failed transaction is to avoid re-executing those operations that were unaffected by the violation(s) that induced the abort. Memoization is one way to capitalize on re-execution savings, especially if violations are not pervasive. Abstractly, if a procedure p is applied with argument v within a transaction, and the transaction aborts, p need only be re-evaluated when the transaction is retried if its argument is different from v. In this paper, we consider the memoization problem for transactions in the context of Concurrent ML (CML) [20]. Our design supports multi-threaded transactions which allow internal communication through synchronous channel-based communication. The challenge to memoization in the context is ensuring that communication actions performed by memoized procedures in the original (aborted) execution can be satisfied when the transaction is retried. We validate the effectiveness of our approach using STMBench7 [9], a customizable transaction benchmark. Our results indicate that memoization for CMLbased transactions can lead to substantial reduction in re-execution costs (up to 45 % on some configurations), with low memory overheads. 1
Keyphrases
multi-threaded transaction resource exhaustion substantial reduction memoization problem long-lived transaction low memory overhead re-execution saving much recent interest concurrent ml internal communication serializability violation memoized procedure concurrent programming transaction lifetime transaction abort simplicity transaction subsequent re-executions synchronous channel-based communication communication action cmlbased transaction customizable transaction benchmark re-execution cost failed transaction
