Search

In server consolidation environments, co-locating I/O-intensive and other workloads on a single physical machine often leads to significant performance degradation for memory-intensive workloads due to the memory copies required during copy-based I/O (buffered I/O) operations. Zero-copy I/O has been proposed as a solution to this problem by eliminating unnecessary memory copying between user space and kernel space, thereby improving performance. However, existing zero-copy I/O schemes fail to provide both transparent copy avoidance via standard read/write system calls and the benefits of kernel-level caching, which limits their general applicability. We introduce the z-READ framework, a solution that enables transparent zero-copy read I/O operations while leveraging kernel-level caching. It addresses two primary practical challenges: minimizing page remapping overhead by reducing the number of TLB shootdowns, and ensuring robust I/O performance under high copy-on-write fault conditions using adaptive hybrid I/O mode switching based on a performance loss model and historical I/O patterns. We implement a z-READ prototype on Linux Kernel 4.12.9 and conduct extensive evaluations. Our results demonstrate that, while traditional copy-based I/O configurations in co-located environments lead to an average performance slowdown of 84% for memory-intensive workloads, z-READ restricts this impact to only an 11% average slowdown.

Solid-state drives (SSDs) are widely adopted in mobile devices, desktop PCs, and data centers since they offer higher throughput, lower latency, and lower power consumption to modern computing systems and applications compared with hard disk drives (HDDs). However, the performance of the SSDs can be degraded depending on the I/O access pattern due to the unique characteristics of SSDs. For example, random I/O operation degrades the SSD performance since it reduces the spatial locality and induces garbage collection (GC) overhead. In this paper, we present an address reshaping scheme in a virtual file system (VFS) called sVFS for improving performance and easy deployment. To do this, it first sequentializes a random access pattern in the VFS layer which is an abstract layer on top of a more concrete file system. Thus, our scheme is independent and easily deployed on any concrete file systems, block layer configuration (e.g., RAID), and devices. Second, we adopt a mapping table for managing sequentialized addresses, which guarantees correct read operations. Third, we support transaction processing for updating the mapping table to avoid sacrificing the consistency. We implement our scheme at the VFS layer in Linux kernel 5.15.34. The evaluation results show that our scheme improve the random write throughput by up to 27%, 36%, 34%, and 2.35× using the microbenchmark and 25%, 22%, 20%, and 3.51× using the macrobenchmark compared with the existing scheme in the case of EXT4, F2FS, XFS, and BTRFS, respectively.

Abstract Large-scale high performance computing (HPC) systems typically consist of many thousands of CPUs and storage units used by hundreds to thousands of users simultaneously. Applications from large numbers of users have diverse characteristics, such as varying computation, communication, memory, and I/O intensity. A good understanding of the performance characteristics of each user application is important for job scheduling and resource provisioning. Among these performance characteristics, I/O performance is becoming increasingly important as data sizes rapidly increase and large-scale applications, such as simulation and model training, are widely adopted. However, predicting I/O performance is difficult because I/O systems are shared among all users and involve many layers of software and hardware stack, including the application, network interconnect, operating system, file system, and storage devices. Furthermore, updates to these layers and changes in system management policy can significantly alter the I/O behavior of applications and the entire system. To improve the prediction of the I/O performance on HPC systems, we propose integrating information from several different system logs and developing a regression-based approach to predict the I/O performance. Our proposed scheme can dynamically select the most relevant features from the log entries using various feature selection algorithms and scoring functions, and can automatically select the regression algorithm with the best accuracy for the prediction task. The evaluation results show that our proposed scheme can predict the write performance with up to 90% prediction accuracy and the read performance with up to 99% prediction accuracy using the real logs from the Cori supercomputer system at NERSC.

