Improves Transaction Throughput Research Articles

An Efficient and Secure Blockchain Consensus Protocol for Internet of Vehicles

Conventional blockchain consensus protocols tailored for the Internet of Vehicles (IoV) usually face low transaction throughput, high latency, and elevated communication overhead issues. To address these issues, in this paper, we propose ESBCP, an efficient and secure blockchain consensus protocol for the IoV environment. Firstly, considering the significant performance differences among nodes in the IoV, we designed a blockchain consensus model for the IoV. Roadside units execute a trust evaluation mechanism to select high-quality vehicle nodes for the consensus process, thereby reducing the likelihood of malicious nodes in the consensus cluster. Secondly, we designed a node partition strategy to adapt to the dynamic feature of the IoV. Finally, addressing the mobility of nodes in the IoV, we introduced a dynamic unique node list. Vehicle nodes can promptly select nodes with high reliability from the list of communicable nodes to join their unique node list, while also promptly removing nodes with low reliability from their unique node list. Combining these strategies, we propose DK-PBFT, an improved Practical Byzantine Fault Tolerance consensus algorithm. The algorithm meets the efficiency and mobility requirements of vehicular networks. Through theoretical analysis, ESBCP could prevent external and internal security risks while reducing communication overhead. Experimental verification demonstrated that ESBCP effectively reduces consensus latency and improves transaction throughput. Our proposed ESBCP can be used in other application scenarios that require high consensus efficiency.

MWPoW+: A Strong Consensus Protocol for Intra-Shard Consensus in Blockchain Sharding

Blockchain sharding splits a blockchain into several shards where consensus is reached at the shard level rather than over the entire blockchain. It improves transaction throughput and reduces the computational resources required of individual nodes. But a derivation of trustworthy consensus within a shard becomes an issue as the longest chain based mechanisms used in conventional blockchains can no longer be used. Instead, a vote-based consensus mechanism must be employed. However, existing vote-based Byzantine fault tolerance consensus protocols do not offer sufficient security guarantees for sharded blockchains. First, when used to support consensus where only one block is allowed at a time (binary consensus), these protocols are susceptible to progress-hindering attacks (i.e., unable to reach a consensus). Second, when used to support a stronger type of consensus where multiple concurrent blocks are allowed (strong consensus), their tolerance of adversary nodes is low. This article proposes a new consensus protocol to address all these issues. We call the new protocol MWPoW +, as its basic framework is based on the existing Multiple Winners Proof of Work (MWPoW) protocol but includes new mechanisms to address the issues mentioned previously. MWPoW+ is a vote-based protocol for strong consensus, asynchronous in consensus derivation but synchronous in communication. We prove that it can tolerate up to f < n /2 adversary nodes in a n-node system as if using a binary consensus protocol and does not suffer from progress-hindering attacks.

LRU-C: Parallelizing Database I/Os for Flash SSDs

The conventional database buffer managers have two inherent sources of I/O serialization: read stall and mutex conflict. The serialized I/O makes storage and CPU under-utilized, limiting transaction throughput and latency. Such harm stands out on flash SSDs with asymmetric read-write speed and abundant I/O parallelism. To make database I/Os parallel and thus leverage the parallelism in flash SSDs, we propose a novel approach to database buffering, the LRU-C method. It introduces the LRU-C pointer that points to the least-recently-used-clean page in the LRU list. Upon a page miss, LRU-C selects the current LRU-clean page as a victim and adjusts the pointer to the next LRU-clean one in the LRU list. This way, LRU-C can avoid the I/O serialization of read stalls. The LRU-C pointer enables two further optimizations for higher I/O throughput: dynamic-batch-write and parallel LRU-list manipulation. The former allows the background flusher to write more dirty pages at a time, while the latter mitigates mutex-induced I/O serializations. Experiment results from running OLTP workloads using MySQL-based LRU-C prototype on flash SSDs show that it improves transaction throughput compared to the Vanilla MySQL and the state-of-the-art WAR solution by 3x and 1.52x, respectively, and also cuts the tail latency drastically. Though LRU-C might compromise the hit ratio slightly, its increased I/O throughput far offsets the reduced hit ratio.

Deciding Robustness for Lower SQL Isolation Levels

