Search

As bitcoin has received considerable attentions, a large number of transactions are increasingly published through the Internet. The potential threat to online transactions is not only limited to the anonymity of identities such as a d d r e s s and p s e u d o n y m s , but also other sensitive information shown on scripts like transaction amounts. We propose a framework to hide the amounts by employing the Paillier cryptosystem for encryption and decryption. Due to its homomorphic properties, we create a d u m b a c c o u n t which can receive the same amounts of bitcoins in each transaction but cannot spend them. This ensures that the hidden amounts are always positive, and keeps the equality between the Input-sum and the Output-sum via the commitment proofs. Our framework achieves delicate anonymity and prevents active and passive attacks, which effectively improves the transaction privacy. Analyses show that our proposal is secure and practical.

Along with the increasing prosperity of electric vehicles (EVs), the large-scale penetration of EVs in V2G (Vehicle to Grid) trading market brings difficulties and security issues in the operation of the energy market. The blockchain has the characteristics of security, transparency, decentralization and traceability, which provides an alternative for complex energy market operation in a secure environment. In this paper, a novel hierarchical blockchain architecture is constructed for the V2G trading system including Data Blockchain layer, Operation Blockchain layer and Transaction Blockchain layer. The intelligent contracts of the V2G trading, two-level auction and optimization strategies are designed for scheduling EVs orderly charge and discharge to participate in the grid load regulation so as to minimize the total load variance of the grid and realize reasonable benefit distribution among the involved market entities, i.e., EVs, aggregators and grid. Based on the V2G trading characteristics, a transaction manager with four optimization strategies are designed to further optimize the transaction generation process. The CA (cellular automata) based simulation experiments are performed to verify the effectiveness of the proposed V2G trading system.

With rapidly increasing interest in distributed real-time database systems (DRTDBS), data conflicts amongst distributed transactions have become a crucial factor which negatively influences the system performance. To address above issue, an I mproved Data Lending based D istributed R eal-Time C ommit (IDRC) protocol has been developed. IDRC reduce the negative impact of data conflicts on the DRTDBSperformance by increasing the data accessibility as compared to the earlier protocols. It allows the commit dependent borrower participant node (who has already lent the data item to the abort dependent borrower participant node) to lend the same data item in read mode to more than one borrower participant nodes. The simulation results show that the proposed commit protocol outperforms.

This paper addresses multi-directional energy trading problems (ETPs) for multiple microgrids (MMGs) in grid-connected and islanded modes considering the unit commitment (UC) scheme. Firstly, a mixed integer quadratic programming (MIQP) model is formulated to describe unit commitment problems (UCPs) for each microgrid (MG) and energy transactions among MMGs. Then binary variables from UCPs are relaxed to convert the original non-convex model into a tractable convex one. Furthermore, an alternating optimization method (AOM) composed of alternating direction method of multipliers (ADMM) and MIQP block is proposed to solve continuous and binary variables alternately. Especially, a rounding-off procedure with thresholds is designed to treat out-of-limit problems of generators and smooth the parameter passing between ADMM and MIQP block with corresponding convergence proof. Finally, comprehensive comparisons are conducted to demonstrate the effectiveness of proposed method. Simulation results indicate that AOM can be directly applied to solve ETPs for MMGs in a distributed manner, and thresholds are effective for operators to adjust the operating range of generators flexibly under the condition that ETPs are completely solvable.

Electric power system reform and innovative energy transaction policies have become increasingly common. In view of the fact that research on today’s multi-energy coupled market have not yet incorporated multi-energy substitution characteristics on the supply and demand sides, nor the coordination between regional and user level markets. A joint energy market was developed in this study for the procurement of local integrated energy system services considering demand flexibility. The transaction mechanisms of the regional level energy coupled market and user level Peer-to-Peer (P2P) distributed transaction market were determined accordingly. The multi-energy and complementary regional energy market was coupled with the user-level distributed transaction market that considering flexible demand response characteristics to establish a regional integrated energy system joint market. The electricity, gas, and heat markets in the regional market were modeled separately, then a joint clearing mechanism of the energy coupled market was established. An autonomous scheduling model for distributed market participants at the user level and a P2P transaction mechanism considering multi-agent non-cooperative game was proposed. The bidding behaviors of different energy operators in the regional level market were simulated to assess the influencing factors. The economic and technical benefits of P2P transactions at the user level as remitted to market participants were quantitatively determined with specific indexes. The correlations and interactions between the region level and user level markets were also analyzed.

Wide-column NoSQL databases are an important class of NoSQL (Not only SQL) databases which scale horizontally and feature high access performance on sparse tables. With current trends towards big Data Warehouses (DWs), it is attractive to run existing business intelligence/data warehousing applications on higher volumes of data in wide-column NoSQL databases for low latency by mapping multidimensional models to wide-column NoSQL models or using additional SQL add-ons. For examples, applications like retail management can run over integrated data sets stored in big DWs or in the cloud to capture current item-selling trends. Many of these systems also employ Snapshot Isolation (SI) as a concurrency control mechanism to achieve high throughput for read-heavy workloads. SI works well in a DW environment, as analytical queries can now work on (consistent) snapshots and are not impacted by concurrent update jobs performed by online incremental Extract-Transform-Load (ETL) flows that refresh fact/dimension tables. However, the snapshot made available in the DW is often stale, since at the moment when an analytical query is issued, the source updates (e.g. in a remote retail store) may not have been extracted and processed by the ETL process in time due to high input data volume or slow processing speed. This staleness may cause incorrect results for time-critical decision support queries. To address this problem, snapshots which are supposed to be accessed by analytical queries need to be first maintained by corresponding ETL flows to reflect source updates based on given freshness needs. Snapshot maintenance in this work means maintaining the distributed data partitions that are required by a query. Since most NoSQL databases are not ACID compliant and do not provide full-fledged distributed transaction support, snapshot may be inconsistently derived when its data partitions are updated by different ETL maintenance jobs. This paper describes an extended version of HBelt system [1] which tightly integrates the wide-column NoSQL database HBase with a clustered & pipelined ETL engine. Our objective is to efficiently refresh HBase tables with remote source updates while a consistent snapshot is guaranteed across distributed partitions for each scan request in analytical queries. A consistency model is defined and implemented to address so-called distributed snapshot maintenance . To achieve this, ETL jobs and analytical queries are scheduled in a distributed processing environment. In addition, a partitioned, incremental ETL pipeline is introduced to increase the performance of ETL (update) jobs. We validate the efficiency gain in terms of data pipelining and data partitioning using the TPC-DS benchmark, which simulates a modern decision support system for a retail product supplier. Experimental results show that high query throughput can be achieved in HBelt when distributed, refreshed snapshots are demanded.

