Search

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.

This paper tells about electronic transaction on ecommerce website using Secure Electronic Transaction (SET) protocol. SET is a very comprehensive security protocol, which utilizes cryptography to provide confidentiality of information, ensure payment integrity, and enable identity authentication. It relies on cryptography, digital certificate and authentication by SMS to ensure message confidentiality and security. First the report introduces about ecommerce websites and how to build it. It then explains how SET works and the components involved in it. Then the report gives out a design and implementation of this protocol.

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.

The specialized production of e-commerce transaction systems is an important research topic, which is of great significance for evaluating the development level and forecasting the development direction of e-commerce. However, there is a certain disparity between the current mainstream research model and reality, which leads to a deviated result. This paper puts forward a definition of “transaction efficiency” based on essential transaction services and establishes a model of the middleman's specialized production decision of transaction services. The research result shows that (1) transaction efficiency plays an important role in improving the middleman's specialized production level, (2) only when the transaction efficiency is higher than a certain threshold will the distribution middleman appear, and (3) the degree of economic specialization, price of commodities and transaction services, and other associated factors also affect the evolution of e-commerce transaction systems.

Debugging transactions and understanding their execution are of immense importance for developing OLAP applications, to trace causes of errors in production systems, and to audit the operations of a database. However, debugging transactions is hard for several reasons: 1) after the execution of a transaction, its input is no longer available for debugging, 2) internal states of a transaction are typically not accessible, and 3) the execution of a transaction may be affected by concurrently running transactions. We present a debugger for transactions that enables non-invasive, post-mortem debugging of transactions with provenance tracking and supports what-if scenarios (changes to transaction code or data). Using reenactment, a declarative replay technique we have developed, a transaction is replayed over the state of the DB seen by its original execution including all its interactions with concurrently executed transactions from the history. Importantly, our approach uses the temporal database and audit logging capabilities available in many DBMS and does not require any modifications to the underlying database system nor transactional workload., Comment: to appear as "Debugging Transactions and Tracking their Provenance with Reenactment" in PVDLB 2017, vol 10., nr. 12

In information systems, illegal information flow among objects has to be prevented. A transaction illegally reads data in an object if the object includes data in other objects which are not allowed to be read. In our previous studies, the FRWA-R (flexible read-write-abortion with role sensitivity) and FRWA-O (object sensitivity) protocols are proposed to prevent illegal information flow. Here, a transaction aborts with some probability once illegally reading data in an object. The abortion probability depends on the sensitivity of roles which the transaction holds and objects in which the transaction illegally reads data. The role sensitivity and object sensitivity show how many transactions which hold the role and illegally read data in the object abort after illegally reading data in the object, respectively. Here, the sensitivity just monotonically increases each time a transaction aborts. In this paper, we propose a new safety concept of a role and an FRWA-RS (FRWA with role safety) protocol. Here, the safety of a role increases and decreases each time a transaction holding the role commits and aborts by issuing an illegal read operation, respectively. A transaction with safer roles aborts with smaller probability. In the evaluation, we show fewer and more numbers of transactions abort in the FRWA-RS protocol than the RWA protocol and than the WA protocol, respectively, and transactions are more efficiently performed than the WA protocol.

It researches how to build a distributed data service platform based on REST architecture in the digital oilfield. In oil enterprise, the data are scattered in the isolated system among various dep...

Modern component-based distributed software systems are increasingly required to offer non-stop service and thus their updates must be carried out at runtime. Different authors have already proposed solutions for the safe management of dynamic updates. Our contribution aims at improving their efficiency without compromising safety. We propose a new criterion, called version consistency , which defines when a dynamic update can be safely and efficiently applied to the components that execute distributed transactions. Version consistency ensures that distributed transactions be served as if they were operated on a single coherent version of the system despite possible concurrent updates. The paper presents a distributed algorithm for checking version consistency efficiently, formalizes the proposed approach by means of a graph transformation system, and verifies its correctness through model checking. The paper also presents ConUp , a novel prototype framework that supports the approach and offers a viable, concrete solution for the use of version consistency. Both the approach and ConUp are evaluated on a significant third-party application. Obtained results witness the benefits of the proposed solution with respect to both timeliness and disruption.

