This paper proposes Oze, a concurrency control protocol that handles heterogeneous workloads, including long-running update transactions. Oze explores a large scheduling space using a multi-version serialization graph to reduce false positives. Oze manages the graph in a decentralized manner to exploit many cores in modern servers. We further propose an OLTP benchmark, BoMB (Bill of Materials Benchmark), based on a use case in an actual manufacturing company. BoMB consists of one long-running update transaction and five short transactions that conflict with each other. Experiments using BoMB show that Oze can handle the long-running update transaction while achieving four orders of magnitude higher throughput than state-of-the-art optimistic and multi-version protocols and up to five times higher throughput than pessimistic protocols. We also show Oze performs comparably with existing techniques even in a typical OLTP workload, TPC-C, thanks to a protocol switching mechanism.

This paper presents ScalarDB, a universal transaction manager that achieves distributed transactions across multiple disparate databases. ScalarDB provides a database-agnostic transaction manager on top of its database abstraction; thus, it achieves transactions spanning various databases without depending on the transactional capability of underlying databases. ScalarDB is based on several research works and extended to provide a strong correctness guarantee (i.e., strict serializability), further performance optimizations, and several critical mechanisms for productization. In this paper, we describe the design and implementation of ScalarDB. We also present evaluation results showing that ScalarDB achieves database-spanning transactions with reasonable performance and near-linear scalability without sacrificing correctness. Finally, we share some case studies and lessons learned while building and running ScalarDB.

Bamboo is a state-of-the-art concurrency control protocol based on the 2-phase locking protocol. One problem of Bamboo is that it requires transactions to fetch timestamps from a single centralized atomic counter. To replace the concentrated access to it, each transaction should generate timestamps independently. This paper proposes thread-ID method (TID), which dismisses the process of fetching timestamps entirely by assigning an ID to each thread, and transactions use the thread IDs as their timestamps. In high-contention settings, the performance of TID plummets, but proposed optimization FairTID sustains the performance. The experiments measured an improvement of up to 60% from Bamboo with the proposed method.

This paper presents Scalar DL, a Byzantine fault detection (BFD) middleware for transactional database systems. Scalar DL manages two separately administered database replicas in a database system and can detect Byzantine faults in the database system as long as either replica is honest (not faulty). Unlike previous BFD works, Scalar DL executes non-conflicting transactions in parallel while preserving a correctness guarantee. Moreover, Scalar DL is database-agnostic middleware so that it achieves the detection capability in a database system without either modifying the databases or using database-specific mechanisms. Experimental results with YCSB and TPC-C show that Scalar DL outperforms a state-of-the-art BFD system by 3.5 to 10.6 times in throughput and works effectively on multiple database implementations. We also show that Scalar DL achieves near-linear (91%) scalability when the number of nodes composing each replica increases.

Most recommendation systems excessively pursue the recommendation accuracy and give rise to over-specialization. However, the existing recommendation systems research has not studied serendipity much. Hence, the serendipitous item recommendation has received more attention in recent years. The serendipitous recommendation of our research is not included in the area that the user predict easily but recommends the keywords that match the potential preferences. Potential preferences are those that are present in the user profile, which the user may not know. In this research, we recommend keywords that can express serendipity by intersecting the relation between keywords mainly. Furthermore, we propose the related page recommendation method on Web IndeX System for recommending linked pages related to these serendipitous keywords based on the user's potential preferences.

Web Index (WIX in short) is a system that achieves joining information resources on the Web. WIX replaces keywords in Web documents hyperlinks to other web pages based on a WIX file that a user chose. WIX file is a kind of a dictionary that have a set of WIX entries (keyword and target URL). Using WIX, users can join any Web contents and arbitrary dictionaries. In conventional WIX, matching and linking are executed only for fixed character strings between the keyword set and the input text. However, when a user wants to search for phrases like idioms, this matching system is not sufficient because of the declension of words, change of the verb tense, and so on. Therefore, we propose a phrasal pattern matching mechanism on WIX. This helps users easily find idiom expressions in the text on the web and get more information.

Manually managing IO workloads and performance in consolidated VM environments is often difficult and error prone. Thus, automated IO workload (re) placement using virtual disk migration is a key functionality of large scale VM infrastructure. A promising approach is to place IO workloads based on predicted IO latencies, but previous prediction models are often inaccurate due to dependence on there being only a linear relationship between workload parameters and IO latency. This paper presents a new accurate IO latency prediction model for use in automated load balancing. Our experiments show that our model improves relative error ratio of IO latency prediction by 67% for SSDs and 43% for HDDs on average. We also evaluate how the improvement of IO latency prediction affects actual load balancing and overall IO performance. Contrary to our expectation, we find that the significant improvement of IO latency prediction accuracy does not translate into significant overall performance improvement.