Opportunistic networks (ONs) allow wireless devices to communicate and collaborate in the absence of dedicated networking infrastructure. Recent research work exploits mobility of nodes to create delayed paths in opportunistic networks. Execution of distributed transactions that comprise a sequence of atomic operations across multiple nodes continues to be a challenge for opportunistic networks. Implementing distributed transactions poses new challenges as participation of multiple processes, both local and remote, is required. In this paper, we propose and implement a novel transaction system called DiTON, specifically tailored to operate in opportunistic networks for delay-tolerant applications. To the best of our knowledge, our work is the first attempt to implement a transaction paradigm specifically intended for opportunistic networks. DiTON is a novel transaction scheme that allows multiple nodes to collaborate on shared sets of data while providing global coherency despite network interruptions. Through experimental results, we demonstrate that DiTON can be successfully implemented in opportunistic networks.

A distributed stock exchange system encompasses multiple network hosts that participate in the sharing and exchange of resources. In such exchanges, the mediator or stock exchange must manage and delineate all operations in a cohesive manner. Stock exchange (SE) also acts as the transaction manager to provide consistent, isolated, durable, and atomic transactions for participating entities. However, the work for the stock exchange is not so straightforward as it may sound. With multiple transactions happening per second, the global serializability and concurrency control becomes an issue resulting in multiple threats and vulnerabilities. We propose a novel stock exchange that integrates time series prediction to distributed transactions and understanding the rapid global transactions and limitations of resources at the stock exchange. We use distributed acyclic graph (DAG) based distributed ledger technology IOTA to provide security and consensus for independent users. The paper proposes a time-variant model that adjusts its predictions based on transactions, moments of observations, participating entities, and history. We show that our model outcasts other state-of-art schemes in terms of prediction accuracy. Also, the model is fair, fast, and scalable to handle millions of transactions per second.

Blockchain works according to the principles of distributed transactions and processing tiny hash-based blocks. Data located in the blockchain preserves its integrity and transparency, which enables participants to verify it. Today, people apply blockchain technology in domains that must maintain the integrity of the data. However, people can be reluctant to introduce blockchain technology due to the complexity of the technology and the resultant inefficiency. This work presents a DEVS-based experimental methodology for performance evaluation of blockchain-based services. The experimental methodology is tested by implementing a content delivery service by utilizing the Ethereum blockchain framework. As the evaluation result, we show the overall turnaround time of the service and investigate the delay of smart contract function consisting the service. In addition, the evaluation result shows the difference in performance between blockchain-based and database-based services. This work presents a methodology for evaluating blockchain service performance and shows experimental results that can be referenced by people who are planning to implement blockchain-based services.

This paper describes a remarkably simple deterministic (not probabilistic) contention-management algorithm for guaranteeing the forward progress of transactions - avoiding deadlocks, livelocks, and other anomalies. The transactions must be finite (no infinite loops), but on each restart, a transaction may access different shared-memory locations. The algorithm supports irrevocable transactions as long as the transaction satisfies a simple ordering constraint. In particular, a transaction that accesses only one shared-memory location is never aborted. The algorithm is suitable for both hardware and software transactional-memory systems. It also can be used in some contexts as a locking protocol for implementing transactions "by hand." HighlightsA remarkably simple algorithm can guarantee the forward progress of transactions.The algorithm supports irrevocable transactions.The algorithm is suitable for hardware or software transactional-memory systems.The algorithm can be used as a locking protocol.

On-line Transaction Processing (OLTP) applications often rely on shared-nothing distributed databases that can sustain rapid growth in data volume. Distributed transactions (DTs) that involve data tuples from multiple geo-distributed servers can adversely impact the performance of such databases, especially when the transactions are short-lived and these require immediate responses. The k -way min-cut graph clustering based database repartitioning algorithms can be used to reduce the number of DTs with acceptable level of load balancing. Web applications, where DT profile changes over time due to dynamically varying workload patterns, frequent database repartitioning is needed to keep up with the change. This paper addresses this emerging challenge by introducing incremental repartitioning. In each repartitioning cycle, DT profile is learnt online and k -way min-cut clustering algorithm is applied on a special sub-graph representing all DTs as well as those non-DTs that have at least one tuple in a DT. The latter ensures that the min-cut algorithm minimally reintroduces new DTs from the non-DTs while maximally transforming existing DTs into non-DTs in the new partitioning. Potential load imbalance risk is mitigated by applying the graph clustering algorithm on the finer logical partitions instead of the servers and relying on random one-to-one cluster-to-partition mapping that naturally balances out loads. Inter-server data-migration due to repartitioning is kept in check with two special mappings favouring the current partition of majority tuples in a cluster-the many-to-one version minimising data migrations alone and the one-to-one version reducing data migration without affecting load balancing. A distributed data lookup process, inspired by the roaming protocol in mobile networks, is introduced to efficiently handle data migration without affecting scalability. The effectiveness of the proposed framework is evaluated on realistic TPC-C workloads comprehensively using graph, hypergraph, and compressed hypergraph representations used in the literature. To compare the performance of any incremental repartitioning framework without any bias of the external min-cut algorithm due to graph size variations, a transaction generation model is developed that can maintain a target number of unique transactions in any arbitrary observation window, irrespective of new transaction arrival rate. The overall impact of DTs at any instance is estimated from the exponential moving average of the recurrence period of unique transactions to avoid transient fluctuations. The effectiveness and adaptability of the proposed incremental repartitioning framework for transactional workloads ?have been established with extensive simulations on both range partitioned and consistent hash partitioned databases. We propose incremental repartitioning of distributed OLTP databases for high-scalability.We model two incremental repartitioning algorithm and lookup mechanism.We develop a unique transaction generation model for simulation.We derive novel impact metrics for distributed transactions.Simulation results indicate adaptability of the methods scalable OLTP applications.