One of the critical concerns in the current era is information security. Companies are sharing vast online critical data, which exposes their databases to malicious attacks. When protection techniques fail to prevent an attack, recovery is needed. Database recovery is not a straightforward procedure, since the transactions are highly interconnected. Traditional recovery techniques do not consider the interconnection between transactions because this information is not saved anywhere in the log file. Thus, they rollback all the transactions starting from the detected malicious transaction to the end of the log file. Hence, both affected and benign transactions will be rolled back, which is a waste of time. This paper presents an algorithm that works efficiently to assess the damage caused in the database by malicious transaction and recovers it. The proposed algorithm keeps track of the transactions that read from one another and store this information in a single matrix. The experimental results prove that the algorithm is faster than any other existing algorithm in this domain.

Trusted third-party (TTP) based transaction authentication is traditionally applied to authenticate mobile commerce transactions. However, several issues can arise with this, including seller fraud, TTP performance bottlenecks, and the risk of operations being interrupted. A peer-to-peer mobile commerce transaction authentication platform (MCTAP) with a semi-offline transaction authentication mechanism is proposed in this work. In this, both buyer and seller mutually authenticate and sign the digital receipt for each other. The trusted transaction authentication center thus no longer needs to operate online transaction verification processes, and only has to deal with consumer disputes. MCTAP can raise the efficiency of transaction authentication and provide solutions for the one-way transaction notification systems adopted by most online shopping sites that may encounter seller fraud. The proposed solution is compared to other TTP-based and secure electronic transaction based transaction authentication mechanisms, and the results indicate that the MCTAP has the advantages of efficiency and a higher security level.

DrTM is a fast in-memory transaction processing system that exploits advanced hardware features such as remote direct memory access (RDMA) and hardware transactional memory (HTM). To achieve high efficiency, it mostly offloads concurrency control such as tracking read/write accesses and conflict detection into HTM in a local machine and leverages the strong consistency between RDMA and HTM to ensure serializability among concurrent transactions across machines. To mitigate the high probability of HTM aborts for large transactions, we design and implement an optimized transaction chopping algorithm to decompose a set of large transactions into smaller pieces such that HTM is only required to protect each piece. We further build an efficient hash table for DrTM by leveraging HTM and RDMA to simplify the design and notably improve the performance. We describe how DrTM supports common database features like read-only transactions and logging for durability. Evaluation using typical OLTP workloads including TPC-C and SmallBank shows that DrTM has better single-node efficiency and scales well on a six-node cluster; it achieves greater than 1.51, 34 and 5.24, 138 million transactions per second for TPC-C and SmallBank on a single node and the cluster, respectively. Such numbers outperform a state-of-the-art single-node system (i.e., Silo) and a distributed transaction system (i.e., Calvin) by at least 1.9X and 29.6X for TPC-C.

Expert-curated guides to the best of CS research.

Recently, mobile phones have been recognized as the most convenient type of mobile payment device. However, they have some security problems; therefore, mobile devices cannot be used for unauthorized transactions using anonymous data by unauthenticated users in a cloud environment. This paper suggests a mobile payment system that uses a certificate mode in which a user receives a paperless receipt of a product purchase in a cloud environment. To address mobile payment system security, we propose the transaction certificate mode (TCM), which supports mutual authentication and key management for transaction parties. TCM provides a software token, the transaction certificate token (TCT), which interacts with a cloud self-proxy server (CSPS). The CSPS shares key management with the TCT and provides simple data authentication without complex encryption. The proposed self-creating protocol supports TCM, which can interactively communicate with the transaction parties without accessing a user's personal information. Therefore, the system can support verification for anonymous data and transaction parties and provides user-based mobile payments with a paperless receipt.

An apostate's opinion.

Data management during the whole life cycle of the object is fundamental requirement of current data processing. Temporal database brings new complex system, which allows storing and handling historical, current and future valid states of the objects. Existing solutions are inadequate in terms of performance--effectiveness, size and time processing requirements of the whole system. This paper deals with the principles of temporal data modelling, describes the structure and methods for manipulation. It focuses on future valid data processing, which can be processed using the transactions, too. It deals with temporal classification rules. Whereas, temporal system requires extension of the transaction properties, proposed system, which is fully temporal, highlights transaction definition and management. Described solution is mostly designed for communication systems, intelligent transport system, but can manage sensorial data, where performance based on speed and the size of the transmitted data is significant. However, it but can be used in any field due to its versatility.

