System and method for managing contention in transactional memory using global execution data
Transactional Lock Elision (TLE) may allow threads in a multi-threaded system to concurrently execute critical sections as speculative transactions. Such speculative transactions may abort due to contention among threads. Systems and methods for managing contention among threads may increase overall performance by considering both local and global execution data in reducing, resolving, and/or mitigating such contention. Global data may include aggregated and/or derived data representing thread-local data of remote thread(s), including transactional abort history, abort causal history, resource consumption history, performance history, synchronization history, and/or transactional delay history. Local and/or global data may be used in determining the mode by which critical sections are executed, including TLE and mutual exclusion, and/or to inform concurrency throttling mechanisms. Local and/or global data may also be used in determining concurrency throttling parameters (e.g., delay intervals) used in delaying a thread when attempting to execute a transaction and/or when retrying a previously aborted transaction.
1. A computer-implemented method, comprising:
initiating execution of a thread comprising a transaction involving a shared resource in a multi-threaded, transactional memory system;
delaying, for an interval determined according to a concurrency throttling mechanism, an attempt by the thread to execute the transaction, wherein said interval is determined dependent, at least in part, on global execution data with regard to transaction attempts involving said shared resource by a plurality of threads, wherein the global execution data is dependent on respective local execution histories of the plurality of threads with regard to said shared resource; and
the thread attempting to execute the transaction subsequent to said interval.
2. The method of claim 1 , wherein said delaying and said attempting are performed in response to a failure of a previous attempt by the thread to execute the transaction.
3. The method of claim 1 , wherein the local execution history comprises data derived from one or more of: transactional abort history, abort causal history, resource consumption history, performance history, synchronization history, or transactional delay history.
4. The method of claim 1 , wherein the concurrency throttling mechanism comprises a backoff mechanism, the method further comprising:
determining a backoff delay interval to be used by the backoff mechanism, dependent on the global execution data.
5. The method of claim 1 , further comprising:
updating the global execution data dependent on results of said attempting.
6. The method of claim 1 , further comprising:
in response to said attempting resulting in an abort of the transaction, retrying the transaction.
7. The method of claim 1 , wherein said attempting comprises:
determining an execution mode dependent, at least in part, on the global execution data; and
executing the transaction using the execution mode;
wherein the execution mode comprises one of: transactional lock elision or mutual exclusion.
8. A system comprising:
one or more processors; and
a memory coupled to the one or more processors and storing memory instructions executable by one or more processors to implement:
initiating execution of a thread comprising a transaction involving a shared resource in a multi-threaded, transactional memory system;
delaying, for an interval determined according to a concurrency throttling mechanism, an attempt by the thread to execute the transaction wherein said interval is determined dependent, at least in part, on global execution data with regard to transaction attempts involving said shared resource by a plurality of threads, wherein the global execution data is dependent on respective local execution history of at least one other thread, wherein said local execution history is local execution histories of the plurality of threads; and
the thread attempting to execute the transaction subsequent to said interval.
9. The system of claim 8 , wherein said delaying and said attempting are performed in response to a failure of a previous attempt by the thread to execute the transaction.
10. The system of claim 8 , wherein the local execution history comprises data derived from one or more of: transactional abort history, abort causal history, resource consumption history, performance history, synchronization history, or transactional delay history.
11. The method of claim 8 , wherein the concurrency throttling mechanism comprises one of: a backoff mechanism, k-exclusion, or group exclusion.
12. The system of claim 8 , wherein program instructions are further executable to implement:
updating the global execution data dependent on results of said attempting.
13. The system of claim 8 , wherein program instructions are further executable to implement:
in response to said attempting resulting in an abort of the transaction, retrying the transaction.
14. The system of claim 8 , wherein said attempting comprises:
determining an execution mode dependent, at least in part, on the global execution data; and
executing the transaction using the execution mode;
wherein the execution mode comprises one of: transactional lock elision or mutual exclusion.
15. A non-transitory computer readable storage medium storing computer-executable program instructions to implement:
initiating execution of a thread comprising a transaction involving a shared resource in a multi-threaded, transactional memory system;
delaying, for an interval determined according to a concurrency throttling mechanism, an attempt by the thread to execute the transaction, wherein said interval is determined dependent, at least in part, on global execution data with regard to transaction attempts involving said shared resource by a plurality of threads, wherein the global execution data is dependent on respective local execution histories of the plurality of threads with regard to said shared resource; and
the thread attempting to execute the transaction subsequent to said interval.
16. The non-transitory storage medium of claim 15 , wherein said delaying and said attempting are performed in response to a failure of a previous attempt by the thread to execute the transaction.
17. The non-transitory storage medium of claim 15 , wherein the local execution history comprises data derived from one or more of: transactional abort history, abort causal history, resource consumption history, performance history, synchronization history, or transactional delay history.
18. The non-transitory storage medium of claim 15 , wherein the program instructions are further executable to implement:
updating the global execution data dependent on results of said attempting.
19. The non-transitory storage medium of claim 15 , wherein the program instructions are further executable to implement:
in response to said attempting resulting in an abort of the transaction, retrying the transaction.
20. The non-transitory storage medium of claim 15 , wherein said attempting comprises:
determining an execution mode dependent, at least in part, on the global execution data; and
executing the transaction using the execution mode;
wherein the execution mode comprises one of: transactional lock elision or mutual exclusion.