788 research outputs found
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
Achieving Starvation-Freedom with Greater Concurrency in Multi-Version Object-based Transactional Memory Systems
To utilize the multi-core processors properly concurrent programming is
needed. Concurrency control is the main challenge while designing a correct and
efficient concurrent program. Software Transactional Memory Systems (STMs)
provides ease of multithreading to the programmer without worrying about
concurrency issues such as deadlock, livelock, priority inversion, etc. Most of
the STMs works on read-write operations known as RWSTMs. Some STMs work at
high-level operations and ensure greater concurrency than RWSTMs. Such STMs are
known as Object-Based STMs (OSTMs). The transactions of OSTMs can return commit
or abort. Aborted OSTMs transactions retry. But in the current setting of
OSTMs, transactions may starve. So, we proposed a Starvation-Free OSTM
(SF-OSTM) which ensures starvation-freedom in object based STM systems while
satisfying the correctness criteria as co-opacity. Databases, RWSTMs and OSTMs
say that maintaining multiple versions corresponding to each key of transaction
reduces the number of aborts and improves the throughput. So, to achieve
greater concurrency, we proposed Starvation-Free Multi-Version OSTM (SF-MVOSTM)
which ensures starvation-freedom while storing multiple versions corresponding
to each key and satisfies the correctness criteria such as local opacity. To
show the performance benefits, We implemented three variants of SF-MVOSTM
(SF-MVOSTM, SF-MVOSTM-GC and SF-KOSTM) and compared it with state-of-the-art
STMs.Comment: 68 pages, 24 figures. arXiv admin note: text overlap with
arXiv:1709.0103
Efficient Concurrent Execution of Smart Contracts in Blockchains using Object-based Transactional Memory
This paper proposes an efficient framework to execute Smart Contract
Transactions (SCTs) concurrently based on object semantics, using optimistic
Single-Version Object-based Software Transactional Memory Systems (SVOSTMs) and
Multi-Version OSTMs (MVOSTMs). In our framework, a multi-threaded miner
constructs a Block Graph (BG), capturing the object-conflicts relations between
SCTs, and stores it in the block. Later, validators re-execute the same SCTs
concurrently and deterministically relying on this BG.
A malicious miner can modify the BG to harm the blockchain, e.g., to cause
double-spending. To identify malicious miners, we propose Smart Multi-threaded
Validator (SMV). Experimental analysis shows that the proposed multi-threaded
miner and validator achieve significant performance gains over state-of-the-art
SCT execution framework.Comment: 49 pages, 26 figures, 11 table
Model-Based Proactive Read-Validation in Transaction Processing Systems
Concurrency control protocols based on read-validation schemes allow transactions which are doomed to abort to still run until a subsequent validation check reveals them as invalid. These late aborts do not favor the reduction of wasted computation and can penalize performance. To counteract this problem, we present an analytical model that predicts the abort probability of transactions handled via read-validation schemes. Our goal is to determine what are the suited points-along a transaction lifetime-to carry out a validation check. This may lead to early aborting doomed transactions, thus saving CPU time. We show how to exploit the abort probability predictions returned by the model in combination with a threshold-based scheme to trigger read-validations. We also show how this approach can definitely improve performance-leading up to 14 % better turnaround-as demonstrated by some experiments carried out with a port of the TPC-C benchmark to Software Transactional Memory
Transparent and efficient shared-state management for optimistic simulations on multi-core machines
Traditionally, Logical Processes (LPs) forming a simulation model store their execution information into disjoint simulations states, forcing events exchange to communicate data between each other. In this work we propose the design and implementation of an extension to the traditional Time Warp (optimistic) synchronization protocol for parallel/distributed simulation, targeted at shared-memory/multicore machines, allowing LPs to share parts of their simulation states by using global variables. In order to preserve optimism's intrinsic properties, global variables are transparently mapped to multi-version ones, so to avoid any form of safety predicate verification upon updates. Execution's consistency is ensured via the introduction of a new rollback scheme which is triggered upon the detection of an incorrect global variable's read. At the same time, efficiency in the execution is guaranteed by the exploitation of non-blocking algorithms in order to manage the multi-version variables' lists. Furthermore, our proposal is integrated with the simulation model's code through software instrumentation, in order to allow the application-level programmer to avoid using any specific API to mark or to inform the simulation kernel of updates to global variables. Thus we support full transparency. An assessment of our proposal, comparing it with a traditional message-passing implementation of variables' multi-version is provided as well. © 2012 IEEE
- …