This paper presents a general distributed messaging framework for online transaction processing applications in e-business industry, and we name it as Metamorphosis (MetaQ). Specifically, this messaging framework has features of high availability, scalability, and high data throughput. The current implementation of MetaQ supports distributed XA transactions, asynchronous messaging, and multiple ways for storing message offsets. As a consequence, it is suited to the application contexts having a large quantity of messages, transaction-support, and real-time requirements. More important, another branch of MetaQ implementation, i.e., RocketMQ has been deployed and used in Taobao.com and Alipay.com. The real usages in both typical online transaction applications have proven that the nature of MetaQ can perform well for such big Internet applications.

Increasing transaction volumes have led to a resurgence of interest in distributed transaction processing. In particular, partitioning data across several servers can improve throughput by allowing servers to process transactions in parallel. But executing transactions across servers limits the scalability and performance of these systems. In this paper, we quantify the effects of distribution on concurrency control protocols in a distributed environment. We evaluate six classic and modern protocols in an in-memory distributed database evaluation framework called Deneva, providing an apples-to-apples comparison between each. Our results expose severe limitations of distributed transaction processing engines. Moreover, in our analysis, we identify several protocol-specific scalability bottlenecks. We conclude that to achieve truly scalable operation, distributed concurrency control solutions must seek a tighter coupling with either novel network hardware (in the local area) or applications (via data modeling and semantically-aware execution), or both.

Contactless mobile payment devices are fast, convenient and user friendly means for executing small value business transactions. This kind of transactions is preferred to be executed conveniently and on the fly by just tapping a mobile payment device to a mobile terminal. Mobility, convenience and fast transaction execution are very important payment system properties in potentially crowded places such as in public transportation. These properties are in practice causing transaction execution problems, such as: delays in offline transaction execution, transaction atomicity failures caused by mobile data communication drops, lack of central control on mobile transaction system components and increased vulnerability risk caused by easy physical access to the mobile transaction system components. This paper describes a holistic transaction processing model for resolving mentioned problems in micropayment mobile touch-and-go transaction systems. Defined processing model was implemented on real public transportation mobile payment system where it was proven as a robust solution for execution of small value touch-and-go mobile ticketing transactions.

The convergence of high-performance computing and big data, which has become known as the field of extreme big data, is problematic in that file creation in storage systems such as distributed file systems is not optimized. That is, the large workload leads to the simultaneous creation of many files by many processes when creating checkpoints. The need to improve the file creation processes prompted us to design a scale-out distributed file system for post-petascale systems named PPFS. PPFS consists of PPMDS, a scale-out distributed metadata server, and PPOSS, a scalable distributed storage server for flash storage. High file creation performance of PPMDS was achieved by using a key-value store for metadata storage and non-blocking distributed transactions to update multiple entries simultaneously. PPOSS depends on PPOST, an object storage system that manages underlying low-level storage, such as Fusion IO ioDrive, a flash device connected through PCI express supporting OpenNVM. High file creation performance was attained by implementing the PPFS prototype using file creation optimization, termed bulk creation, to reduce the amount of communication between PPMDS and PPOSS. Moreover, to enhance the I/O performance of PPOSS when the client process and PPOSS run on the same node, PPOSS accesses the local storage device directly. The prototype implementation of PPFS with file creation optimization achieves 119,000 operations per second for file creation when using five metadata servers and 128 client processes, thereby exceeding the performance of IndexFS 2.17 times. With local access optimization, PPOSS reached its limit at a block size of 16 KiB, an improvement of 1.5 times compared to before optimization. Furthermore, this evaluation indicates that PPFS has scalability on file creation and IO performance, that is required for post-petascale systems.

Transaction processing database management systems (DBMSs) are critical for today's data-intensive applications because they enable an organization to quickly ingest and query new information. Many of these applications exceed the capabilities of a single server, and thus their database has to be deployed in a distributed DBMS. The key factor affecting such a system's performance is how the database is partitioned. If the database is partitioned incorrectly, the number of distributed transactions can be high. These transactions have to synchronize their operations over the network, which is considerably slower and leads to poor performance. Previous work on elastic database repartitioning has focused on a certain class of applications whose database schema can be represented in a hierarchical tree structure. But many applications cannot be partitioned in this manner, and thus are subject to distributed transactions that impede their performance and scalability. In this paper, we present a new on-line partitioning approach, called Clay, that supports both tree-based schemas and more complex "general" schemas with arbitrary foreign key relationships. Clay dynamically creates blocks of tuples to migrate among servers during repartitioning, placing no constraints on the schema but taking care to balance load and reduce the amount of data migrated. Clay achieves this goal by including in each block a set of hot tuples and other tuples co-accessed with these hot tuples. To evaluate our approach, we integrate Clay in a distributed, main-memory DBMS and show that it can generate partitioning schemes that enable the system to achieve up to 15× better throughput and 99% lower latency than existing approaches.