The distributed trading mechanism has gained substantial popularity in protecting the privacy of the agents and reducing the computation burden. The existing studies focus on the distributed transaction mechanism applied in the power market, but the distributed multilateral transaction in the integrated energy system has not been explored. This paper proposes a novel power-heating multilateral contract transaction mechanism considering spot market prices. A multi-leader multi-follower (MLMF) Stackelberg game model is formulated to describe the multilateral contract transactions between the integrated energy service providers (IESPs) and the load aggregators (LAs). In this model, the IESPs play the role of leaders to select discriminate prices for different LAs while the LAs play the role of followers to determine the energy purchases. The competition among IESPs is formulated as a non-cooperative Nash game, where each stakeholder seeks to maximize its own profit. Then, the existence of the Nash equilibrium is proved. Besides, a distributed algorithm is developed to derive the equilibrium of the proposed hierarchical decision model, through which the optimal strategies for each player can be obtained. Two case studies with different scales demonstrate the effectiveness of the proposed contract transaction mechanism and the distributed solution algorithm.

The space of Internet-of-things has exploded, with billions of interconnected devices ranging from mainframes to refrigerators and thermostats. These devices offer the promise of greater automation and control, and the ability for micro-level transactions that did not exist before. The advent of blockchain offers an intriguing path to managing distributed transactions in this new ecosystem. The use of blockchain in IoT applications is relatively new, especially at the lower end of the computing spectrum. Consequently, the roadmap for the future is unclear, and there are several challenges and questions that need to be addressed, such as trust, security, and efficiency. In this paper, we survey some of the promising applications that are being implemented including supply chains, smarter energy, and healthcare. We outline strategies for overcoming many of the challenges, which should lead to successful adoptions of blockchain for IoT. Finally, we sound a cautionary note on the potential cybersecurity implications in using IoT devices, including increased attack surfaces and device vulnerabilities.

At present, to deal with a large amount of variety data in the database, various NoSQL databases have been proposed and put to practical use. However, since most of them support the transaction processing only on the single data, there is the problem that the plural data cannot be updated in a lump with maintaining the ACID properties. To solve this problem, in this paper, we propose a method to process plural data as a single transaction for MongoDB, which is a kind of document oriented NoSQL database. Concretely, each data has both of the before and after update fields, and the state of the transaction is managed. Then, in the case of before the commit, the former data is queried; after the commit, the latter data is queried. By this method, we show that the plural data can be updated as a transaction with the specified isolation level.

Large scale cloud applications are difficult to program due to the need to access data in a consistent manner. To lift this burden from programmers, Deferred Update Replication (DUR) protocols provide serializable transactions with both high availability and performance in read-dominated workloads. However, the inherently optimistic nature of DUR protocols makes them prone to thrashing in conflict-intensive scenarios: existing DUR schemes, in fact, avoid any synchronization during transaction execution; thus, these schemes end up aborting any update transaction whose reads are no longer up to date by the time it attempts to commit. To tackle this problem, we introduce Bumper, a set of innovative techniques to reduce aborts of transactions in high-contention scenarios. At its core, Bumper relies on two key ideas. First, we spare update transactions from spurious aborts (i.e., unnecessary aborts of serializable transactions), by attempting to serialize the transactions in the past. For this, we use a novel distributed concurrency control scheme that we call Distributed Time-Warping (DTW). And second, we avoid aborts due to contention hot spots (that cannot be tackled by DTW) via a programming abstraction that we call Delayed Actions. These, allow for efficiently serializing, in an abort-free fashion, the execution of conflict-prone data manipulations. By means of an extensive evaluation, on a distributed system of 160 nodes, we show that Bumper can boost performance up to 3 × in conflict-intensive workloads, while imposing negligible (about 2.5%) overheads in uncontended scenarios.

With the development of cloud computing and internet; e-Commerce, e-Business and corporate world revenue are increasing with high rate. These areas not only require scalable and consistent databases but also require inter database transaction support. In this paper, we present, a scalable three-tier architecture along with a distributed middle-ware protocol to support atomic transactions across heterogeneous NoSQL databases. Our methodology does not compromise on any assumption on the accuracy of failure modalities. Hence, it is suitable for a class of heterogeneous distributed systems. To achieve such a target, our architectural model exploits an innovative methodology to achieve distributed atomic transactions. We simulate this architectural setup with different latency tests under different environments to produce reliable impact and correctness. This study proposes a three-tier architecture to facilitate atomic transactions among heterogeneous NoSQL distributed database environment as HBase.The first tier called client tier, deals with user requests. The client tier wraps transaction request and deliver it to a corresponding global transaction manager (GTM), which is assigned by a manager node.The second tier called middle tier, contains a zookeeper, manager nodes, and labour nodes. Zookeeper assigns an active manager node to the client and the active manager node assigns a labour node to process the transaction.The third tier called distributed tier manages multiple heterogeneous NoSQL databases participating with different transactions.Experimental results show that the proposed architecture is scalable and fault tolerated.

