Search

Summary: This article proposes EPO‐R, which is an efficient garbage collection scheme designed for multi‐version concurrency control (MVCC) protocols. MVCC generates a version for each update operation, and it can exhaust physical memory for dynamically changing environments such as IoT payments. Eager pruning of obsolete versions (EPO) is a novel garbage collection technique for long‐term transactions. We found room for improvement in EPO, which triggers reclamation invocation. EPO is triggered for each write operation, and it wastes CPU resources. The proposed method EPO‐R is triggered on a read operation to address this issue. The result of experiments with 64 CPU cores and workloads with the combination of short‐term and long‐term transactions demonstrated that EPO‐R exhibited 6.3 times higher throughput than that of EPO. The reason for this can be explained by analyzing the number of unreclaimable versions. [ABSTRACT FROM AUTHOR]

Deterministic databases are able to reduce coordination costs in a replication. This property has fostered a significant interest in the design of efficient deterministic concurrency control protocols. However, the state-of-the-art deterministic concurrency control protocol Aria has three issues. First, it is impractical to configure a suitable batch size when the read-write set is unknown. Second, Aria running in low-concurrency scenarios, e.g., a single-thread scenario, suffers from the same conflicts as running in high-concurrency scenarios. Third, the single-version schema brings write-after-write conflicts. To address these issues, we propose Gria, an efficient deterministic concurrency control protocol. Gria has the following properties. First, the batch size of Gria is auto-scaling. Second, Gria's conflict probability in low-concurrency scenarios is lower than that in high-concurrency scenarios. Third, Gria has no write-after-write conflicts by adopting a multi-version structure. To further reduce conflicts, we propose two optimizations: a reordering mechanism as well as a rechecking strategy. The evaluation result on two popular benchmarks shows that Gria outperforms Aria by 13x. [ABSTRACT FROM AUTHOR]

Abstract Privacy concerns the majority of individuals, governments, and organizations that share data over dissimilar networks of nodes. Every kind of participant requires awareness of the data journey that unfolds inside a blockchain network with its own trustworthy rules of data management and accessibility. This paper provides a methodological approach on privacy for data sharing within blockchain environments. Specific technological aspects of blockchains that relate to on‐chain privacy such as network nature, party join, smart contracts, blockchain states, transactions, and ledger flows, are analysed with respect to the involvement and impact of privacy in distributed ledgers. A high‐level architectural approach is suggested that is intended to address significant privacy concerns on data sharing among different kinds of users in the context of blockchain networks deployment and the broader Web 3.0 ecosystem building. Simultaneously, many pertinent challenges are discussed regarding network nature, configurable privacy, ownership, confidentiality, secured computation, and data monetization that appear in the field and ought to be carefully tackled for the future mass adoption of privacy‐matured distributed ledgers that interconnect delivering the future Internet.

Abstract Most blockchain users run light nodes on mobile devices. Due to limited storage and computation, light nodes cannot perform transaction validation. This shortage makes opportunities for malicious nodes to produce blocks containing invalid transactions, which results in the loss of funds for light nodes. Fraud proofs play a significant role in ensuring transaction security for light nodes. However, existing fraud proof schemes require honest collaborators and the processing of entire blocks. To address these limitations, Independent Single Transaction Verification Protocol for Light node Using Fraud Proofs without Collaborator called ISTVP is proposed that enables light nodes to independently verify transactions and generate fraud proofs without relying on collaborators or processing the entire block. To support ISTVP, SVST is introduced, an efficient block structure for single‐transaction verification. SVST not only efficiently indexes historical transaction outputs to improve verification efficiency, but also significantly reduces the storage requirements for verifying transactions to O(h+logn). Furthermore, the authors analyze the security of ISTVP and demonstrate that it satisfies both persistence and liveness, while maintaining the level of security of full node.

