Escalonamento de transações em memória a nível de usuário em Haskell

Abstract

Transactional memory is a thread synchronization model that uses a transaction concept which is similar to the one seen in databases. This model is highly abstract, since the programmer only needs to define data that must be synchronized, whereas the synchronization task is performed by the transactional system. Although transactional memories are highly abstract, they tend to lose performance in high contention systems due to the large conflict rate between transactions. This leads to performance deterioration, as available resources (cores) are not explored in an efficient way. In this context, the transactional scheduling appears as an alternative to mitigate the high rate of cancellations. In this strategy, transactions are managed so that new conflicts are avoided, by distributing transactions in a way that available computational resources (cores) can be explored more efficiently. This work presents three transactional schedulers which are developed in Haskell, exploring its practicality of implementing complex structures in a programming language which has a high level of abstraction. The goal of this work is to show the behaviour comparison of different scheduling techniques over different transactional algorithms, such as TL2, TINY and SWISS – where they have, respectively, late, forward and mixed data versioning. The results of this work show that by using the schedulers, the number of conflicts has been reduced in most of applications, which reduced overall runtime. In addition, when schedulers were used in applications where maximum memory contention occurred, system deterioration was lower – runtime was near constant, independently of number of threads used. Finally, it has been noted that scheduler efficiency (reducing conflicts) is also associated with the type of transactional memory algorithm that is used, and not just with its capacity to deal with conflicts.