Optimistic scheduling policy based on the concept of Very Important Transaction.Progressively pessimistic scheduling policy with low runtime overheads.Adaptive scheduler that combines two scheduling policies in a synergistic way.Thorough evaluation of 4 schedulers with the STAMP and the STMBench7 benchmark. Transaction schedulers reduce the number of transaction reexecutions in applications using Software Transactional Memory (STM) by preventing conflicting transactions to run in parallel. Unfortunately, current scheduling solutions are too conservative, rely on coarse measures to serialize transactions, and are specially inadequate for workloads with long transactions.In this paper we introduce an optimistic and adaptive transaction scheduler that takes advantage of the information already collected by the STM runtime to increase parallelism between transactions and, thus, improve transactions' throughput. Our new ProVIT scheduler implements a low-overhead scheduling policy for short transactions that reduces concurrency as contention increases and a fine-grained scheduling policy for long transactions based on the novel concept of Very Important Transaction.Experimental results conducted with the STMBench7 benchmark and the STAMP benchmark suite showed that the ProVIT scheduler has comparable performance to other current scheduling solutions for short transactions, but is up to 65% faster for long-running transactions.

This paper examines information leakage in distributed ledgers. We show how the lack of time priority in the period between the publication of a transaction and its validation by miners or designated participants can expose a transaction’s “footprint” to the market, resulting in potential front-running and manipulation. We propose a cryptology-based approach for solving information leakage problems in distributed ledgers that relies on using a “hash” (or mathematical identifier) to secure time-priority followed by a second communication revealing more features of the underlying market transaction. Solving the information leakage problem greatly expands the potential applications of private distributed ledger technology.

Today, distributed business systems are used widely, and the consistency of their databases are maintained by the distributed transactions. On the other hand, a great deal of data is often updated in a lump-sum in the business systems. And, since the non-stop service has become general, it is necessary to perform this lump-sum update concurrently with the online transactions that service to users. So, some methods are utilized to avoid the influences on the online transactions, like the mini-batch that splits a lump-sum update into small transactions and executes them one after another. However, in the distributed systems, since it has to be executed by the distributed transactions, there is a problem on the efficiency to update a great deal of data by this method. For this problem, we propose to apply an update method to the distributed systems, which utilizes the records of data about the time to avoid conflicts between the lump-sum update and the online transactions. Moreover, through experiments using a prototype, we confirmed that it can update data more efficiently than the chain of small transactions even in the distributed systems.

This work discusses the parallelization of an irregular scientific code, the transposition of a sparse matrix, comparing two multithreaded strategies on a multicore platform: a programmer-optimized parallelization and a semi-automatic parallelization using transactional memory (TM) support. Sparse matrix transposition features an irregular memory access pattern that de- pends on the input matrix, and thereby its dependencies cannot be known before its execution. This situation demands from the parallel programmer an important effort to develop an optimized parallel version of the code. The aim of this paper is to show how TM may help to simplify greatly the work of the programmer in parallelizing the code while obtaining a competitive parallel version in terms of performance. To this end, a TM solution intended to exploit concurrency from sequential programs has been developed by adding a fully distributed transaction commit manager to a well-known STM system. This manager is in charge of ordering transaction commits when required in order to preserve data dependencies.

International audience; We present an authentication and key agreement protocol to secure Voice over IP call establishment between interconnection proxies of different domains. The protocol operates on a transaction basis. Each transaction is defined as the set of operations and data required to send an Authenticated Message from a sender to a responder. A transaction allows a sender to either transmit a cryptographically protected stand-alone message; or a key-agreement message required to establish a secure session. The protocol handles transaction synchronisation loss and guarantees the use of a single transaction window in the general (inter-domain) context with multiple originating servers.

The aim of a Software Transactional Memory (STM) is to discharge the programmers from the management of synchronization in multiprocess programs that access concurrent objects. To that end, an STM system provides the programmer with the concept of a transaction. The job of the programmer is to design each process the application is made up of as a sequence of transactions. A transaction is a piece of code that accesses concurrent objects, but contains no explicit synchronization statement. It is the job of the underlying STM system to provide the illusion that each transaction appears as being executed atomically. Of course, for efficiency, an STM system has to allow transactions to execute concurrently. Consequently, due to the underlying STM concurrency management, a transaction commits or aborts.This paper first presents a new STM consistency condition, called virtual world consistency. This condition states that no transaction reads object values from an inconsistent global state. It is similar to opacity for the committed transactions but weaker for the aborted transactions. More precisely, it states that (1) the committed transactions can be totally ordered, and (2) the values read by each aborted transaction are consistent with respect to its causal past. Hence, virtual world consistency is weaker than opacity while keeping its spirit. Then, assuming the objects shared by the processes are atomic read/write objects, the paper presents an STM protocol that ensures virtual world consistency (while guaranteeing the invisibility of the read operations). From an operational point of view, this protocol is based on a vector-clock mechanism. Finally, the paper considers the case where the shared objects are regular read/write objects. It also shows how the protocol can easily be weakened while still providing an STM system that satisfies causal consistency, a condition strictly weaker than virtual world consistency.

NT 2012 and MobiWIS 2012, This work has been performed under the research project TIN2010-20057-C03-01, funded by the Spanish Ministry of Science and Technology. This work also has been funded by the research grant BES-2008-004355. It has also been carried out in collaboration with the Oxford Brookes University, UK.

