ConfluxDB

In stand-alone databases, the functions of ordering the transaction commits and making the effects of transactions durable are performed in one single action, namely the writing of the commit record to disk. For efficiency many of these writes are grouped into a single disk operation. In replicated databases in which all replicas agree on the commit order of update transactions, these two functions are typically separated. Specifically, the replication middleware determines the global commit order, while the database replicas make the transactions durable.The contribution of this paper is to demonstrate that this separation causes a significant scalability bottleneck. It forces some of the commit records to be written to disk serially, where in a standalone system they could have been grouped together in a single disk write. Two solutions are possible: (1) move durability from the database to the replication middleware, or (2) keep durability in the database and pass the global commit order from the replication middleware to the database.We implement these two solutions. Tashkent-MW is a pure middleware solution that combines durability and ordering in the middleware, and treats an unmodified database as a black box. In Tashkent-API, we modify the database API so that the middleware can specify the commit order to the database, thus, combining ordering and durability inside the database. We compare both Tashkent systems to an otherwise identical replicated system, called Base, in which ordering and durability remain separated. Under high update transaction loads both Tashkent systems greatly outperform Base in throughput and response time.

We address, the issue of reading the entire database by the broadcast transaction for data broadcasting in mobile environments. The broadcast transaction is a long-lived read-only transaction which creates significant amount of data conflicts with other concurrent update transactions. Using conventional concurrency control to handle the broadcast transaction is inadequate. Recently, some algorithms are proposed for reading the entire database. However, they suffer from late detection of data conflicts. This leads to many data entities being locked unnecessarily, reducing the availability of data. To solve this problem, an effective protocol based on a data locking approach is devised. Data conflicts can be detected at the early stage of the execution of update transactions by a set of predefined rules. As a result, the lock holding time of data entities is effectively reduced and unnecessary acquisitions of data locks are avoided. The simulation results show that the system performance can be significantly improved.

In this paper, we devise a “temporally reordering” mechanism of supporting update transactions that are impacted by delays (e.g., network delays) to the extent that they cannot be executed because of the irreversible progress of other conflicting transactions (i.e., data dependent and temporally dependant) extend this scheme with a delayed-initiation mechanism. This mechanism allows (a) the impacted update transaction to be repositioned to the earliest supportable point in the temporal ordering of transactions, and (b) the associated transaction manager (and in turn, the application or entity that submitted the transaction) to be notified of the new position, thereby providing the opportunity for adjustments or transaction termination. We describe the risk-free MVTC (RF-MVTC) algorithm and its delay-initiation variation (RF-MVTCD). We also present the set of experiments we have carried out to study the performance of MVTC and its variations: RF-MVTC, and RF-MVTCD.KeywordsData ItemTurnaround TimeNetwork DelayInitiation VariationRead RequestThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Relational database applications are notoriously difficult to test and debug. Concurrent execution of database transactions may violate complex structural invariants that constraint how changes to the contents of one (shared) table affect the contents of another. Simplifying the underlying concurrency model is one way to ameliorate the difficulty of understanding how concurrent accesses and updates can affect database state with respect to these sophisticated properties. Enforcing serializable execution of all transactions achieves this simplification, but it comes at a significant price in performance, especially at scale, where database state is often replicated to improve latency and availability.To address these challenges, this paper presents a novel testing framework for detecting serializability violations in (SQL) database-backed Java applications executing on weakly-consistent storage systems. We manifest our approach in a tool, CLOTHO, that combines a static analyzer and model checker to generate abstract executions, discover serializability violations in these executions, and translate them back into concrete test inputs suitable for deployment in a test environment. To the best of our knowledge, CLOTHO, is the first automated test generation facility for identifying serializability anomalies of Java applications intended to operate in geo-replicated distributed environments. An experimental evaluation on a set of industry-standard benchmarks demonstrates the utility of our approach.

SummaryA distributed system consisting of a huge number of computational entities is prone to faults because faults in a few nodes cause the entire system to fail. Consequently, fault tolerance of distributed systems is a critical issue. Checkpoint‐rollback recovery is a universal and representative technique for fault tolerance; it periodically records the entire system state (configuration) to non‐volatile storage, and the system restores itself using the recorded configuration when the system fails. To record a configuration of a distributed system, a specific algorithm known as a snapshot algorithm is required. However, many snapshot algorithms require coordination among all nodes in the system; thus, frequent executions of snapshot algorithms require unacceptable communication cost, especially if the systems are large. As a sophisticated snapshot algorithm, a partial snapshot algorithm has been introduced that takes a partial snapshot (instead of a global snapshot). However, if two or more partial snapshot algorithms are concurrently executed, and their snapshot domains overlap, they should coordinate, so that the partial snapshots (taken by the algorithms) are consistent. In this paper, we propose a new efficient partial snapshot algorithm with the aim of reducing communication for the coordination. In a simulation, we show that the proposed algorithm drastically outperforms the existing partial snapshot algorithm, in terms of message and time complexity.

This article introduces a comprehensive framework for building trustworthy and interpretable Large Language Model (LLM)-driven control planes for autonomous distributed systems. As LLMs are increasingly integrated into critical infrastructure management, from database administration to resource allocation, they introduce unique challenges related to trustworthiness, interpretability, and robustness. To identify two fundamental issues: the Recursive AI Problem, where AI systems manage other AI components, creating complex feedback loops, and the Semantic Gap Issue, where LLMs operate at high levels of abstraction while distributed systems require precise operational semantics. Our proposed framework addresses these challenges through a multi-layered approach combining formal verification techniques, explainability mechanisms, and human-in-the-loop integration. We develop novel methods for system-specific LLM fine-tuning, symbolic-neural integration, and semantic alignment verification. Experimental evaluation across database management, Kubernetes resource allocation, and data pipeline orchestration scenarios demonstrates significant improvements in trustworthiness and interpretability while maintaining performance benefits. This work bridges the critical gap between advanced LLM capabilities and the requirements for safe, reliable system management in mission-critical environments.