As the importance of data increases, data is continuously collected from diverse sources such as sensors, IoT devices, and edge computing devices. To manage these continuously monitored data, it is often organized chronologically with time which is referred as time-series data. By managing the data using time, data from different streams can be analyzed in a comprehensive manner with an identical index which is time. However, due to the unique characteristics of time-series data, it is essential for the underlying database systems to understand the characteristics of the time-series data. To handle this, time-series database systems, which specially target time-series data, are emerging. These database systems have different performance characteristics due to the unique characteristics of the data which should be investigated to efficiently store and analyze the data. In this paper, we analyze the time-series database from the perspective of I/O using various storage devices from HDD, SATA and NVMe SSD. First, we analyze the I/O characteristics such as runtime, throughput and size of total requests using various storage devices. In addition, we analyze the effect of unique time-series database features such as data chunk interval, compression and number of workers. Our analysis results show that adapting high-performance devices can greatly improve the performance of the database by up to $33.22\times $ .

The Internet of Things (IoT) has been a critical and emerging technology platform enabling the development and deployment of smart devices to solve real-world challenges and issues. In addition, IoT applications have gathered various and numerous data from various sources, such as sensor data from IoT devices, system data, status information of IoT devices, and others. However, the quality of sensor data should be thoroughly verified to exploit the benefits of sensor data fully. Due to the importance of sensor data quality, we comprehensively provide a survey on the verification of IoT sensor data in this paper. Thus, we conduct a survey of sensor data verification in IoT regarding six aspects. We focus on: 1) anomaly classification; 2) sensor data verification frameworks; 3) sensor data verification methods (including anomaly detection and anomaly correction); 4) evaluation methods to assess sensor data verification methods; 5) technology and tools to build sensor data verification systems; and 6) challenges and future research directions. In addition, we identify advantages and disadvantages of the methods in anomaly detection and correction. Hence, this survey provides a comprehensive and better understanding of sensor data verification in IoT, building background knowledge in related topics.

InterPlanetary File System (IPFS) is a peer-to-peer (P2P) distributed file system that allows data to be shared and exchanged between connected nodes. Recently, IPFS aims to replace existing protocols used in a centralized system (e.g., HTTP) by overcoming their weaknesses such as a single point of failure and arbitrary control. However, we observe that the performance of IPFS is worse as the data size increases since it demands large numbers of storage and network I/O operations. In this paper, we present an efficient data transmission scheme in IPFS called IPFSz to improve the I/O performance of IPFS. To do this, we extend IPFS by enabling real-time compression functionality while maintaining its existing operations in IPFS. In IPFSz, we compress/decompress the data during I/O operations by using a compression algorithm, manage the states of data (e.g., compressed or decompressed), and provide a compression/decompression interface to applications. Thus, IPFSz can reduce the number of storage and network I/O operations and storage space without sacrificing the integrity of the existing IPFS. We have implemented and evaluated IPFSz on five Amazon EC2 nodes. The experimental results show that IPFSz provides higher performance by up to $7.9\times $ and saves the storage space by up to $6.3\times $ compared with existing IPFS.

Recently, flash-based solid-state drives (SSDs) are widely used in industry and academia due to their higher bandwidth and lower latency compared with traditional hard disk drives (HDDs). Furthermore, SSDs with the Non-Volatile Memory Express (NVMe) interface can provide higher performance and ultra-low latency compared with the Serial AT Attachment (SATA) SSDs. Due to their high performance, NVMe SSDs are adopted in many systems as fast storage devices. However, the performance of NVMe SSDs can be negatively affected by I/O access patterns. For example, random write access patterns can have negative impacts on performance due to the unique characteristics of SSDs such as out-of-place update and garbage collection. In this paper, we propose an address remapping scheme to improve the I/O performance of NVMe SSDs. Our proposed scheme transforms random access patterns into sequential access patterns in the NVMe device driver. This allows our scheme to improve the I/O performance of NVMe SSDs while supporting widely used file systems such as EXT4, XFS, BTRFS, and F2FS without any modification to the device. Experimental results show that our proposed scheme can improve the performance of NVMe SSD by up to 64.1% compared with the existing scheme.