Abstract Purpose This research introduces a decentralized method for handling real estate transactions through the utilization of private blockchain technology. The authors pinpoint the primary challenges within the prevailing transaction procedures in India and advocate for the integration of blockchain technology as a solution. Ultimately, the study concludes that the proposed system has the potential to optimize transaction processes within Indian government offices, fostering heightened efficiency, transparency, and a reduction in corrupt practices. Methods/design/methodology The current transaction process and the centralized technology are investigated using a physical observation approach at the government office. Following that, numerous parties are questioned to identify the main pain areas in the process. The outcomes of the interviews are used to create a blockchain solution that addresses the identified pain points. Following the design, interviewees are requested to validate the suggested model. Findings Some of the primary pain areas found in the real estate transaction procedure include that it is impossible to avoid single-point failure due to the present centralized transaction process, the possibility of corruption at any point, and the lack of data available at each node. Using blockchain techniques, the suggested decentralized application enhances the way transactions are processed and ensures the quality of data availability, transparency, and the elimination of single points of failure. Practical implications and simulation process A private blockchain application is created to improve the real estate transaction procedure at the Indian government office. One complex front end is created to receive information about the seller, the buyer’s property, and the payment, and a suitable database is employed to hold the sensitive data. Data is moved to the private blockchain for final execution when the smart business logic has been applied to the necessary information. One artificial utility is created that places a heavy load on the proposed system and measures the load trashing to validate it. It generates an enormous amount of sample data to verify the suggested system. Originality/value According to recent research, blockchain technology has the potential to get better efficiency, transparency, security, data accessibility, and thus trust in the transaction process. As a result, the suggested application is beneficial to the future of the Indian real estate transaction process.

Purpose: This research introduces a decentralized method for handling real estate transactions through the utilization of private blockchain technology. The authors pinpoint the primary challenges within the prevailing transaction procedures in India and advocate for the integration of blockchain technology as a solution. Ultimately, the study concludes that the proposed system has the potential to optimize transaction processes within Indian government offices, fostering heightened efficiency, transparency, and a reduction in corrupt practices. Methods/design/methodology: The current transaction process and the centralized technology are investigated using a physical observation approach at the government office. Following that, numerous parties are questioned to identify the main pain areas in the process. The outcomes of the interviews are used to create a blockchain solution that addresses the identified pain points. Following the design, interviewees are requested to validate the suggested model. Findings: Some of the primary pain areas found in the real estate transaction procedure include that it is impossible to avoid single-point failure due to the present centralized transaction process, the possibility of corruption at any point, and the lack of data available at each node. Using blockchain techniques, the suggested decentralized application enhances the way transactions are processed and ensures the quality of data availability, transparency, and the elimination of single points of failure. Practical implications and simulation process: A private blockchain application is created to improve the real estate transaction procedure at the Indian government office. One complex front end is created to receive information about the seller, the buyer's property, and the payment, and a suitable database is employed to hold the sensitive data. Data is moved to the private blockchain for final execution when the smart business logic has been applied to the necessary information. One artificial utility is created that places a heavy load on the proposed system and measures the load trashing to validate it. It generates an enormous amount of sample data to verify the suggested system. Originality/value: According to recent research, blockchain technology has the potential to get better efficiency, transparency, security, data accessibility, and thus trust in the transaction process. As a result, the suggested application is beneficial to the future of the Indian real estate transaction process. [ABSTRACT FROM AUTHOR]

In this paper, we present a novel Byzantine fault-tolerant consensus protocol for sharded blockchain networks that does not rely on expensive leader-driven communication. The proposed protocol selects a single block proposer at a time and uses threshold signatures as a voting mechanism to confirm the validity of the proposed block. By using a gossip-like communication scheme, each node can collect and recover the group signature within O(logN) steps. With only one block proposer per consensus round, there is no possibility of conflicting blocks and resultant forks. Therefore, our consensus protocol requires only one round of one-way communication to achieve finality for each block. Our protocol guarantees safety and liveness while tolerating up tof faulty participants among 2f + 1 nodes. Our performance study shows that the proposed protocol enables hundreds of nodes to participate in the agreement process, and can finalize large blocks in approximately 10 seconds.

To sidestep reasoning about the complex effects of concurrent execution, many system designers have conveniently embraced strict serializability on the strength of its claims, support from commercial and open-source database communities and ubiquitous levels of industry adoption. Crucially, distributed components are built on this model; multiple schedulers are composed in an event-driven architecture to form larger, ostensibly correct systems. This paper examines the oft-misconstrued position of strict serializability as a composable correctness criterion in the design of such systems. An anomaly is presented wherein a strict serializable scheduler in one system produces a history that cannot be serially applied to even a weak prefix-consistent replica in logical timestamp order. Several solutions are presented under varying isolation properties, including novel isolation properties contributed by this paper. It is further shown that every nondeterministic scheduler is anomaly-prone, every nonconcurrent scheduler is anomaly-free, and at least one deterministic concurrent scheduler is anomaly-free.

