Sangjin Lee

We propose ScaleDefrag , a parallel and asynchronous defragmentation tool that reduces defragmentation time by up to 3.8× compared to e4defrag , while improving scalability on multi-core systems. Flash-based solid-state drives (SSDs) have been widely adopted in various large-scale storage systems including cloud and HPC environments. Unfortunately, even with high-performance flash-based SSDs, intensive file modifications can provoke file fragmentation by scattering file data across non-contiguous blocks and splits large requests into several smaller I/O requests, which degrades performance. To address this fragmentation issue, the defragmentation technique gathers the scattered blocks into contiguous space. However, the current technique does not scale well since the defragmentation process is performed by a single defragger sequentially and synchronously. ScaleDefrag scales the defragmentation process as follows. Specifically, we first devise an information collector that gathers metadata for all target files before parallel defragmentation. Second, to realize parallel defragmentation, we devise multiple defraggers with the previously collected file information, enabling a one-to-one (defragger-to-file) model. Finally, we adopt an asynchronous I/O strategy to enable each defragger to issue multiple requests for the scattered blocks and complete them asynchronously. We implement ScaleDefrag and evaluate its performance on a multi-core machine with a flash-based SSD. Our evaluation results on a commodity SSD show that ScaleDefrag reduces defragmentation time and increases defragmentation throughput across various workloads, while also mitigating the slowdown experienced by a co-running application compared with e4defrag .

This paper proposes ScaleOPT, a scalable optimal page replacement policy (OPT) simulator by leveraging multi-core parallelism. Specifically, we first propose AccessMap which enables calculating the next reference time of the accessed page in a constant time by collecting the future references of pages in parallel before the OPT simulation. Second, we introduce Pipelined-Tree consisting of multiple trees which organize caches based on min-max reference times. It enables traverse and update operations of each cache to be performed in a partially parallel manner (i.e., pipelined), thereby scaling out the OPT simulation on multi-cores. The experimental results demonstrate that ScaleOPT improves the simulation time on a 72-core machine by 6.3×, 20.5×, and 13.9× compared with the long-established standard algorithm-based simulator along with our AccessMap, and two widely-used cache simulators, respectively.

This paper proposes a scalable optimal page replacement policy (OPT) simulator called ScaleOPT to scale the OPT simulation by leveraging multi-core parallelism. Specifically, we first propose AccessMap which collects the future references of pages in parallel before the OPT simulation. It enables calculating the next reference time of the accessed page in a constant time. Second, we introduce Pipelined-Tree consisting of multiple trees which organize caches based on min-max reference times. It enables traverse and update operations of each cache to be performed in a partially parallel manner (i.e., pipelined), thereby scaling out the OPT simulation on multi-cores. Finally, we implement ScaleOPT with two techniques and evaluate it on a 72-core machine. The experimental results demonstrate that ScaleOPT improves the simulation time by up to 6.3×, 7.7×, 20.5×, and 13.9× compared with the long-established standard algorithm-based simulator along with our AccessMap, a variable-size cache scheme, and two widely-used cache simulators (webcachesim and libCacheSim), respectively.

This paper presents a scalable page cache called ScaleCache for improving SSD scalability. Specifically, we first propose a concurrent data structure of page cache based on XArray (ccXArray) to enable access and update the page cache concurrently. Second, we introduce a direct page flush (dflush) which directly flushes pages to storage devices in a parallel and opportunistic manner. We implement ScaleCache with two techniques in the Linux kernel and evaluate it on a 64-core machine with eight NVMe SSDs. Our evaluations show that ScaleCache improves the performance of Linux file systems by up to 6.81× and 4.50× compared with the existing scheme and scalable scheme for multiple SSDs, respectively.

A blockchain is designed to establish consistent and reliable agreements in an untrusted and decentralized environment. In addition, the blockchain enables transaction processing and the creation of smart contracts. It empowers end users to execute contracts without any intermediate entities. However, there are some issues when it comes to retrieving information, such as the state and history of smart contracts and regular transactions in the blockchain. For example, in a smart contract, user-defined data structures can be used to recall the state of the smart contract for a range query, which can decrease the general performance. In addition, an external database can be required to retrieve regular transactions for range queries, which increases management costs. To achieve this, we propose a new scheme that enables SQL query operations to retrieve a smart contract and regular transaction information within the blockchain system. To achieve this, we combine an embedded relational database with an Ethereum-based blockchain system to provide the SQL query. It enables range queries on smart contracts without requiring user-defined data structures and decreases management costs for regular transactions without any external database. We implement the proposed blockchain system on quorum, which is an Ethereum-based blockchain system. Also, we evaluate the proposed system using a synthetic benchmark. The performance of retrieving smart contract data is improved by up to approximately 22×, with low memory usage compared with the existing system. Moreover, the proposed system demonstrates a similar search performance to the existing system, even when considering external databases in regular transactions.

In-memory databases has emerged as the most favorable modern database replacing with traditional ones to sufficiently handle with storing, retrieving, and processing large collections of data in big data applications. High speed in storing, retrieving, processing of in-memory databases makes itself outperform classic databases and becomes the most prominent database nowadays. However, along with rapid growth of collected data from intensive-workload applications, in-memory databases should achieve an exceptional scalability to deal with the huge amounts of received data. In addition, they must overcome their internal disadvantages regarding to durability and persistence. Epoch-based mechanisms are suitable solutions for scalability, durability, and persistence issues, while maintaining excellent performance in speed of in-memory databases. This study provides a survey of epoch-based in-memory databases in terms of their database management architecture, classification of epoch-based mechanisms used in, and current developments of epoch-based in-memory database systems.