While serializability always guarantees application correctness, lower isolation levels can be chosen to improve transaction throughput at the risk of introducing certain anomalies. A set of transactions is robust against a given isolation level if every possible interleaving of the transactions under the specified isolation level is serializable. Robustness therefore always guarantees application correctness with the performance benefit of the lower isolation level. While the robustness problem has received considerable attention in the literature, only sufficient conditions have been obtained. The most notable exception is the seminal work by Fekete where he obtained a characterization for deciding robustness against SNAPSHOT ISOLATION. In this article, we address the robustness problem for the lower SQL isolation levels READ UNCOMMITTED and READ COMMITTED, which are defined in terms of the forbidden dirty write and dirty read patterns. The first main contribution of this article is that we characterize robustness against both isolation levels in terms of the absence of counter-example schedules of a specific form (split and multi-split schedules) and by the absence of cycles in interference graphs that satisfy various properties. A critical difference with Fekete’s work, is that the properties of cycles obtained in this article have to take the relative ordering of operations within transactions into account as READ UNCOMMITTED and READ COMMITTED do not satisfy the atomic visibility requirement. A particular consequence is that the latter renders the robustness problem against READ COMMITTED coNP-complete. The second main contribution of this article is the coNP-hardness proof. For READ UNCOMMITTED, we obtain LOGSPACE-completeness.

Embedded Transaction Support Inside SSD With Small-Capacity Non-Volatile Disk Cache

Flash-based Solid State Drives (SSDs) have proved to be ideal devices that support embedded transaction protocols inside SSDs. Existing embedded transaction protocols effectively improve transaction throughput, but still incur high transaction overhead and long recovery time. In this paper, we propose a new embedded transaction protocol called Non-volatile Cache Transaction (NVCTX). NVCTX reduces transaction overhead and provides fast recovery by leveraging the small-capacity NVM-based disk cache from two aspects. First, we store transactional metadata, which is of small amount but is frequently accessed, in the NVM-based disk cache rather than in the flash memory. Second, we introduce two techniques to improve the performance when the capacity of the NVM-based disk cache is very limited. We have implemented NVCTX on a real hardware board, and modified ext4 file system and NVMe driver to be compatible with the transactional interfaces provided by NVCTX. For comparison, we implement other four protocols in the firmware. Evaluations using DBMS and file system workloads show that, compared to other protocols, NVCTX improves transaction throughput by up to 136.5%, 9.4%, 131.6% and 29.9%, reduces write traffic to flash memory by up to 42.8%, 4.1%, 62.4%, 31.2%, and shortens recovery time to 1/2574, 1/2559, 1/95 and 1/2 respectively.

CHChain: Secure and parallel crowdsourcing driven by hybrid blockchain

Blockchain-based crowdsourcing solutions have been widely used in the industry to solve insider threats and free-riding/false-reporting issues. However, the existing solutions suffer from three main limitations: 1) inability to concurrently achieve task privacy protection and distributed transparent storage, 2) limited transaction throughput caused by serial transaction processing, and 3) low fault-tolerance ability of their practical byzantine-fault-tolerance (PBFT) consensus protocols. In order to overcome these limitations, this paper proposes a novel hybrid-blockchain crowdsourcing platform named CHChain. The core of CHChain is a hybrid blockchain structure, which achieves distributed and transparent storage while guaranteeing task privacy by isolating the private information of each task (e.g., task response, evaluation, and feedback) into its own private task chain, and recording other common information of tasks (e.g., task ID, reward, and deadline) into a common chain. To improve transaction throughput, we then design a parallel-transaction-processing chaincode (PTPC), a chaincode running on the hybrid blockchain structure, to process transactions in parallel, which is also responsible for evaluating the reputations of platform users. For fault-tolerance enhancement, we finally design a Reputation-based PBFT (R-PBFT) consensus protocol based on the hybrid reputation values of platform users. Extensive experiment results showed that the transaction throughput of CHChain is nearly twice as much as those of the existing solutions. Moreover, the fault tolerance of R-PBFT can be approximately 98%, which is much higher than that of the PBFT, 1/3.

Efficient Concurrent Execution of Smart Contracts in Blockchain Sharding

Throughput performance is a critical issue in blockchain technology, especially in blockchain sharding systems. Although sharding proposals can improve transaction throughput by parallel processing, the essence of each shard is still a small blockchain. Using serial execution of smart contract transactions, performance has not significantly improved, and there is still room for improvement. A smart contract concurrent execution strategy based on concurrency degree optimization is proposed for performance optimization within a single shard. This strategy is applied to each shard. First, it characterizes the conflicting contract feature information by executing a smart contract, analyzing the factors that affect the concurrent execution of the smart contracts, and clustering the contract transaction. Second, in shards with high transaction frequency, considering the execution time, conflict rate, and available resources of contract transactions, finding a serializable schedule of contract transactions by redundant computation and a Variable Shadow Speculative Concurrency Control (SCC-VS) algorithm for smart contract scheduling is proposed. Finally, experimental results show that the strategy increases the concurrency of smart contract execution by 39% on average and the transaction throughput of the whole system by 21% on average.