The Arjuna transaction processing system began life in the mid‐1980s as an academic research project to examine the use of object‐oriented techniques in the development of fault‐tolerant distributed systems. Thirty‐five years later, and available in open source form, it forms an integral part of various middleware products from Red Hat where it is used to provide ACID as well as non‐ACID transaction services. This journey from an academic to a commercial environment has been neither easy nor smooth but it has been interesting from many different perspectives. This article gives an overview of this journey, discusses the features of Arjuna that enables it to support a wide variety of transaction services and concludes by presenting lessons learned. [ABSTRACT FROM AUTHOR]

With the advent of the Internet and Internet-connected devices, modern business applications can experience rapid increases as well as variability in transactional workloads. Database replication has been employed to scale performance and improve availability of relational databases but past approaches have suffered from various issues including limited scalability, performance versus consistency tradeoffs, and requirements for database or application modifications. This paper presents Hihooi, a replication-based middleware system that is able to achieve workload scalability, strong consistency guarantees, and elasticity for existing transactional databases at a low cost. A novel replication algorithm enables Hihooi to propagate database modifications asynchronously to all replicas at high speeds, while ensuring that all replicas are consistent. At the same time, a fine-grained routing algorithm is used to load balance incoming transactions to available replicas in a consistent way. Our thorough experimental evaluation with several well-established benchmarks shows how Hihooi is able to achieve almost linear workload scalability for transactional databases. [ABSTRACT FROM AUTHOR]

The concurrency control algorithm is a key approach for a database system to guarantee the correctness and efficiency of the transaction execution. Thus, substantial effort has been devoted to proposing new concurrency control algorithms in both the database industry and academia. In this paper, we take the lead in summarizing the fundamental ideas of concurrency control algorithms as "ordering-and-verifying". We then redescribe and sort out the existing concurrency control algorithms following the ordering-and-verifying paradigm. On the basis of extensive comparative experiments on an open-source main-memory distributed transaction testbed called 3TS,we systematically investigate the advantages and disadvantages of the mainstream concurrency control algorithms and finally summarize the preferable application scenario for each algorithm to provide valuable references for follow-up research on concurrency control algorithms used in main-memory databases. [ABSTRACT FROM AUTHOR]

This paper discusses the load-balanced task allocation problem in the grid transaction processing system to maximize reliability. Finding the solution of optimal load-balanced task allocation is known to be an NP-hard. This paper presents a load-balanced task allocation based cuckoo search-ant colony optimization (LBTA_CSACO) method for this problem. The LBTA_CSACO is based on the cooperative behavior of cuckoo search and ant colony optimization to nd a collection of task allocation solutions. This paper also models the reliability of the system with the help of the availability of the system. The motive of this work is to maximize the reliability of the system. After the simulation, six existing algorithms are taken for the comparison of the results; Honey Bee Optimization (HBO), Ant Colony Optimization (ACO), Hierarchical Load Balanced Algorithm (HLBA), Dynamic and Decentralized Load Balancing (DLB), and Randomized respectively. [ABSTRACT FROM AUTHOR]

Benchmarks play a crucial role in database performance evaluation, and have been effectively promoting the development of database management systems. With critical transaction processing requirements of new applications, we see an explosion of innovative database technologies for dealing with highly intensive transaction workloads (OLTP) with the obvious characteristics of sharp dynamics, terrificskewness, high contention, or high concurrency (abbr. DSC2), which can not be well described or evaluated by current standard benchmarks. In this paper, based on the representative SecKill applications, we define a pacakge of workloads simulating intensive transactional processing requirements. And we create a general and flexible benchmark framework PeakBench for evaluating intensive OLTP workloads on databases. We are the first work to have full control on simulating DSC2, especially for the fine granularity control for contention generation. With a comprehensive set of experiments conducted on popular open sourced DBMSs compared with the other representative OLTP benchmarks, we completely demonstrate the usefulness of PeakBench. [ABSTRACT FROM AUTHOR]

Logging and replication are commonly used recovery approaches in database systems. To guarantee that the database state is not corrupted due to system crash, database systems rely on a centralized logging method to persist log entries into a stable storage device; to prevent data loss due to device failure, a primary server in the database system periodically replicates its state to backup servers by copying log entries over networks. As the transaction execution in a modern database system is highly parallelized, the centralized logging with a single I/O channel tends to inhibit the scalability of the system. Meanwhile, log entries generated at high speed make a network with limited bandwidth a potential bottleneck for replication. In this paper, we propose an in-memory transaction engine named Plover with parallel logging and speedy replication for primary-backup replication systems. The parallel logging enables concurrent execution of logging by utilizing multiple log buffers associated with multiple stable storages. All log entries in the log buffers maintain a global sequence number (GSN), which ensures a partial order among transactions. The kernel of the speedy replication is an adaptive shipping method, which allows to transfer data increments instead of log entries to backups under heavy workloads. Experimental results using the YCSB and TPC-C benchmarks show that Plover scales well with the increasing number of worker threads and stable storage devices. And our adaptive shipping requires only one fifth network bandwidth of the conventional log shipping. [ABSTRACT FROM AUTHOR]