Flash-based solid state drives (SSDs) are widely adopted in both industry and the academia since SSDs offer higher performance, lower latency, and lower power consumption compared with traditional hard disk drives (HDDs). Unfortunately, the performance of SSDs can be affected by I/O access patterns. For example, random I/O operation degrades the SSD performance compared with sequential I/O operation since the random I/O operation reduces the spatial locality and increases garbage collection (GC) overhead. To handle this issue, in this article, we propose an efficient block address transformation scheme in the block layer to improve both performance and portability. To do this, we first transform random access patterns to sequential access patterns by sequentializing the block addresses in the block layer. Second, we devise a mapping table for managing transformed block addresses. Third, we support correct read operations and transaction processing for updating the mapping table to avoid sacrificing the consistency. Finally, we provide a cleaning scheme to reclaim invalid data generated by the transformed sequential access. This scheme increases spatial locality, reduces GC overhead, and operates well on any file systems or devices. Experimental results show the proposed scheme improves performance by up to 2x, 1.86x, 2.15x, and 42.8% compared with existing scheme in the case of diverse file systems such as EXT4, XFS, BTRFS, and F2FS, respectively.

As the popularity of e-commerce grows, an electronic coupon (e-coupon) is widely used due to its convenience and portability. In most e-coupon services, the information of e-coupons is managed on a centralized server. However, e-coupon services are often vulnerable to security issues because of centralization. For example, when the e-coupon information which is stored in a centralized e-coupon server is forged, it becomes difficult to match the user and the e-coupon’s owner, and an expired e-coupon can be used repetitively (i.e., double-spending). To handle this issue, we propose a new e-coupon service by exploiting a blockchain system to improve the security of the service. To do this, we first design a server to enable the e-coupon service and communicate with the blockchain system. Second, we devise a smart contract on the blockchain system to provide integrity of the e-coupon business logic and the e-coupon’s information. We implemented the proposed service on an Ethereum-based blockchain system. The experimental results show that our proposed service improves higher security with a minor performance overhead compared with an existing e-coupon service.

Key-Value store (KV store) is becoming widely popular in both academia and industry due to its fast performance and simplicity in data management. To improve the performance of KV stores, recent Serial Advanced Technology Attachment (SATA) and Non-Volatile Memory express (NVMe) Solid-State Drives (SSDs) have been widely adopted. In contrast to the existing Hard-Disk Drives (HDDs), SSDs have unique characteristics which must be carefully considered to exploit the full performance. For example, due to the erase before write constraint, the access pattern of workloads impacts the performance and endurance of SSDs. Thus, the performance of SSD with the sequential workload is higher than that with the random workload. In this paper, we propose a key reshaping technique to improve the performance of KV stores with high performance storage devices. By reshaping keys, our scheme allows KV stores to process the random insert requests into sequential insert requests, improving request processing and Input/Output (I/O) performance. Our experimental results show that the proposed scheme can improve the performance of KV store by up to 106% and 281% compared with the existing scheme, in the case of SATA and NVMe SSDs, respectively.

Solid-state drives (SSDs) have accelerated the architectural evolution of storage systems with several characteristics (e.g., out-of-place update) compared with hard disk drives (HDD). Out-of-place update of SSDs naturally can support transaction mechanism which is commonly used in systems to provide crash consistency. Thus, transactional functionality has been recently implemented inside solid-state drives (SSDs). However, this approach must be re-evaluated for enterprise storage with a standard interface to investigate their benefits in a more realistic and standard fashion. In this article, we explore the implications and challenges of transactional SSDs with different experiments. To evaluate the potential benefit of transactional SSDs, we design and implement the transactional functionality in a Samsung enterprise-class and SATA-based SSD (i.e., SM843TN) called TxSSD. We modify the local file systems (i.e., ext4 and btrfs) and a distributed parallel file system (i.e., Lustre) to utilize TxSSDs. Our modified file systems with TxSSDs provide crash consistency without redundant writes. We evaluate our file systems by using multiple micro and macro benchmarks. We analyze the performance results and demonstrate that TxSSDs may generate an overhead for supporting transactional functionality inside SSD.