Reordering Transaction Execution to Boost High-Frequency Trading Applications

High-frequency trading (HFT) has always been welcomed because it benefits not only personal benefits but also the whole social welfare. While the recent advance of portfolio selection in HFT market enables to bring about more profit, it yields much contended OLTP workloads. Featuring exploiting the abundant parallelism, transaction pipeline, the state-of-the-art concurrency control (CC) mechanism, however, suffers from limited concurrency confronted with HFT workloads. Its variants that enable more parallel execution by leveraging fine-grained contention information also take little effect. To solve this problem, we for the first time observe and formulate the source of restricted concurrency as harmful ordering of transaction statements. To resolve harmful ordering, we propose PARE, a pipeline-aware reordered execution, to improve application performance by rearranging statements in order of their degrees of contention. In concrete, two mechanisms are devised to ensure the correctness of statement rearrangement and identify the degrees of contention of statements, respectively. We also study the off-line reordering problem. We prove that this problem is NP-hard and present an off-line reordering approach to approximate the optimal reordering strategy. Experiment results show that PARE can improve transaction throughput and reduce transaction latency on HFT applications by up to an order of magnitude than the state-of-the-art CC mechanism.

방송환경에서 갱신 거래 우선 낙관적 동시성 제어 기법

대부분의 방송 환경 응용 시스템들은 클라이언트측에서 발생한 주로 주식 데이터, 교통 정보와 새로운 뉴스와 같은 여러 가지 다양한 정보를 검색하는 읽기전용 즉 질의 거래들을 허락한다. 그러나, 기존의 여러 가지 동시성 제어 기법들은 이러한 특수성을 고려하지 않음으로써 방송 환경에 적용될 때 성능 감소가 일어난다. 이 논문에서는 방송환경에서 가장 적절한 OCC/UTF(Optimistic Concurrency Control with Update Transaction First)를 제안한다. OCC/UTF는 갱신 거래에 의해 무효화된 데이터를 먼저 일기 연산한 질의 거래가 비직렬 가능성으로 인한 철회 없이 갱신된 새로운 값을 다시 읽는다. 그럼으로써 직렬 순서가 유지되어 갱신 거래의 완료와 상관없이 해당 질의 거래가 무사히 완료된다. 그 결과 첫째, 서버에게 질의 거래 완료 요구를 할 필요가 없으며 무효화 보고서 내에 갱신된 최신의 값을 포함하여 클라이언트들에게 방송함으로써 최근 데이터 값을 서버에게 요구하는 기회를 줄임과 동시에 서버는 새로운 값을 재방송할 필요가 없기 때문에 비대칭적 대역폭을 효율적으로 활용한다. 둘째, 질의 거래의 완료율을 최대한 높여 처리율을 향상시킬 수 있다. Most of mobile computing systems allow mostly read-only transactions from mobile clients for retrieving various types of Information such as stock data, traffic information and news updates. Since previous concurrence control protocols, however, do not consider such a particular characteristics, the performance degradation occurs when previous schemes are applied to the broadcast environment. In this paper, we propose OCC/UTF(Optimistic Concurrence Control with Update Transaction First) that is most appropriate for broadcast environment. OCC/UTF lets a query transaction, that has already read the data item which was invalidated by update transaction, read again the same data item without the abort of the query transaction due to non-serializability. Therefore, serializable order is maintained and the query transaction is committed safely regardless of commitment of update transactions. In OCC/UTF, Clients need not require server to commit their query transactions. Because of broadcasting the validation reports including values updated recently to clients, it reduces the overhead of requesting recent values from the server and the server need not also re-broadcast the newest values. As a result, OCC/UTF makes full use of the asymmetric bandwidth. It can also improve transaction throughput by increasing the commit ratio of query transactions as much as possible.

Nonblocking two-phase commit protocol to avoid unnecessary transaction abort for distributed systems

Processing a distributed transaction takes more time than processing a local transaction, since processing of a distributed transaction requires multiple phases with respect to its commitment to keep a distributed transaction consistent. For distributed systems, since the commit cost could be high due-to volume of network messages and network delays, it is required to optimise commit protocol to improve transaction throughput. In order to improve the throughput of transaction processing, we concentrate on the nonblocking property without loss of consistency, including the number of message exchanges, recovery time. Blocking is a critical problem in transaction processing with respect to throughput, since blocked transactions interfere the progress of other transactions. Abortion of the commitable transaction makes the system degrade, and it becomes serious if there are many transactions at the failed sites due to the unnecessary restart overhead. Therefore, in the view of efficiency, it is essentially required to develop a commit protocol that has not only few message exchanges but also low ratio of transaction aborts.