In cloud–fog environments, the opportunity to avoid using the upstream communication channel from the clients to the cloud server all the time is possible by fluctuating the conventional concurrency control protocols. Through the present paper, the researcher aimed to introduce a new variant of the optimistic concurrency control protocol. Through the deployment of augmented partial validation protocol, IoT transactions that are read-only can be processed at the fog node locally. For final validation, update transactions are the only ones sent to the cloud. Moreover, the update transactions go through partial validation at the fog node which makes them more opportunist to commit at the cloud. This protocol reduces communication and computation at the cloud as much as possible while supporting scalability of the transactional services needed by the applications running in such environments. Based on numerical studies, the researcher assessed the partial validation procedure under three concurrency protocols. The study's results indicate that employing the proposed mechanism shall generate benefits for IoT users. These benefits are obtained from transactional services. We evaluated the effect of deployment the partial validation at the fog node for the three concurrency protocols, namely AOCCRBSC, AOCCRB and STUBcast. We performed a set of intensive experiments to compare the three protocols with and without such deployment. The result reported a reduction in miss rate, restart rate and communication delay in all of them. The researcher found that the proposed mechanism reduces the communication delay significantly. They found that the proposed mechanism shall enable low-latency fog computing services of the IoT applications that are a delay sensitive. [ABSTRACT FROM AUTHOR]

Recent advances in flash memory technology have reduced the cost-per-bit of flash storage devices such as solid-state drives (SSDs), thereby enabling the development of large-capacity SSDs for enterprise-scale storage. However, two major concerns arise in designing SSDs. First, the size of the address mapping table is increasing in proportion to the capacity of the SSD. The SSD-internal firmware, called flash translation layer (FTL), must maintain the address mapping table in the internal DRAM. Although the previously proposed demand map loading technique uses a small size of cached map table, the technique aggravates poor random performance. Second, there are many redundant writes in storage workloads, which have an adverse effect on the performance and lifetime of the SSD. For example, many transaction-supporting applications use the write-ahead-log (WAL) scheme, which writes the same data twice. To resolve these problems, we propose a novel transaction-supporting SSD, called WAL-SSD, which logs transaction data at the internally-managed WAL area and relocates the data atomically via the FTL-level remap operation at the transaction checkpointing. It can also be used to transform random write requests to sequential requests. We implemented a prototype of WAL-SSD with a real SSD device. Experiments demonstrate the performance improvement by WAL-SSD with three use cases: remap-journaling, atomic multi-block update, and random write logging. [ABSTRACT FROM AUTHOR]

Traditional disk-resident OLTP systems were mainly designed for computers with relatively small memory. Driven by the advance of hardware, OLTP systems need to be redesigned for larger memory and multi-core environments. Compared to disk-resident systems, in-memory systems have significant performance advantages, from the perspectives of both transaction throughput and query latency. Their performance is no longer limited by disk I/Os. Instead, the efficiency and scalability over multi-core CPUs become more important. In this paper, we survey and summarize a wide spectrum of design and implementation considerations that may affect the efficiency or scalability of an in-memory OLTP system. These considerations are concerned with most of the main components of databases, including concurrency control, logging, indexing and transaction compilation. For each of the components, we provide some in-depth analysis based on recent research works. This survey also aims to provide some guidance for designing or implementing high-performance in-memory OLTP systems. [ABSTRACT FROM AUTHOR]

The central hypothesis of this paper is that database design and systems design in general can be simplified considerably by tailoring the design methods to a suitable range of applications. Domain-specific knowledge can be incorporated into a specialized database architecture that leaves the designer only with the task of specifying the application-specific parts. Based on an analysis of business constraints, we propose such an architecture for the domain of business transaction processing. The architecture offers several data and transaction management services, special-purpose subdatabases, and design-checking rules to be used by the application designer. Two services, input management and audit and control services, are described in more detail. [ABSTRACT FROM AUTHOR]