Analysis, classification and comparison of scheduling techniques for software transactional memories

Transactional Memory (TM) is a practical programming paradigm for developing concurrent applications. Performance is a critical factor for TM implementations, and various studies demonstrated that specialised transaction/thread scheduling support is essential for implementing performance-effective TM systems. After one decade of research, this article reviews the wide variety of scheduling techniques proposed for Software Transactional Memories. Based on peculiarities and differences of the adopted scheduling strategies, we propose a classification of the existing techniques, and we discuss the specific characteristics of each technique. Also, we analyse the results of previous evaluation and comparison studies, and we present the results of a new experimental study encompassing techniques based on different scheduling strategies. Finally, we identify potential strengths and weaknesses of the different techniques, as well as the issues that require to be further investigated

A speculative execution approach to provide semantically aware contention management for concurrent systems

PhD ThesisMost modern platforms offer ample potention for parallel execution of concurrent programs yet concurrency control is required to exploit parallelism while maintaining program correctness. Pessimistic con- currency control featuring blocking synchronization and mutual ex- clusion, has given way to transactional memory, which allows the composition of concurrent code in a manner more intuitive for the application programmer. An important component in any transactional memory technique however is the policy for resolving conflicts on shared data, commonly referred to as the contention management policy. In this thesis, a Universal Construction is described which provides contention management for software transactional memory. The technique differs from existing approaches given that multiple execution paths are explored speculatively and in parallel. In the resolution of conflicts by state space exploration, we demonstrate that both concur- rent conflicts and semantic conflicts can be solved, promoting multi- threaded program progression. We de ne a model of computation called Many Systems, which defines the execution of concurrent threads as a state space management problem. An implementation is then presented based on concepts from the model, and we extend the implementation to incorporate nested transactions. Results are provided which compare the performance of our approach with an established contention management policy, under varying degrees of concurrent and semantic conflicts. Finally, we provide performance results from a number of search strategies, when nested transactions are introduced

A semantically aware transactional concurrency control for GPGPU computing

PhD ThesisThe increased parallel nature of the GPU a ords an opportunity for the exploration of multi-thread computing. With the availability of GPU has recently expanded into the area of general purpose program- ming, a concurrency control is required to exploit parallelism as well as maintaining the correctness of program. Transactional memory, which is a generalised solution for concurrent con ict, meanwhile allow application programmers to develop concurrent code in a more intu- itive manner, is superior to pessimistic concurrency control for general use. The most important component in any transactional memory technique is the policy to solve con icts on shared data, namely the contention management policy. The work presented in this thesis aims to develop a software trans- actional memory model which can solve both concurrent con ict and semantic con ict at the same time for the GPU. The technique di ers from existing CPU approaches on account of the di erent essential ex- ecution paths and hardware basis, plus much more parallel resources are available on the GPU. We demonstrate that both concurrent con- icts and semantic con icts can be resolved in a particular contention management policy for the GPU, with a di erent application of locks and priorities from the CPU. The basic problem and a software transactional memory solution idea is proposed rst. An implementation is then presented based on the execution mode of this model. After that, we extend this system to re- solve semantic con ict at the same time. Results are provided nally, which compare the performance of our solution with an established GPU software transactional memory and a famous CPU transactional memory, at varying levels of concurrent and semantic con icts

The parallel event loop model and runtime: a parallel programming model and runtime system for safe event-based parallel programming

Recent trends in programming models for server-side development have shown an increasing popularity of event-based single- threaded programming models based on the combination of dynamic languages such as JavaScript and event-based runtime systems for asynchronous I/O management such as Node.JS. Reasons for the success of such models are the simplicity of the single-threaded event-based programming model as well as the growing popularity of the Cloud as a deployment platform for Web applications. Unfortunately, the popularity of single-threaded models comes at the price of performance and scalability, as single-threaded event-based models present limitations when parallel processing is needed, and traditional approaches to concurrency such as threads and locks don't play well with event-based systems. This dissertation proposes a programming model and a runtime system to overcome such limitations by enabling single-threaded event-based applications with support for speculative parallel execution. The model, called Parallel Event Loop, has the goal of bringing parallel execution to the domain of single-threaded event-based programming without relaxing the main characteristics of the single-threaded model, and therefore providing developers with the impression of a safe, single-threaded, runtime. Rather than supporting only pure single-threaded programming, however, the parallel event loop can also be used to derive safe, high-level, parallel programming models characterized by a strong compatibility with single-threaded runtimes. We describe three distinct implementations of speculative runtimes enabling the parallel execution of event-based applications. The first implementation we describe is a pessimistic runtime system based on locks to implement speculative parallelization. The second and the third implementations are based on two distinct optimistic runtimes using software transactional memory. Each of the implementations supports the parallelization of applications written using an asynchronous single-threaded programming style, and each of them enables applications to benefit from parallel execution

