An Innovative Approach to Achieve Compositionality Efficiently using Multi-Version Object Based Transactional Systems

In the modern era of multicore processors, utilizing cores is a tedious job. Synchronization and communication among processors involve high cost. Software transaction memory systems (STMs) addresses this issues and provide better concurrency in which programmer need not have to worry about consistency issues. Another advantage of STMs is that they facilitate compositionality of concurrent programs with great ease. Different concurrent operations that need to be composed to form a single atomic unit is achieved by encapsulating them in a single transaction. In this paper, we introduce a new STM system as multi-version object based STM (MVOSTM) which is the combination of both of these ideas for harnessing greater concurrency in STMs. As the name suggests MVOSTM, works on a higher level and maintains multiple versions corresponding to each key. We have developed MVOSTM with the unlimited number of versions corresponding to each key. In addition to that, we have developed garbage collection for MVOSTM (MVOSTM-GC) to delete unwanted versions corresponding to the keys to reduce traversal overhead. MVOSTM provides greater concurrency while reducing the number of aborts and it ensures compositionality by making the transactions atomic. Here, we have used MVOSTM for the list and hash-table data structure as list-MVOSTM and HT- MVOSTM. Experimental results of list-MVOSTM outperform almost two to twenty fold speedup than existing state-of-the-art list based STMs (Trans-list, Boosting-list, NOrec-list, list-MVTO, and list-OSTM). HT-MVOSTM shows a significant performance gain of almost two to nineteen times better than existing state-of-the-art hash-table based STMs (ESTM, RWSTMs, HT-MVTO, and HT-OSTM). MVOSTM with list and hash-table shows the least number of aborts among all the existing STM algorithms. MVOSTM satisfies correctness-criteria as opacity.Comment: 35 pages, 23 figure

Conservative Multi-Generational Age-Based Garbage Collection with Fast Allocation

In the era of today’s technology, Garbage Collectors have high mortality and high efficiency because they look and remove garbage memory blocks among newly created objects. Many very newly created objects are included into these objects which are still live and easily can be identified as live objects. Generational Garbage Collection is a technique which is based on newer objects where the older objects are pointed by these newly created objects; because of this, these type of algorithms earn more efficiency than other garbage collectors. The only one way called “Store Operation” is used to a formerly created objects for pointing to a newly created objects and many languages have limitations for these operations. Recently allocated objects are focused more by a Garbage Collector and these objects can give more support to the above mentioned issue. The efficiency of such type of Garbage Collectors can be measured on the basis of allocation and expenditure type than the disposal of objects. In this paper, we have studied various techniques based on Generational Garbage Collection to observe object structures for producing better layout for finding live objects, in which objects with high temporal weakness are placed next to each other, so that they are likely to locate in the same generation block. This paper presents a low-overhead version of a new Garbage Collection technique, called Conservative multi-generational age-based algorithm which is simple and more efficient with fast allocation, suitable to implement for many object oriented languages. Conservative multi-generational age-based algorithm is compatible with high performance for the many managed object oriented languages