Scaling out database management systems(DBMSs) requires distributed coordination, which caneasily become a bottleneck. Recent work on speeding updistributed transactions has addressed this problem byproposing scale-out techniques that are deeply integratedwith the concurrency control mechanism of the DBMS.This paper explores the design of modular coordinationlayers, which encapsulate all scale-out logic and can beapplied to scale out any unmodified single-server DBMS.It proposes Gyro, a modular coordination layer that runson top of a collection of single-server DBMS instancesand interacts with them only through their client interface.Gyro distributes the load by ensuring that as many requestsas possible are executed by only one DBMS instance. Ourexperiments show that modular distributed coordination ispractically viable and can be much faster than traditionaldistributed transaction protocols using two-phase commit.

Most large modern-day applications (Facebook, Gmail, eBay, etc.) rely on widely distributed and replicated storage of data for scalability, availability, and disaster tolerance. Since maintaining high degrees of data consistency requires costly communication across distant sites, applications over such distributed and partially replicated data are complex artifacts that must carefully balance the required degrees of consistency and performance. In this paper I summarize work at the University of Illinois Assured Cloud Computing center on using rewriting logic and its associated Maude tool environment to formally model and analyze both the correctness and the performance of state-of-the-art distributed transaction systems designs, as well as on how to automatically obtain a correct-by-construction distributed implementation of a promising design.

Emerging Multicore SoC SmartNICs, enclosing rich computing resources (e.g., a multicore processor, onboard DRAM, accelerators, programmable DMA engines), hold the potential to offload generic datacenter server tasks. However, it is unclear how to use a SmartNIC efficiently and maximize the offloading benefits, especially for distributed applications. Towards this end, we characterize four commodity SmartNICs and summarize the offloading performance implications from four perspectives: traffic control, computing capability, onboard memory, and host communication. Based on our characterization, we build iPipe, an actor-based framework for offloading distributed applications onto SmartNICs. At the core of iPipe is a hybrid scheduler, combining FCFS and DRR-based processor sharing, which can tolerate tasks with variable execution costs and maximize NIC compute utilization. Using iPipe, we build a real-time data analytics engine, a distributed transaction system, and a replicated key-value store, and evaluate them on commodity SmartNICs. Our evaluations show that when processing 10/25Gbps of application bandwidth, NIC-side offloading can save up to 3.1/2.2 beefy Intel cores and lower application latencies by 23.0/28.0 μs.

Concurrent objects with asynchronous messaging are an increasingly popular way to structure highly available, high performance, large-scale software systems. To ensure data-consistency and support synchronization between objects such systems often use distributed transactions with Two-Phase Locking (2PL) for concurrency control and Two-Phase commit (2PC) as atomic commitment protocol. Inquiry In highly available, high-throughput systems, such as large banking infrastructure, however, 2PL becomes a bottleneck when objects are highly contended, when an object is queuing a lot of messages because of locking.ApproachIn this paper we introduce Path-Sensitive Atomic Commit (PSAC) to address this situation. We start from message handlers (or methods), which are decorated with pre- and post-conditions, describing their guards and effect.KnowledgeThis allows the PSAC lock mechanism to check whether the effect of two incoming messages at the same time are independent, and to avoid locking if this is the case. As a result, more messages are directly accepted or rejected, and higher overall throughput is obtained.GroundingWe have implemented PSAC for a state machine-based DSL called Rebel, on top of a runtime based on the Akka actor framework. Our performance evaluation shows that PSAC exhibits the same scalability and latency characteristics as standard 2PL/2PC, and obtains up to 1.8 times median higher throughput in congested scenarios.ImportanceWe believe PSAC is a step towards enabling organizations to build scalable distributed applications, even if their consistency requirements are not embarrassingly parallel.