The many sensors embedded in phones nowadays provide advanced sensing capabilities that make it possible to capture real-time information about the user and his surroundings. There are already examples of apps that use this information to provide highly useful and contextual services to the users. However, users are still reluctant to share their personal data with service providers due to their privacy implications (if misused). In this work, we provide protocols that allow users to store their sensor data on third party (untrusted) cloud servers. The data is stored in encrypted form (so protected from the cloud providers) with access only to service providers explicitly pre-approved by the users. The protocols simultaneously also ensure that the data accessed by service providers is in fact ‘current’ and consistent. This is achieved by integrating transactional and cryptographic primitives, such as atomic uploads, optimistic concurrency control, proxy re-encryption and homomorphic encryption, among others. Finally, experimental results are given to illustrate the practical feasibility and scalability of the proposed protocols.

In this paper, we present an efficient model for real-time transaction management in a cellular environment with random frequent handoffs and disconnections. In this environment, the Mobile Support Subsystems (MSS) contain special Agents with caching techniques to contain the frequently accessed data from the Fixed Hosts (FH), which can be concurrently or exclusively accessed by transactions being executed in Mobile Hosts (MH) under the radio range of a particular MSS. Each Agent consists of a Cache Coordinator for communication with the Fixed Hosts and the Mobile Hosts and for disconnection and handoff management. The Fixed Hosts consist of a wired network with two types of server-Data Servers and Transaction Servers. The Transaction Servers contain a Transaction Manager for concurrency control and real-time transaction management. Using this schema, the transactions can continue in the Mobile Hosts regardless of random handoffs and frequent short disconnections enhancing real-time transactions and minimizing rollbacks.

Transaction processing can guarantee the reliability of business applications. Locking resources is widely used in distributed transaction management (e.g., two phase commit, 2PC) to keep the system consistent. The locking mechanism, however, potentially results in various deadlocks. In service oriented architecture (SOA), the deadlock problem becomes even worse because multiple (sub)transactions try to lock shared resources in the unexpectable way due to the more randomicity of transaction requests, which has not been solved by existing research results. In this paper, we investigate how to prevent local deadlocks, caused by the resource competition among multiple sub-transactions of a global transaction, and global deadlocks from the competition among different global transactions. We propose a replication based approach to avoid the local deadlocks, and a timestamp based approach to significantly mitigate the global deadlocks. A general algorithm is designed for both local and global deadlock prevention. The experimental results demonstrate the effectiveness and efficiency of our deadlock prevention approach. Further, it is also proved that our approach provides higher system performance than traditional resource allocation schemes.

This paper investigates a transaction processing mechanism in a peer to peer database network. A peer to peer database network is a collection of autonomous data sources, called peers, where each peer augments a conventional database management system with an inter-operability layer (i.e. mappings) for sharing data. In this network, each peer independently manages its database and executes queries as well as updates over the related data in other peers. In this paper, we consider a peer to peer database network where mappings between peers are established through data-level mappings for sharing data and resolving data heterogeneity. With regards to transaction processing in a peer to peer database network, we mainly focus on how to maintain a consistent execution view of concurrent transactions in peers without a global transaction coordinator. Since there is no global transaction coordinator and each peer executes concurrent transactions independently, different peers may produce different execution views for the same set of transactions. For this purpose, we investigate potential problems that arise when maintaining a consistent execution of concurrent transactions. In order to guarantee consistent execution, we introduce a correctness criteria and propose two approaches, namely Merged Transactions and OTM based propagation. We assume that one single peer initiates the concurrent transactions. We also present a solution for ensuring the consistent execution view of concurrent transactions considering the failures of transactions.

In this paper we introduce a new model for supporting transactions in a web environment. The model offers business benefits by increasing throughput of transactions. This is achieved by supporting the relaxation of various combinations of ACID properties according to the user's requirements and the business needs. The model aims at improving transaction throughput at the same time as maintaining a reliable user service. A distinctive feature is that any or all of the ACID properties may be maintained or relaxed depending on user need. We tested the proposed model through various experiments and our results show that the proposed model is capable of increasing transaction throughput while supporting user and business needs.

Most GIS (Geographic Information System) applications tend to have heterogeneous and autonomous geospatial information resources, and the availability of these local resources is unpredictable and dynamic under a distributed computing environment. In order to make use of these local resources together to solve larger geospatial information processing problems that are related to an overall situation, in this paper, with the support of peer-to-peer computing technologies, we propose a geospatial data distributed computing mechanism that involves loosely coupled geospatial resource directories and a term named as Equivalent Distributed Program of global geospatial queries to solve geospatial distributed computing problems under heterogeneous GIS environments. First, a geospatial query process schema for distributed computing as well as a method for equivalent transformation from a global geospatial query to distributed local queries at SQL (Structured Query Language) level to solve the coordinating problem among heterogeneous resources are presented. Second, peer-to-peer technologies are used to maintain a loosely coupled network environment that consists of autonomous geospatial information resources, thus to achieve decentralized and consistent synchronization among global geospatial resource directories, and to carry out distributed transaction management of local queries. Finally, based on the developed prototype system, example applications of simple and complex geospatial data distributed queries are presented to illustrate the procedure of global geospatial information processing.