On the Impact of Serializing Contention Management on STM Performance

Abstract. Transactional memory (TM) is an emerging concurrent programming abstraction. Numerous software-based transactional memory (STM) implementations have been developed in recent years. STM implementations must guarantee transaction atomicity and isolation. In order to ensure progress, an STM implementation must resolve transaction collisions by consulting a contention manager (CM). Recent work established that serializing contention management- a technique in which the execution of colliding transactions is serialized for eliminating repeatcollisions- can dramatically improve STM performance in high-contention workloads. In low-contention and highly-parallel workloads, however, excessive serialization of memory transactions may limit concurrency too much and hurt performance. It is therefore important to better understand how the impact of serialization on STM performance varies as a function of workload characteristics. We investigate how serializing CM influences the performance of STM systems. Specifically, we study serialization’s influence on STM throughput (number of committed transactions per time unit) and efficiency (ratio between the extent of “useful” work done by the STM and work “wasted ” by aborts) as the workload’s level of contentio

Transaction Scheduling Using Conflict Avoidance And Contention Intensity

In the last few years, Transactional Memories (TMs) have been shown to be a parallel programming model that can effectively combine performance improvement with ease of programming. Moreover, the recent introduction of TM-based ISA extensions, by major microprocessor manufacturers, also seems to endorse TM as a programming model for today's parallel applications. One of the central issues in designing Software TM (STM) systems is to identify mechanisms/heuristics that can minimize contention arising from conflicting transactions. Although a number of mechanisms have been proposed to tackle contention, such techniques have a limited scope, as conflict is avoided by either interrupting or serializing transaction execution, thus considerably impacting performance. To deal with this limitation, we have proposed a new effective transaction scheduler, along with a conflict-avoidance heuristic, that implements a fully cooperative scheduler that switches a conflicting transaction by another with a lower conflicting probability. This paper extends such framework and introduces a new heuristic, built from the combination of our previous conflict avoidance technique with the Contention Intensity heuristic proposed by Yoo and Lee. Experimental results, obtained using the STMBench7 and STAMP benchmarks atop tinySTM, show that the proposed heuristic produces significant speedups when compared to other four solutions. © 2013 IEEE.236245IEEE Computer Society's Technical',ACM,Committee on Parallel Processing (TCPP),et al.,Shell IndiaHerlihy, M., Moss, J.E.B., Transactional memory: Architectural support for lock-free data structures (1993) Proceedings of the 20th Annual International Symposium on Computer Architecture, pp. 289-300. , JunWang, A., Gaudet, M., Wu, P., Amaral, J.N., Ohmacht, M., Barton, C., Silvera, R., Michael, M., Evaluation of blue gene/q hardware support for transactional memories (2012) Proceedings of the 21st International Conference on Parallel Architectures and Compilation Techniques, pp. 127-136Christie, D., Chung, J.-W., Diestelhorst, S., Hohmuth, M., Pohlack, M., Fetzer, C., Nowack, M., Rivière, E., Evaluation of amd's advanced synchronization facility within a complete transactional memory stack (2010) Proceedings of the 5th European Conference on Computer Systems, pp. 27-40Chung, J., Yen, L., Diestelhorst, S., Pohlack, M., Hohmuth, M., Christie, D., Grossman, D., ASF: AMD64 extension for lock-free data structures and transactional memory (2010) Proceedings of the 43rd ACM/IEEE International Symposium on Microarchitecture, pp. 39-50. , Dec(2012) Intel Architecture Instruction Set Extensions Programming Reference, , Intel, FebHarris, T., Larus, J., Rajwar, R., (2010) Transactional Memory, , 2nd ed. Morgan & Claypool Publishers, JunGuerraoui, R., Herlihy, M., Pochon, B., Towards a theory of transactional contention managers (2006) Proceedings of the Twenty-fifth Annual ACM Symposium on Principles of Distributed Computing, pp. 316-317Ansari, M., Lujan, M., Kotselidis, C., Jarvis, K., Kirkham, C., Watson, I., Steal-on-Abort: Improving transactional memory performance through dynamic transaction reordering (2009) Proceedings of the 4th International Conference on High Performance Embedded Architectures and Compilers, pp. 4-18. , JanDolev, S., Hendler, D., Suissa, A., CAR-STM: Scheduling-based collision avoidance and resolution for software transactional memory (2008) Proceedings of the 27th Annual Symposium on Principles of Distributed Computing, pp. 125-134. , AugYoo, R.M., Lee, H.-H.S., Adaptive transaction scheduling for transactional memory systems (2008) Proceedings of the 20th Annual ACM Symposium on Parallel Algorithms and Architectures, pp. 169-178. , JunDragojevic, A., Guerraoui, R., Singh, A.V., Singh, V., Preventing versus curing: Avoiding conflicts in transactional memories (2009) Proceedings of the 28th Annual Symposium on Principles of Distributed Computing, pp. 7-16. , AugNicácio, D., Baldassin, A., Araújo, G., LUTS: A lightweight userlevel transaction scheduler (2011) Proceedings of the 11th International Conference on Algorithms and Architectures for Parallel Processing, pp. 144-157. , OctNicácio, D., Baldassin, A., Araujo, G., Transaction scheduling using dynamic conflict avoidance (2013) International Journal of Parallel Programming, 41 (1), pp. 89-110Guerraoui, R., Kapalka, M., Vitek, J., STMBench7: A benchmark for software transactional memory (2007) Proceedings of the 2nd European Conference on Computer Systems, pp. 315-324. , MarMinh, C.C., Chung, J., Kozyrakis, C., Olukotun, K., STAMP: Stanford transactional applications for multi-processing (2008) Proceedings of the IEEE International Symposium on Workload Characterization, pp. 35-46. , SepChristie, D., Chung, J.-W., Diestelhorst, S., Hohmuth, M., Pohlack, M., Fetzer, C., Nowack, M., Riviere, E., Evaluation of AMD's advanced synchronization facility within a complete transactional memory stack (2010) Proceedings of the 5th European Conference on Computer Systems, pp. 27-40. , AprHerlihy, M., Luchangco, V., Moir, M., Scherer, W.N., Software transactional memory for dynamic-sized data structures (2003) Proceedings of the 22nd Annual Symposium on Principles of Distributed Computing, pp. 92-101. , JulGuerraoui, R., Herlihy, M., Pochon, B., Polymorphic contention management (2005) 19th International Symposium on Distributed Computing, pp. 303-323. , SepScherer, W.N., Scott, M.L., Advanced contention management for dynamic software transactional memory (2005) Proceedings of the 24th Annual Symposium on Principles of Distributed Computing, pp. 240-248Attiya, H., Epstein, L., Shachnai, H., Tamir, T., Transactional contention management as a non-clairvoyant scheduling problem (2006) Proceedings of the 25th Annual Symposium on Principles of Distributed Computing, pp. 308-315. , JulSpear, M.F., Dalessandro, L., Marathe, V.J., Scott, M.L., A comprehensive strategy for contention management in software transactional memory (2009) Proceedings of the 14th Symposium on Principles and Practice of Parallel Programming, pp. 141-150. , FebSharma, G., Busch, C., Window-based greedy contention management for transactional memory: Theory and practice (2012) Distributed Computing, 25 (3), pp. 225-248. , JunAttiya, H., Milani, A., Transactional scheduling for read-dominated workloads (2012) Journal of Parallel and Distributed Computing, 72 (10), pp. 1386-1396. , OctMaldonado, W., Marlier, P., Felber, P., Suissa, A., Hendler, D., Fedorova, A., Lawall, J.L., Muller, G., Scheduling support for transactional memory contention management (2010) Proceedings of the 15th Symposium on Principles and Practice of Parallel Programming, pp. 79-90. , JanBlake, G., Dreslinski, R.G., Mudge, T., Proactive transaction scheduling for contention management (2009) Proceedings of the 42nd ACM/IEEE International Symposium on Microarchitecture, pp. 156-167. , DecAtoofian, E., Improving performance of software transactional memory through contention locality (2013) The Journal of Supercomputing, 64 (2), pp. 527-547. , MayHeber, T., Hendler, D., Suissa, A., On the impact of serializing contention management on stm performance (2012) Journal of Parallel and Distributed Computing, 72 (6), pp. 739-750. , Ju