Blockchain technology has attracted various areas like corporations, education, government, and healthcare because of its unhackable security features. In spite of common arguments about the occurrence of Blockchain technology in terms of security and privacy, in reality, several attacks can be launched against them. This paper presents a comprehensive survey of the most vulnerable Blockchain attacks and the different approaches proposed against these attacks. This paper also provides taxonomy of attacks, which are most challengeable to Blockchain security key features. Additionally, a review of the countermeasures, which have offered solutions to avoid these attacks, has been presented.

Health Data Records Fragmentation across hospitals, labs, pharmacies, and general caregivers has been hurting medical services quality and patient outcome. The problem is getting worse as we have even more healthcare accesses from different sources such as mobile phones, wearable devices, etc. In an attempt to defragment health data, we are proposing the utilization of distributed transaction ledgers (DTL) technology by IOTA-Tangle which facilitates communication between patients and care providers. Through this technology the gap between health-care delivery and population health can be bridged so the quality of health services and patient outcomes may be improved. Our approach provides complete picture for each patient by sharing data between healthcare participants.

Existing blockchain systems scale poorly because of their distributed consensus protocols. Current attempts at improving blockchain scalability are limited to cryptocurrency. Scaling blockchain systems under general workloads (i.e., non-cryptocurrency applications) remains an open question. In this work, we take a principled approach to apply sharding, which is a well-studied and proven technique to scale out databases, to blockchain systems in order to improve their transaction throughput at scale. This is challenging, however, due to the fundamental difference in failure models between databases and blockchain. To achieve our goal, we first enhance the performance of Byzantine consensus protocols, by doing so we improve individual shards' throughput. Next, we design an efficient shard formation protocol that leverages a trusted random beacon to securely assign nodes into shards. We rely on trusted hardware, namely Intel SGX, to achieve high performance for both consensus and shard formation protocol. Third, we design a general distributed transaction protocol that ensures safety and liveness even when transaction coordinators are malicious. Finally, we conduct an extensive evaluation of our design both on a local cluster and on Google Cloud Platform. The results show that our consensus and shard formation protocols outperform state-of-the-art solutions at scale. More importantly, our sharded blockchain reaches a high throughput that can handle Visa-level workloads, and is the largest ever reported in a realistic environment., Comment: This is an updated version of the Chain of Trust: Can Trusted Hardware Help Scaling Blockchains? paper. This version is to be appeared in SIGMOD 2019

Distributed generation transaction stimulates the demand response potential of users and promotes the near-end of energy consumption. However, the existing models lack research on distributed transaction algorithms. In this paper, a nucleolus model for profit allocation of distributed generation transactions is proposed first. Based on the model, a low-carbon trading strategy suitable for distributed users is proposed considering the differences in carbon emissions between different distributed power sources. The trading strategy is designed for individual users and is suitable for both power purchasers and sellers. Then, trading mechanism is designed for distributed transaction. According to the size of the quotation differences, the transaction objects are selected and the transaction volumes are determined. Finally, the low-carbon strategy is carried out under the mechanism. It is shown that the strategy satisfies the individual and the overall rationality and promote low-carbon transaction.

The popular microservice architecture for applications brings new challenges for consistent distributed transactions across multiple microservices. These microservices may be implemented in different languages, and access multiple underlying databases. Consistent distributed transactions are a real requirement but are very hard to achieve with existing technologies in these environments. In this demo we present GRIT: a system that resolves this challenge by cleverly leveraging deterministic database technologies and optimistic concurrency control protocol(OCC). A transaction is optimistically executed with its read-set and write-set captured during the execution phase. Then at the commit time, conflict checking is performed and a global commit decision is made. A logically committed transaction is persisted into logs first, and then asynchronously applied to the physical databases deterministically. GRIT is able to achieve consistent, high throughput and serializable distributed transactions for any applications invoking microservices. The demonstration offers a walk-through of how GRIT can easily support distributed transactions across multiple microservices and databases.

The blockchain is a secure and trustworthy distributed transaction management system that is being extensively researched and developed for various applications and use cases. This study introduces a novel distributed control system using the Blockchain. A multi-robot path planning application is developed and deployed to benchmark a blockchain platform, the Hyperledger Fabric. Blockchain technology has the reputation of being sufficiently dilatory that it is inappropriate for time-sensitive applications. This research demonstrates how the enterprise-grade blockchain solutions overcome this shortcoming and investigates their potential for enabling secure and trusted distributed control systems for IoT.