Market-based principles can be used to manage the risk of distributed peer-to-peer transactions. This is demonstrated by Ptrim, a system that builds a transaction default market on top of a main transaction processing system, within which peers offer to underwrite the transaction risk for a slight increase in the transaction cost. The insurance cost, determined through market-based mechanisms, is a way of identifying untrustworthy peers and perilous transactions. The risk of the transactions is contained, and at the same time members of the peer-to-peer network capitalise on their market knowledge by profiting as transaction insurers. We evaluated the approach through trials with the deployed Ptrim prototype, as well as composite experiments involving real online transaction data and real subjects participating in the transaction default market. We examine the efficacy of our approach both from a theoretical and an experimental perspective. Our findings suggest that the Ptrim market layer functions in an efficient manner, and is able to support the transaction processing system through the insurance offers it produces, thus acting as an effective means of reducing the risk of peer-to-peer transactions. In our conclusions we discuss how a system like Ptrim assimilates properties of real world markets, and its potential exposure and possible countermeasures to events such as those witnessed in the recent global financial turmoil.

This paper presents DMVOCC-2PLV (Distributed Multiversion Optimistic Concurrency Control with Two-Phase Local Validation) protocol for processing mobile distributed real-time transactions in mobile broadcast environments. In DMVOCC-2PLV protocol, transaction validation is performed at two levels: local validation and global validation. Local validation of transactions is performed in two phases: local pre-validation and local final validation. At the MHs (Mobile Hosts), all mobile transactions perform local pre-validation of transactions by using a backward validation mechanism. The local pre-validation process is carried out against committed transactions at the server in the last broadcast cycle. Such an early data conflict detection feature can save processing and communication resources. Transactions that survive in local pre-validation must be submitted to the server for local final validation. In global validation distributed update transactions have to check to ensure distributed serializability in all participants. The protocol can eliminate conflicts between mobile read-only and mobile update transactions, and resolve data conflicts flexibly using multiversion dynamic adjustment of serialization order to avoid unnecessary restarts of transactions. Mobile read-only transactions can be committed with no-blocking, and respond time of mobile read-only transactions is greatly reduced. The tolerance of mobile transactions of disconnections from the broadcast channel is increased. The results of simulation experiment show that the new protocol proposed offers better performance in terms of miss rate, restart rate, commit rate and throughput.

Composite Web services provide promising prospects for conducting cross-organizational Web service transactions. Such transactions generally require longer processing time and manipulate financially critical data. To efficiently manage these Web services transactions, isolation is commonly relaxed, but inconsistency will be caused by concurrently executing isolation-relaxing transactions. This article proposes an extension to the WS-Business Activity Protocol, which ensures the consistent executions of isolation-relaxing Web service transactions, and which is based on transaction dependency graphs distributed over multiple nodes. Furthermore, this article presents several algorithms implementing the protocol, and introduces the implement of a prototype system.

Parallel accesses to the data of a field device by more than one user, e.g. a programmable controller and a commissioning tool, may cause inconsistencies, which may result in a functional misbehavior of the overall (automation) system. The solution to this problem must start within the field device. It is proposed here to integrate a transaction manager directly into the field device. The transaction manager controls all internal and external accesses to the field device data and ensures the data consistency within the device. These transaction safe field devices are the necessary base for an (automation) system wide data consistency.

For efficiently managing Web Services (WS) transactions which are executed across multiple loosely-coupled autonomous organizations, isolation is commonly relaxed. A Web service operation of a transaction releases locks on its resources once its jobs are completed without waiting for the completions of other operations. However, those early unlocked resources can be seen by other transactions, which can spoil data integrity and cause incorrect outcomes. Existing WS transaction standards do not consider this problem. In this paper, we propose a mechanism to ensure the consistent executions of isolation-relaxing WS transactions. The mechanism effectively detects inconsistent states of transactions with a notion of an end-state dependency and recovers them to consistent states. We also propose a new Web services Transaction Dependency management Protocol (WTDP). WTDP helps organizations manage the WS transactions easily without data inconsistency. WTDP is designed to be compliant with a representative WS transaction standard, the Web Services Transactions specifications, for easy integration into existing WS transaction systems. We prototyped a WTDP-based WS transaction management system to validate our protocol.

Active database management systems (ADBMS) are used in different application domains and especially for cooperative and long duration activity management. This paper deals with performance analysis of long-lived cooperative transaction processing in an ADBMS. We first briefly discuss NP-QuadLock - a concurrency control scheme for cooperative and long durational transactions in ADBMS. A restricted version of NP-QuadLock named 2L-QuadLock has been used for simulation. We have modeled such an ADBMS supporting 2L-QuadLock scheme by a queuing model. The failure of the transactions running in such systems has been modeled by a failure recovery model. We have simulated this model for a transaction processing system serving long-lived and cooperative transactions. We also discuss some important emerging application scenarios, where the proposed cooperative complex transaction mechanism can be used (e.g. 3G-service environment, ubiquitous computing environment, feature composition in intelligent network environment, multi-site and multi-domain web-services). An important objective of our work is to analyze quantitatively (a) the performance penalty on the system due to the partial abort, the number of locks held by a transaction, the number of states of the transactions, and (b) the gain in the performance of the system with the cooperation semantics proposed in 2L-QuadLock concurrency control mechanism. We have analyzed the effect of various parameters such as partial abort rate, cooperation rate, number of locks held by a transaction, multiprogramming level, on the performance metrics such as average service time, average saga length and the degree of compensation. Later, we characterize the application scenarios based on some important simulation parameters, and discuss the application performance needs for each of the application scenarios. The required performance parameters that need to be used for these application scenarios and the corresponding performance results using 2L-QuadLock are also discussed.

Version control systems play a very important role in maintaining the revision history of software and facilitating software evolution. As the software development process is gradually taking the form of a collaborative effort among several teams hosted over widely dispersed sites, centralized version control systems are gradually giving way to multi-sited version control systems. Ensuring the integrity and consistency of versioned objects in a environment that supports concurrent access, is a difficult problem. The paradigm of transactions has been successfully used in database systems to ensure integrity of objects. In this paper, we look into the transaction management requirements of version control systems and propose a new transaction model of revision control.

