# Adaptive Versioning in Transactional Memory Systems +
## 6 Experimental Evaluation
### Evaluation of Adaptive in Non-Persistent Memories
In all the benchmarks, the minimum execution time gain for Adaptive ranges between 1 and 1.16 when running with threads up to 4 numbers. It is interesting to mention here that the Adaptive versioning technique outperforms both _eager_ and _lazy_ versioning for most of the applications in all the benchmark suites. This is mainly due to the decrease in number of aborts and the better time barrier design where non-conflicting transactions can execute and commit in parallel. Furthermore, the delay due to writing data in persistent log is not the concern in non-persistent TMs which also helps in reducing the total execution time. switch mechanism (\(SW\_INT=2\)). The improvement is up to \(1.09\times\) compared to Adaptive with better time barrier. Alongwith decreasing the total number of aborts, the better switch mechanism decreases the total number of switches between the versioning methods which helps to get the improvement on execution time. Figure 27 illustrates the reduction of total number of switches using better switch mechanism for STAMP benchmarks. The experiments on micro-benchmarks and STAMPEDE showed similar results. The experiments so far use \(Threshold_{Eager}=\frac{1}{2}\) and \(Threshold_{Lazy}=2\) as computed in Section 4. It is natural to ask whether these are the ideal threshold values. Therefore, for \(Threshold_{Eager}\), we used \(\frac{1}{4}\) and \(\frac{3}{4}\), whereas for \(Threshold_{Lazy}\), we used 1 and 3. We performed experiments by using two different combinations of \(Threshold_{Eager}\) and \(Threshold_{Lazy}\), \((\frac{1}{4},1)\) and \((\frac{3}{4},3)\). We noticed the increase in both execution time and number of aborts in all the benchmarks for both the combinations. This suggests that the threshold values computed in Section 4 are appropriate. Figure 23: Execution time in STAMPEDE benchmarks using better time barrier in non-persistent TM. Figure 24: Number of aborts in STAMPEDE benchmarks using better time barrier in non-persistent TM. Figure 25: Execution time in STAMP benchmarks using better barrier and better switch in non-persistent TM. Figure 27: Decrease in total number of switches between versioning methods using better switch mechanism in non-persistent TM. Figure 26: Aborts in STAMP benchmarks using better barrier and better switch in non-persistent TM. The results reported in Figures 19-27 use _suicide_ as a contention management technique. We were interested to see whether other strategies perform better than _suicide_. Therefore, we performed experiments using 4 different contention management techniques _suicide_, _delay_, _back-off_, and _kill_ for the comparison. The execution time is shown in Figure 28 and the number of aborts is shown in Figure 29 for \(Adaptive\_ETL\) in STAMP benchmarks. The results showed not significant change on performance in some of the benchmarks, while in the rest, the selection of contention management technique affected the performance. For example, _genome_ and _intruder_ performed better with _suicide_ whereas, _kmeans_ performed better with _back-off_. In overall, _suicide_ performed better than the rest in most of the benchmarks. Finally, we performed experiments starting the execution initially using eager and lazy versioning. We observed that the initial selection of versioning does not affect performance significantly in both micro and complex benchmarks except _intruder_ and _kmeans_ from STAMP in which Adaptive performed better when starting with _Eager_ than _Lazy_ for upto 4 threads. This is mainly because transactions have almost constant abort rate and versioning method change is not necessary.