International audience; Providing scalability for mobile distributed applications often leads the applications to compromise their consistency requirements. However, some of these applications depend on strong consistency to guarantee that one consistent state is observed by all participants over (some of) the shared objects of the application. While deploying the application in the Cloud facilitates state management and trivially solves the strong consistency requirements, this also creates a geographical barrier between mobile devices and the application servers that penalises performance with an unavoidable la-tency and jitter. Fog Computing architectures can mitigate this impact by deploying surrogate servers at the network edge but its performance depends of a middleware service able to monitor the application and deploy each fragment of the state at the most convenient location. Such alternative leads to the emergence of distributed transactions that require increasing efforts to maintain strong consistency. This paper addresses how virtual synchrony, in particular a technique named LightWeight Group (LWG), can help supporting strong consistency for mobile applications in the Fog Computing environment.

Highly-available datastores are widely deployed for Internet-based applications. However, many Internet-based applications are not contented with the simple data access interface provided by highly-available datastores. Distributed transaction support is demanded by applications such as massive online payment used by Alipay, Paypal or Baidu Wallet. Current solutions to distributed transaction can spend more than half of the whole transaction processing time in distributed commit. The culprits are the multiple write-ahead logging steps and communication roundtrips in the commit process. This paper presents the HACommit protocol, a logless one-phase commit protocol for highly-available datastores. HACommit has transaction participants vote for a commit before the client decides to commit or abort the transaction; in comparison, the state-of-the-art practice for distributed commit is to have the client decide before participants vote. The change enables the removal of both the participant’s write-ahead logging and the coordinator’s write-ahead logging steps in the distributed commit process; it also makes possible that, after the client initiates the transaction commit, the transaction data is visible to other transactions within one communication roundtrip time (i.e., one phase). In the evaluation with extensive experiments, HACommit outperforms recent atomic commit solutions for highly-available datastores under different workloads. In the best case, HACommit can commit in one fifth of the time the widely-used two-phase commit (2PC) does.

While Chapter 13 covered distributed transactions with working code, you relooked at those examples with an enhanced design in Chapter 14 with an aim to understand the nitty-gritty details and concerns while architecting solutions for BASE transactional support. So far, so good, but the question is whether there is a way to abstract the details you saw in those two chapters and still attain the required level of data consistency in a microservices architecture. You will look at this in detail in this chapter. The examples in this chapter are not a continuation of the examples you covered in Chapters 13 and 14, so you can skip those two chapters if you are in a hurry to understand the examples in this chapter. However, you are going to leverage Axon framework again in this chapter, so you are strongly advised to go through Chapter 12 first to get an introduction to Axon so that you know the programming paradigm during this discussion.

Many transaction systems distribute, partition, and replicate their data for scalability, availability, and fault tolerance. However, observing and maintaining strong consistency of distributed and partially replicated data leads to high transaction latencies. Since different applications require different consistency guarantees, there is a plethora of consistency properties—from weak ones such as read atomicity through various forms of snapshot isolation to stronger serializability properties—and distributed transaction systems (DTSs) guaranteeing such properties. This paper presents a general framework for formally specifying a DTS in Maude, and formalizes in Maude nine common consistency properties for DTSs so defined. Furthermore, we provide a fully automated method for analyzing whether the DTS satisfies the desired property for all initial states up to given bounds on system parameters. This is based on automatically recording relevant history during a Maude run and defining the consistency properties on such histories. To the best of our knowledge, this is the first time that model checking of all these properties in a unified, systematic manner is investigated. We have implemented a tool that automates our method, and use it to model check state-of-the-art DTSs such as P-Store, RAMP, Walter, Jessy, and ROLA.

Chapter 13 covered distributed transactions extensively. You now understand distributed transactions clearly so you use them judiciously. To make it clear, you want to avoid distributed transactions as much as possible in the microservices world across partitions and domains. I do not say that distributed transactions should be deprecated completely in microservices architecture because there are areas where you want to use them by trading loose coupling for reliability; however, the essence is that you can do most of the design without actually using distributed transactions when cross-partitions and cross-domains are involved. You will look at how to do this in detail in this chapter. The examples in this chapter are a continuation of the examples from Chapter 13, so you may want to read and understand Chapter 13 before you attempt to run the examples in this chapter.