In this paper, we propose the use of Versioned Boxes, which keep a history of values, as the basis for language-level memory transactions. Unlike previous work on software transactional memory, in our proposal read-only transactions never conflict with any other concurrent transaction. This may improve significantly the concurrency on applications which have longer transactions and a high read/write ratio.Furthermore, we discuss how we can reduce transaction conflicts by delaying computations and re-executing only parts of a transaction in case of a conflict. We propose two language-level abstractions to support these strategies: the per-transaction boxes and the restartable transactions.Finally, we lay out the basis for a more generic model, which better supports fine-grained restartable transactions. The goal of this new model is to generalize the previous two abstractions to reduce conflicts.

In this paper, we propose and formalize a rule based knowledge transaction model for mobile environments. Our model integrates the features of both mobile environments and intelligent agents. We use logic programming as a mathematic tool and formal specification method to study knowledge transaction in mobile environments. Our knowledge transaction model has the following major advantages: (1) It can be used for knowledge transaction representation, formalization and knowledge reasoning in mobile environments. (2) It is knowledge oriented and has a declarative semantics inherited from logic programming. (3) It is a formalization that can be applied to general problem domains. We show that our model can be used for knowledge transaction representation, formalization and knowledge reasoning in mobile environments.

Although there has been a lot of discussion of "transactions" in mobile e-commerce (m-commerce), very little attention has been paid for distributed transactional properties of the computations facilitating m-commerce. In this paper, we first present a requirement analysis and then present a wireless terminal-based transaction manager (TM) architecture. This architecture is based on the assumption that there is an application that supports certain business transaction(s) and that it uses the TM to store transactional state information and retrieve it after a communication link, application, or terminal crash. We present the design of such a TM, including the application interface, modules and log structure. A pilot implementation of this TM for the location-based application is also discussed. We further discuss other alternatives to design such a TM that together can be called "ontological transaction monitor". This acts as an intelligent component between the application and the servers accessed during m-commerce transactions and controls the perceivable communication behavior of the terminal towards the servers, maintains the state information and takes care of tight coupling of transactional properties of the computations as well as of security and privacy.

Data-shipping systems that allow inter-transaction caching raise the need of a transactional cache consistency maintenance (CCM) protocol because each client is able to cache a portion of the database dynamically. Deferred locking (DL) is a new CCM scheme that is capable of reducing the communication overhead required for cache consistency checking. Due to its low communication overhead, DL could show a superior performance, but it tends to exhibit a high ratio of transaction abort. To cope with this drawback, we develop a new notion of shadow transaction, which is a backup-purpose one that is kept ready to replace an aborted transaction. This notion and the locking mechanism of DL have been incorporated into deferred locking with shadow transaction. Using a distributed database simulation model, we evaluate the performance of the proposed schemes under a wide range of workloads.

It is very difficult to achieve guaranteed real time database services when putting a database into a real-time environment because various components can compete for system resources. Previous research in real-time databases has focused primarily on evolution of transaction processing algorithms, priority assignment strategies and concurrency control techniques. But for the most part the research efforts are based only on simulation studies with many parameters defined. Our objective is to design and implement an experimental real-time database system suitable for study of real time transaction processing. The experimental system is implemented as an integrated set of the most important functional parts upon the real-time operating system VxWorks. It serves as a support platform for performance evaluation of known and new algorithms of the particular processing components to understand their effect on system performance and to identify the most influencing factors.

A transaction defines a locus of computation that satisfies important concurrency and failure properties. These so-called ACID properties provide strong serialization guarantees that allow us to reason about concurrent and distributed programs in terms of higher-level units of computation (e.g., transactions) rather than lower-level data structures (e.g., mutual-exclusion locks). This paper presents a framework for specifying the semantics of a transactional facility integrated within a host programming language. The TFJ calculus, an object calculus derived from Featherweight Java, supports nested and multi-threaded transactions. We give a semantics to TFJ that is parametrized by the definition of the transactional mechanism that permits the study of different transaction models. We give two instantiations: one that defines transactions in terms of a versioning-based optimistic concurrency model, and the other which specifies transactions in terms of a pessimistic two-phase locking protocol, and present soundness and serializability properties for our semantics.

For enterprise systems to interoperate, as in an e-business transaction, some kind of transaction management is crucial. Current standard transaction protocols do not meet important requirements for e-business transactions. In this paper, a new transaction model is introduced that meets those requirements and for which well-defined business semantics can be given.

Service-oriented computing is emerging as a distributed computing model where autonomous services interact with each other using standard Internet technology. In addition to the application-specific functions that services provide (different) services may also support (different) sets of protocols and formats addressing extra-functional concerns such as transaction processing and reliable messaging. This raises the need for services to complement their functional service descriptions with descriptions of extra-functional capabilities, requirements, and/or preferences, which must be matched and enforced for service interactions. In this paper, we address the problem of transactional coordination in service-oriented computing. We argue for the use of declarative policy assertions to advertise and match support for different transaction styles (direct transaction processing, queued transaction processing, and compensation-based transaction processing), and introduce the concept of and system support for transaction coupling modes as the policy-based contracts guiding transactional business process execution. We focus on concrete, protocol-specific policies that apply to relevant Web services specifications. Using transaction policies and our middleware system, we are able to support a reliable SOC environment.

