Transactional CSP processes

Long-lived transactions (LLTs) are transactions intended to be executed over an extended period of time ranging from seconds to days. A long-lived transaction is normally organized as a series of activities, with each activity being a discrete transactional unit of work that releases transactional locks upon its execution. The long-lived transaction commits if all its activities complete successfully. Unless an activity requires the result of a previously committed activity, there is no constraint which specifies that the various activities belonging to a long lived transaction should execute sequentially. In this paper we present a solution that combines long-lived transactions and CSP such that in- dependent activities execute in parallel to achieve flexibility and better performance for long-lived transactions. We introduce two composition constructs SEQ LLT and PAR LLT. Very much as the occam CSP-based constructs, SEQ and PAR, allow processes to be executed sequentially or concurrently, the proposed SEQ LLT and PAR LLT constructs can be used to specify the sequential or concurrent execution of transactions. Transactional CSP Processes is a framework that makes use of these composition constructs, providing an API through which the application developer can define long-lived transactions. Concurrency and transaction handling are managed by the framework transparently from the application developer.peer-reviewe

Open Transactions on Shared Memory

Transactional memory has arisen as a good way for solving many of the issues of lock-based programming. However, most implementations admit isolated transactions only, which are not adequate when we have to coordinate communicating processes. To this end, in this paper we present OCTM, an Haskell-like language with open transactions over shared transactional memory: processes can join transactions at runtime just by accessing to shared variables. Thus a transaction can co-operate with the environment through shared variables, but if it is rolled-back, also all its effects on the environment are retracted. For proving the expressive power of TCCS we give an implementation of TCCS, a CCS-like calculus with open transactions

Progressive Transactional Memory in Time and Space

Transactional memory (TM) allows concurrent processes to organize sequences of operations on shared \emph{data items} into atomic transactions. A transaction may commit, in which case it appears to have executed sequentially or it may \emph{abort}, in which case no data item is updated. The TM programming paradigm emerged as an alternative to conventional fine-grained locking techniques, offering ease of programming and compositionality. Though typically themselves implemented using locks, TMs hide the inherent issues of lock-based synchronization behind a nice transactional programming interface. In this paper, we explore inherent time and space complexity of lock-based TMs, with a focus of the most popular class of \emph{progressive} lock-based TMs. We derive that a progressive TM might enforce a read-only transaction to perform a quadratic (in the number of the data items it reads) number of steps and access a linear number of distinct memory locations, closing the question of inherent cost of \emph{read validation} in TMs. We then show that the total number of \emph{remote memory references} (RMRs) that take place in an execution of a progressive TM in which $n$ concurrent processes perform transactions on a single data item might reach $\Omega(n \log n)$, which appears to be the first RMR complexity lower bound for transactional memory.Comment: Model of Transactional Memory identical with arXiv:1407.6876, arXiv:1502.0272

Differential rates, residual information sets and transactional algebras

The purpose of this paper is to model differential rates over residual information sets, so as to shape transactional algebras into operational grounds. Firstly, simple differential rates over residual information sets are introduced by taking advantage of finite algebras of sets. Secondly, after contextual sets and the relevant algebra of information sets is suitably fashioned, generalized differential rates over residual information sets are expanded on, while a recursive algorithm is set forth to characterize such rates and sets. Thirdly, the notion of transactional algebra is presented and heed is given to the costs of running such structure. Finally, an application to financial arbitrage processes is fully developed within a transactional algebra, setting up arbitrage returns net of transaction costs, establishing boundary conditions for an arbitrage to take place, and finally allowing for a definition of what should be meant by financial arbitrage within a transactional algebra.differential rates, residual information sets, transactional algebras, arbitrage

Value Stream Mapping and Simulation Modelling for Healthcare Transactional Process Improvement

Lean management philosophy was originated in Japan from the Toyota production system. The main idea is to determine and eliminate waste. The concept of end-to-end value allows organizations to achieve competitive advantage through best quality product and services through minimum operational cost. These days there is more to be achieved by applying lean to services and transactional processes floors. Lean facilitators are facing challenges when trying to transform an organization to be a lean enterprise because it is possible in production systems, but that is not easier in the services and transactional sectors, which means there are challenges that should be considered. Some of the challenges for the service sector are; complex and mixed value streams, information and people are processed instead of parts and human interaction is a major part of the service sector

An algebraic approach to transactional processes

Abstract We present a set of operators in order to simplify the modelling of transactional behaviour of processes using process algebra. We give an axiomatic semantics of the operators presented. Apart from that, we give their operational semantics using Plotkin-style deduction rules. Our goal is to give formal speci¯cations of Internet applications using process algebra, for which transactional behaviour should be modelled