Distributed ledger technology faces scalability problems due to a long commit time despite recent successes for cryptocurrency. Small group consensus studies have improved this scalability of distributed ledgers. However, they still have problems of the consensus process itself. For example, most blockchain systems perform serialized block proposal and consensus processing, guarantee the finality with high overhead, and handle byzantine nodes inefficiently. To address these problems, we propose a consensus system, named graph learning byzantine fault tolerance (GL BFT), which offers high parallelism and low latency under Byzantine fault. To do this, we enable a parallel pipelined agreement by separating the block proposal and the consensus process. Second, we devise two techniques of merging blocks and commit learning to guarantee the finality with little overhead. Finally, we present a path learning approach which chooses optimal paths to handle Byzantine fault. The proposed GL BFT can achieve instant finality with low message overhead among a small group of nodes even if Byzantine nodes exit. Also, we evaluate its performance on an open source blockchain protocol. Experimental results show that our design reduces data traffic required by the consensus up to 30%, one transaction is finalized within a few seconds, and optimal performance is maintained.

NAND Flash-based solid-state drives (SSDs) have been widely used as secondary storage devices due to their faster access speed, lower power consumption, and higher reliability compared with hard disk drives. However, application I/O performance can be significantly affected by garbage collection (GC) inside SSDs. For example, a GC operation usually moves valid pages from a victim block into a clean block in a serialized manner. Thus, it increases the GC time and affects the application I/O performance. To address this issue, this article presents a preliminary study on a parallel GC scheme for flash-based SSDs. In our scheme, we parallelize valid page migrations during a GC operation to reduce the total GC time. To do this, we first propose a new flash chip architecture that enables valid page migrations in parallel. Second, we collect information such as new addresses for the migration of valid pages by considering the restriction of SSD operations. Finally, we employ multiple worker threads to migrate the valid pages using the collected information in a parallel manner. We implement and evaluate our scheme using Disksim with Microsoft SSD extension. The experimental result shows that the proposed scheme reduces the overall GC time by 70% and 57% on average compared with the existing scheme and a state-of-the-art GC scheme IPPBE, respectively.

Flash-based solid-state drives (SSD) are being widely adopted in virtualized environments to improve the I/O performance due to their low latency and high throughput compared with existing hard disk drives. In the virtualized environment, the performance of SSDs fluctuates significantly according to the I/O patterns from the virtual machine. For example, random writes have a significantly negative impact on the performance of SSDs compared with sequential writes due to the characteristics of SSDs. In this paper, we propose an address reshaping technique for SSDs in the virtualization layer to improve the spatial locality and the performance of random writes. Our scheme transforms random write requests into sequential write requests in the virtualization layer and thus enables the virtualization layer to issue the transformed sequential requests to SSDs. The experimental results show that the optimized scheme improves the performance by up to 97% compared with the existing scheme under random write workloads.

Distributed supercomputing is becoming common in different companies and academia. Most of the parallel computing researchers focused on harnessing the power of commodity processors and even internet computers to aggregate their computation powers to solve computationally complex problems. Using flexible commodity cluster computers for supercomputing workloads over a dedicated supercomputer and expensive high-performance computing (HPC) infrastructure is cost-effective. Its scalable nature can make it better employed to the available organizational resources, which can benefit researchers who aim to conduct numerous repetitive calculations on small to large volumes of data to obtain valid results in a reasonable time. In this paper, we design and implement an HPC-based supercomputing facility from commodity computers at an organizational level to provide two separate implementations for cluster-based supercomputing using Hadoop and Spark-based HPC clusters, primarily for data-intensive jobs and Torque-based clusters for Multiple Instruction Multiple Data (MIMD) workloads. The performance of these clusters is measured through extensive experimentation. With the implementation of the message passing interface, the performance of the Spark and Torque clusters is increased by 16.6% for repetitive applications and by 73.68% for computation-intensive applications with a speedup of 1.79 and 2.47 respectively on the HPDA cluster. We conclude that the specific application or job could be chosen to run based on the computation parameters on the implemented clusters.