The future Grid will be an autonomic environment that can not only assist users to share large-scale resources and accomplish collaborative tasks but also self-manage to reduce the users' interventions as much as possible. In such an autonomic Grid environment, the real-time transaction processing is a key and challenging technology to protect systems from various failures. This paper presents an autonomic real-time transaction service (ARTTS) that can (1) dynamically discover Grid services as participants to execute specified sub-transactions, (2) coordinate these participants to achieve the real-time and transactional requirements, and (3) assign priorities to schedule concurrent transactions. Petri nets are used to model and validate the coordination algorithms of real-time Grid transactions and experiment result demonstrates the feasibility of the ARTTS and the performance of the algorithms in different workloads. By handling the potential failures and exceptions autonomically, the ARTTS can facilitate the implementation of real-time Grid transactions and simplify the system management work, which frees users from the complex interference in the autonomic Grid environment.

Global computing (WAN programming, Internet programming) distinguishes itself from local computing (LAN computing) by the fact that it exposes some aspects of the network to the application, rather than seeking to hide them with network transparency, as in LAN programming. Global computing languages seek to provide useful abstractions for building applications in such environments. The lqp(·)-calculus is a family of programming languages that use the abstraction of logs to specify application-specific protocols for distributed agreement and fault tolerance in global applications. Reflecting the motivation for global computing, the abstraction of logs isolates the communication requirements of such protocols. Two specific instances of the lqp(·)-calculus are provided, the lqp(dc)-calculus and the lqp(dcu)-calculus. These are intended as kernel programming languages for fault-tolerant distributed programming. The calculi incorporate various abstractions for fault tolerance, from which several forms of distributed transactions and optimistic computation may be built. As an example application, a calculus of atomic failures is presented, the atf-calculus, and its encoding in the lqp(dc)-calculus used to verify a correctness property.

Middleware components are becoming increasingly important as applications share computational resources in distributed environments, such as high-end clusters with ever larger number of processors, computational grids and increasingly large server farms. One of the main challenges in such environments is to achieve scalability of synchronization. In general, concurrency services arbitrate resource requests in distributed systems. But concurrency protocols currently lack scalability. Adding such guarantees enables resource sharing and computing with distributed objects in systems with a large number of nodes. The objective of our work is to enhance middleware services to provide scalability of synchronization and to support state replication in distributed systems. We have designed and implemented a middleware protocol in support of these objectives. Its essence is a peer-to-peer protocol for multi-mode hierarchical locking, which is applicable to transaction-style processing and distributed agreement. We demonstrate high scalability combined with low response times in high-performance cluster environments. Our technical contribution is a novel, fully decentralized, hierarchical locking protocol to enhance concurrency in distributed resource allocation following the specification of general concurrency services for large-scale data and object repositories. Our experiments on an IBM SP show that the number oF messages approaches an asymptote at 15 node from which point on the message overhead is in the order of 3-9 messages per request, depending on system parameters. At the same time, response times increase linearly with a proportional increase in requests and, consequently, higher concurrency levels. Specifically, in the range of up to 80 nodes, response times under 10 ms are observed for critical sections that are one 25th the size of noncritical code. The high degree of scalability and responsiveness of our protocol is due in large to a high level of concurrency upon resolving requests combined with dynamic path compression for request propagation paths. Our approach is not only applicable to CORBA, its principles are shown to provide benefits to general distributed concurrency services and transaction models. Besides its technical strengths, our approach is intriguing due to its simplicity and its wide applicability, ranging From large-scale clusters to server-style computing.

This paper introduces the Mobile Nested Transactions (MNT) model for transaction processing coordination in groups of mobile devices. The model extends traditional approaches—centralized and distributed—for distributed transaction processing over mobile devices. Under the Nested Transactions approach, sub-transactions—logical work units—processing control is highly flexible and fault-tolerant. Hence, transaction processing with mobile groups lacking of access to a wired network or the Internet becomes possible. A MNT additional advantage is that sub-transactions could be distributed among mobile devices. This is, whenever some sub-transactions are successfully committed, they cannot be affected by failed or pending sub-transactions.

In broadcast environments, the limited bandwidth of the upstream communication channel from the mobile clients to the server bars the application of conventional concurrency control protocols. In this paper, we propose a new variant of the optimistic concurrency control (OCC) protocol that is suitable for broadcast environments. At the server, forward validation of a transaction is done against currently running transactions, including mobile transactions and server transactions. At the mobile clients, partial backward validation of a transaction is done against committed transactions at the beginning of every broadcast cycle. Upon completion of execution, read-only mobile transactions can be validated and committed locally and update mobile transactions are sent to the server for final validation. These update transactions have a better chance of commitment because they have gone through the partial backward validation. In addition to the nice properties of conventional OCC protocols, this protocol provides autonomy between the mobile clients and the server with minimum upstream communication, which is a desirable feature to the scalability of applications running in broadcast environments. This protocol is able to process both update transactions and read-only transactions at the mobile clients at low space and processing overheads.

In a distributed real-time database system, the only way to ensure transaction atomicity is to investigate and develop a real-time atomic commit protocol. This paper presents the model of distributed real-time transaction and analyses all kinds of dependencies because of data conflicts access. Based on this model, we propose an optimistic real-time commit protocol, double space commit (2SC), which is specifically designed for the high-performance distributed real-time transaction. 2SC allows a non-healthy transaction to lend its held data to the transactions in its commit dependency set. When the prepared transaction aborts, only the transactions in its abort dependency set are aborted while the transactions in its commit dependency set will execute as normal. The two properties of 2SC can reduce the data inaccessibility and the priority inversion that is inherent in distributed real-time commit processing. Extensive simulation experiments have been performed to compare the performance of the 2SC with that of other protocols such as the base protocol, the permits reading of modified prepared-data for timeliness [IEEE Transactions on Parallel and Distributed Systems 11 (2) (2000) 160-181] and the deadline-driven conflict resolution [The Computer Journal 42 (8) (1999) 674-692]. The simulation results show that 2SC has the best performance. Furthermore, it is easy to incorporate in current concurrency control protocols.