Guest Editorial

The building of an object distributed database management system (ODDBMS) integrates the linked concepts of the distributed database management and the linked concepts of objects. Among the object concepts, the author focuses interest on the following two concepts: inherit link and reference link. The author studies how these links, adapted to a distributed system, influence the global request (transaction) decomposition into local sub-requests (sub-transactions). The author also studies how these links have to be taken into account during the different types of management that the distributed system has to use in order to be consistent and reliable. The originality of the proposition is that one integrates the inheritance concept in a distributed system by extending it to an aspect related to duplication. A class which inherits from another class implanted on another site sees its inherited attribute occurrences duplicated on its implantation site. The author proposes with an example of ODDB, an implementation of the methods used in description of classes and shows how they can be used in examples of update transactions.

the effect of hypoxia to stimulate breathing and the cardiovascular system has been well known for more than a century (for a review, see Ref. [11][1]). In 1938, Heymans was awarded the Nobel Prize for Physiology or Medicine for demonstrating the importance of carotid body chemoreceptors. However,

As a representative large-scale data management technology, Apache Hadoop is an open-source framework for processing a variety of data such as SNS, medical, weather, and IoT data. Hadoop largely consists of HDFS, MapReduce, and YARN. Among them, we focus on improving the HDFS metadata management scheme responsible for storing and managing big data. We note that the current HDFS incurs many problems in system utilization due to its file-based metadata management. To solve these problems, we propose a novel metadata management scheme based on RDBMS for improving the functional aspects of HDFS. Through analysis of the latest HDFS, we first present five problems caused by its metadata management and derive three requirements of robustness, availability, and scalability for resolving these problems. We then design an overall architecture of the advanced HDFS, A-HDFS, which satisfies these requirements. In particular, we define functional modules according to HDFS operations and also present the detailed design strategy for adding or modifying the individual components in the corresponding modules. Finally, through implementation of the proposed A-HDFS, we validate its correctness by experimental evaluation and also show that A-HDFS satisfies all the requirements. The proposed A-HDFS significantly enhances the HDFS metadata management scheme and, as a result, ensures that the entire system improves its stability, availability, and scalability. Thus, we can exploit the improved distributed file system based on A-HDFS for various fields and, in addition, we can expect more applications to be actively developed.

Optimizing resource management is essential for improving the performance of web platforms in dynamic cloud environments. This paper introduces a predictive cloud resource management framework that integrates Long Short-Term Memory (LSTM) neural networks for workload forecasting with a dynamic resource scaling mechanism. The framework proactively allocates cloud resources, addressing challenges such as latency, cost inefficiency, and under-utilization. Experimental evaluations on a benchmark dataset demonstrated significant performance improvements over traditional methods. The proposed framework achieved a mean squared error (MSE) of 0.012 in workload prediction, a 28% reduction in response time, and a 23% increase in cost savings. These results highlight the effectiveness of predictive resource management in managing dynamic workloads and optimizing distributed web systems. The findings provide a scalable and cost-efficient solution, contributing to advancements in cloud-based resource management. Future work will explore hybrid models to further enhance adaptability and address real-time anomalies. This research lays a foundation for developing innovative and sustainable strategies in distributed computing environments.

Evaluation of contact synchronization algorithms for the Android platform

Synchronization protocols have been widely investigated in distributed systems aiming to achieve real time and scalable properties. With the fast development of large scale distributed systems and due to their heterogenous nature involving wired, wireless and mobile nodes, synchronization has come again to play. In this work we have studied the contact synchronization and handling, which is an important feature in corporate environments. Indeed, it has become very important to support collaboration of teams of mobile users by enabling anytime and anywhere access to shared contact data. We characterize the problem as a distributed systems problems, identify its desirable properties and outline its main characteristics. A simple algorithm is proposed as an efficient solution to the contact synchronization when some nodes of the system are assumed mobile phones under Android system. The needed features on both ends of the distributed system are explained in order to guarantee the correctness of the algorithm. We also analyze the implementation of the algorithm coupling the Android platform and the Sugar CRM server and provide some experimental evaluation on the performance of the proposed approach.

Virtual Tree: A robust architecture for interval valid queries in dynamic distributed systems

This article presents Pot, a system that leverages the concept of preordered transactions to achieve deterministic multithreaded execution of programs that use Transactional Memory. Preordered transactions eliminate the root cause of nondeterminism in transactional execution: they provide the illusion of executing in a deterministic serial order, unlike traditional transactions that appear to execute in a nondeterministic order that can change from execution to execution. Pot uses a new concurrency control protocol that exploits the serialization order to distinguish between fast and speculative transaction execution modes in order to mitigate the overhead of imposing a deterministic order. We build two Pot prototypes: one using STM and another using off-the-shelf HTM. To the best of our knowledge, Pot enables deterministic execution of programs using off-the-shelf HTM for the first time. An experimental evaluation shows that Pot achieves deterministic execution of TM programs with low overhead, sometimes even outperforming nondeterministic executions, and clearly outperforming the state of the art.