Дослідження ставить на меті підвищення рівня загальної доступності даних в окремому вузлі розподіленої бази даних та ефективності використання програмних систем по роботі з даними за рахунок зменшення кількості розподілених запитів. Мета досягається шляхом оптимізації структури вузла розподіленої бази даних та мінімізації обсягів даних, що зберігаються у ньому. Для досягнення мети було створено підсистему обліку користувацьких запитів, граматику мови T-SQL та виконано парсинг коду SQL-запитів. В результаті запити класифікуються за списком таблиць бази даних, які трапляються у запиті, а також, після виконання більш детального аналізу, за списком атрибутів та кортежів відношення. Останнє досягається за рахунок виконання набору запитів зі зверненням до первинного ключа кожного відношення, що входить до складу запиту. Виконання повного аналізу оцінки корисності атрибутів та кортежів таблиць бази даних є досить ресурсоємною операцією, тому не може виконуватися при кожній зміні даних. У рамках дослідження запропоновано реалізувати вирішення задачі класифікації нових даних із використанням нейронної мережі прямого поширення, що навчається на базі оцінених попередньо даних на базі парсингу SQL-запитів. Враховуючи необхідність виконання аналізу накопичених даних з точки зору множинності вимірів, а також, ймовірно, великі їх обсяги, було виконано представлення даних, необхідних для аналізу, у вигляді багатовимірної моделі. The paper deals with the tendency to move from "universal" accounting systems to specialized solutions usage. This requires the synchronization of distributed database data. It is noted that among the strategies of data distribution between distributed database nodes, the combined one is the most justified, but the main disadvantage consists in the existence of distributed transactions when handling data. The research aims to improve the general availability of data in the separate node of the distributed database and the efficiency of using software systems to work with database data by reducing the number of distributed requests. The goal is achieved by optimizing the structure of the distributed database node and minimizing the amount of data stored in it. To achieve the goal, users' query accounting subsystem and T-SQL grammar have been created, and SQL query code has been parsed. As a result, the queries are classified by the list of database tables that are found in the query, and, after performing more deyailed analysis, by the list of attributes and relation tuples. The last one is achieved by executing a set of queries with getting the primary key of each relation included in the query. Performing the complete analysis of the database tables attributes and tuples estimation is a very resource-intensive operation, so it cannot be performed every time the database data is changed. The research proposes to solve the problem of classification of new data by using the perceptron, which learns on the basis of pre-evaluated data based on SQL query parsing. Also, according to the need of performing the analysis of received data from the point of view of multiple dimensions, as well as probably their large amount, the data required for the analysis has been presented in the form of a multidimensional model

Modern transactional platforms strive to jointly ensure ACID consistency and high scalability. In order to pursue these antagonistic goals, several recent systems have revisited the classical State Machine Replication (SMR) approach in order to support sharding of application state across multiple data partitions and partial replication. By promoting and exploiting locality principles, these systems, which we call Partially Replicated State Machines (PRSMs), can achieve scalability levels unparalleled by classic SMR. Yet, existing PRSM systems suffer from two major limitations: 1) they rely on a single thread to execute or serialize transactions within a partition, thus failing to fully untap the parallelism of multi-core architectures, and/or 2) they rely on the ability to accurately predict the data items to be accessed by transactions, which is non-Trivial for complex applications. This paper proposes Sparkle, an innovative deterministic concurrency control that enhances the throughput of state of the art PRSM systems by more than one order of magnitude under high contention, through the joint use of speculative transaction processing and scheduling techniques. On the one hand, speculation allows Sparkle to take full advantage of modern multi-core micro-processors, while avoiding any assumption on the a-priori knowledge of the transactions' access patterns, which increases its generality and widens the scope of its scalability. Transaction scheduling techniques, on the other hand, are aimed to maximize the efficiency of speculative processing.

Blockchain technology is one of the most widely acclaimed technologies of recent years. It enables the creation of distributed applications involving multiple actors or organizations in which transactions and data are not under the control of a central authority. Transactions are stored in a distributed public ledger in an immutable format in such a way that they can be verified by participants. This disintermediation promises to remove much of the “friction” (and lower costs) from distributed transactions by cutting out the intermediary party, thus enabling a variety of applications in finance, government, health, etc. This paper provides an overview of recent research in the application of blockchain technology to higher education for those who are interested in working in this area or just understanding how higher education may be positively impacted in the future by blockchain.

In this paper we introduce SpecRPC, a speculative execution framework that allows applications to concurrently execute dependent operations both locally and through remote procedure calls. The framework tracks dependencies among non-speculative and speculative operations and ensures that incorrect speculations do not affect the correctness of applications that follow our suggested design pattern. By using speculation to parallelize dependent operations, SpecRPC can significantly reduce application latency even if only a fraction of the results can be correctly speculated. We evaluate SpecRPC by using it to implement Replicated Commit, a low-latency distributed transaction commit protocol for geo-replicated database systems. Our evaluation results show that, compared to RPC frameworks that sequentially execute dependent operations, SpecRPC can reduce the average transaction completion time of Replicated Commit by 58%.

Since the security and fault tolerance is the two important metrics of the data storage, it brings both opportunities and challenges for distributed data storage and transaction. The traditional transaction system of storage resources, which generally runs in a centralized mode, results in high cost, vendor lock-in, single point failure risk, DDoS attack and information security. Therefore, this paper proposes a distributed transaction method for cloud storage based on smart contract. First, to guarantee the fault tolerance and decrease the storing cost for erasure coding, a VCG-based auction mechanism is proposed for storage transaction, and we deploy and implement the proposed mechanism by designing a corresponding smart contract. Especially, we address the problem - how to implement a VCG-like mechanism in a blockchain environment. Based on private chain of Ethereum, we make the simulations for proposed storage transaction method. The results showed that proposed transaction model can realize competitive trading of storage resources, and ensure the safe and economic operation of resource trading.

Shared-nothing, distributed database is the core component for modern OLTP application. It uses horizontal partitioning to partition data into multiple partitions to achieves both ACID and scalability. The existing distributed transactions degrade the performance of database, many partition management systems therefore had been proposed to use graph partitioning to mitigate impact of distributed transactions on performance. These systems run well when amount of data is limited, but consume a lot of resources otherwise. This paper proposed an adaptive chunk tool ACTDP, automatically aggregate the vertices in the graph in such systems by consider both number and weight of each vertex, improves performance of these graph-based partition management systems.

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.

The modern financial world has seen a significant rise in the use of cryptocurrencies in recent years, partly due to the convincing lure of anonymity promised by these schemes. Bitcoin, despite being considered as the most widespread among all, is claimed to have significant lapses in relation to its anonymity. Unfortunately, studies have shown that many cryptocurrency transactions can be traced back to their corresponding participants through the analysis of publicly available data, to which the cryptographic community has responded by proposing new constructions with improved anonymity claims. Nevertheless, the absence of a common metric for evaluating the level of anonymity achieved by these schemes has led to numerous disparate ad hoc anonymity definitions, making comparisons difficult. The multitude of these notions also hints at the surprising complexity of the overall anonymity landscape. In this study, we introduce such a common framework to evaluate the nature and extent of anonymity in (crypto) currencies and distributed transaction systems, thereby enabling one to make meaningful comparisons irrespective of their implementation. Accordingly, our work lays the foundation for formalizing security models and terminology across a wide range of anonymity notions referenced in the literature, while showing how “anonymity” itself is a surprisingly nuanced concept, as opposed to existing claims that are drawn upon at a higher level, thus missing out on the elemental factors underpinning anonymity.

Blockchain consists of networks of successive blocks that are interconnected to each other by references to their former block. These form a chain. Blockchain technology creates a database like support by creation of digital ledgers, in order to support distributed transactions. The adoption of blockchain in real-world applications poses many challenges. This study aims to understand the method, its characteristics as well as the implementation concepts of transactional systems in terms of distributed transactions over web resources. The study also examines the current trends and issues in the use of blockchain in many large-scale public utility applications in e-commerce.

First, Irene Zhang delivers a whirlwind tour of recent developments in distributed concurrency control. If you thought distributed transactions were prohibitively expensive, Irene’s selections may prompt you to reconsider: the use of atomic clocks, clever replication protocols, and new means of commit ordering all improve performance at scale. Second, Fadel Adib provides a fascinating look at using computer networks as physical sensors. It turns out that the radio waves passing through our environment and bodies are subtly modulated as they do so. As Fadel’s selection shows, new techniques for sensing and interpreting these modulations allow us to perform tasks previously reserved for science fiction: seeing through walls, performing gesture recognition, and monitoring breathing.