Non-volatile memory (NVM) is a promising storage technology that combines not only high performance and byte-addressability (like DRAM) but also durability (like SSD). However, as existing relational database management systems (RDBMS) are originally designed based on the assumption that all the data and log are stored on high latency block based devices, they are not able to take full advantage of this new technology yet. Consequently, write operations will under-utilize the device(NVM) and eventually downgrade the performance. In this work, we analyzed the redo-log mechanism in InnoDB and after discovering its severe impact on the overall performance, we decided to perform optimizations that will match with NVM features. We started by re-designing the log write path within InnoDB. After that, we worked on improving the log data access locality and finally, we optimized the write ahead mechanism. NF-log (Non Flushing Log) utilizes the NVM byte addressability and its persistence feature to reduce the write size by 30% and boost up the performance to up to 38% for sysbench write_intensive workloads and up to 16% for TPC-C.

In HPC systems, the increasing need for a higher level of concurrency has led to packing more cores within a single chip. However, since multiple processes share memory space, the frequent access to resources in critical sections where only atomic operations are being executed can result in poor performance. In this paper, we focus on reducing lock contention on the memory management system of an HPC manycore architecture. One of the critical sections causing severe lock contention in the I/O path is in the page management system, which uses multiple Least Recently Used (LRU) lists with a single lock instance. To solve this problem, we propose a Finer-LRU scheme, which optimizes the page reclamation process by splitting LRU lists into multiple sub-lists, each having its own lock instance. Our evaluation result shows that the Finer-LRU scheme can improve sequential write throughput by 57.03% and reduce latency by 98.94% compared to the baseline Linux kernel version 5.2.8 in the Intel Knights Landing (KNL) architecture.

In HPC systems, the increasing need for a higher level of concurrency has led to packing more cores within a single chip. However, since multiple processes share memory space, the frequent access to resources in critical sections where only atomic operation has to be executed can result in poor performance. In this paper, we focus on reducing lock contention on the memory management system of an HPC manycore architecture. One of the critical sections causing severe lock contention in the I/O path is in the page management system, which uses multiple Least Recently Used (LRU) lists with a single lock instance. To solve this problem, we propose a Finer-LRU scheme, which optimizes the page reclamation process by splitting LRU lists into multiple sub-lists, each having its own lock instance. Our evaluation result shows that the Finer-LRU scheme can improve sequential write throughput by 57.03% and reduce latency by 98.94% compared to the baseline Linux kernel version 5.2.8 in the Intel Knights Landing (KNL) architecture.

Recently, graphic processing unit (GPU) multitasking has become important in many platforms since an efficient GPU multitasking mechanism can enable more GPU-enabled tasks running on limited physical GPUs. However, current GPU multitasking technologies, such as NVIDIA Multi-Process Service (MPS) and Hyper-Q may not fully utilize GPU resources since they do not consider the efficient use of intra-GPU resources. In this paper, we present smCompactor, which is a fine-grained GPU multitasking framework to fully exploit intra-GPU resources for different workloads. smCompactor dispatches any particular thread blocks (TBs) of different GPU kernels to appropriate stream multiprocessors (SMs) based on our profiled results of workloads. With smCompactor, GPU resource utilization can be improved as we can run more workloads on a single GPU while their performance is maintained. The evaluation results show that smCompactor improves resource utilization in terms of the number of active SMs by up to 33% and it reduces the kernel execution time by up to 26% compared with NVIDIA MPS.

계산 집약적인 응용을 가속화하기 위해 GPU(Graphics Processing Unit)가 널리 사용됨에 따라 데이터 센터 및 클라우드에서 GPU는 점점 더 많이 활용되고 있다. 여러 응용들의 동시 실행 요청이 있을 때 GPU 자원을 효율적으로 공유하도록 하는 연구는 아직 충분하지 않다. 또한, GPU 내의 자원을 효과적으로 공유하는 것은 응용의 자원 사용 패턴을 인지하지 않고서는 어렵다. 본 논문은 응용의 실행 패턴에 기반한 응용 분류법을 제시하고 자원 할당량 증가에도 성능이 향상되지 않는 이유를 런타임 특성에 따라 설명한다. 또한, 스레드 블록 기반 스케줄링 프레임워크인 smCompactor를 사용하여 분류된 응용을 기반으로 응용 조합의 동시 멀티태스킹 특성을 분석한다. 이를 통해 자원의 효율적인 활용이 가능한 응용의 조합을 파악한다. 응용 실행 특성을 고려하여 GPU상 멀티태스킹 실험을 진행한 결과, 기존 동시 실행 방법인 NVIDIA의 MPS와 비교하여 평균 28% 이상의 성능 향상을 보였다.

Various applications, frameworks, and services are built on Java Virtual Machine (JVM) (e.g., Big data analytics) due to its cross-platform portability. However, many of them suffer from long latency of Garbage Collection (GC) which also drops throughput, efficiency, and availability of the system. For example, when clients demand larger memory than available system memory, Operating System (OS) usually uses its swap space to release the space by evicting some inactive contents stored in memory. In this case, GC latency can be longer due to the I/O time (i.e., swap in/out). In this paper, we present a performance analysis of the existing GC policy in JVM. Based on the result of analysis, we propose an efficient GC scheme to improve the GC performance via swap I/O optimization to complement the existing GC policy. In this scheme, we selectively compact JVM heap by interacting with OS swap system during GC. The experimental results demonstrate that our scheme reduces overall GC overhead by 77.5% and improves the throughput by 82.5% respectively.

The graphics processing unit (GPU) is extensively used in diverse domains, such as finance, machine learning, and image processing. The GPU can be underutilized as multiple applications may not share the same GPU concurrently owing to a memory oversubscription issue. For example, when applications that require fewer computational resources but a larger GPU memory are running instantaneously, the GPU memory may be insufficient; consequently, the number of GPU applications running simultaneously is restricted, decreasing GPU utilization. Further, it can even stop the execution of applications that are running on the GPU. To this end, we propose FlexGPU, which schedules the kernels of the GPU applications that run on the same GPU according to their features. This framework 1) schedules the kernel at the launching time according to its features to improve GPU utilization and 2) temporarily checkpoints and restores non-dependent content in the GPU memory to/from the host memory, which avoids oversubscription of the GPU when out-of-memory failure occurs and allows more kernels to run concurrently on the GPU. The experimental results show that compared to existing methods, our approach demonstrates a 7 times improvement in performance in terms of execution time and enables a 2.5 times increase in the concurrent execution of applications.

Non-volatile random access memory (NVRAM) is a promising approach to persistent data storage with outstanding advantages over traditional storage devices, such as hard disk drives (HDDs) and solid state drives (SSDs). Some of its biggest advantages are its DRAM-like read latency and microsecond-level write latency, which are several hundred times faster than those in the original block device. However, one of the issues with using NVRAM as a storage device is designing an indexing system for its data stores to fully utilize NVRAM characteristics. The state-of-the-art indexing systems of non-volatile key-value stores are usually based on B+-trees or their variants, which were originally designed for block-based storage devices with better sequential performance than random performance. The semantics of B+-tree require data being sorted into leaf nodes and inner nodes and frequent splitting and merging to keep balanced. However, all the sorting, splitting, and merging operations cause extra write to NVRAM, which decreases its performance. In this article, we propose NV-Skiplist, a skiplist-based indexing system for key-value stores on NVRAM that fully uses the features of both NVRAM and DRAM. NV-Skiplist constructs its bottom layer in non-volatile memory to maintain data persistence and support range scans. It builds its upper layers in DRAM to retain rapid index searching and prevent consistently large overhead. We also propose a multiranged variant of NV-Skiplist to increase its search performance and scalability. We evaluate the performance of NV-Skiplist and wB+-tree which is a state-of-art scheme on an NVRAM emulator on a server with an Intel Xeon E5-2620 v2 processor. The results show that our design outperforms the original tree-based, non-volatile key-value stores up to 48%.

Container based virtualization is an innovative technology that accelerates software development by providing portability and maintainability of applications. Recently, a growing number of workloads such as high performance computing (HPC) and Deep Learning(DL) are deployed in the container based environment. However, GPU resource management issues especially the GPU memory over subscription issue in container-based clusters, which brings substantial performance loss, is still challenging. This paper proposes an adaptive fair-share method to share effectively in container-based virtualization environment as well as an execution rescheduling method to manage the execution order of each container for acquiring maximum performance gain. We also proposed a checkpoint based mechanism especially for DL workload running with TensorFlow, which can efficiently solve the GPU memory over subscription problem. We demonstrate that our approach contributes to overall performance improvement as well as higher resource utilization compared to default and static fair-share methods with homogeneous and heterogeneous workloads. Compared to two other conditions, their results show that the proposed method reduces by 16.37%, 15.61% in average execution time and boosts approximately by 52.46%, 10.3% in average GPU memory utilization, respectively. We also evaluated our checkpoint based mechanism by running multiple CNN workloads with TensorFlow at the same time and the result shows our proposed mechanism can ensure each workload executing safely without out of memory (OOM) error occurs.

JVM based Applications usually suffers a severe suspend from the “Stop-The-World” pauses during Garbage Collection(GC). The suspend time could even be much longer when some of the GC targets are systematically swapped out to a permanent storage device. Additionally, we discovered that the default Parallel-Compact GC policy shifts contents that are not GC targets to reduce segmentations, which make the situation worse if these contents have been already swapped out to slow devices such as HDD. We present a new garbage collect policy that can recognize the swapped out contents and will remove them from the shifting targets. From our demonstrative experiment, the new policy can theoretically reduce the latency of collecting 10 GiB contents from 671s to 190s.

In this paper, we present OS I/O path optimizations for NAND flash solid-state drives, aimed to minimize scheduling delays caused by additional contexts such as interrupt bottom halves and background queue runs. With our optimizations, these contexts are eliminated and merged into hardware interrupts or I/O participating threads without introducing side effects. This was achieved by pipelining fine grained host controller operations with the cooperation of I/O participating threads. To safely expose fine grained host controller operations to upper layers, we present a low level hardware abstraction layer interface. Evaluations with micro-benchmarks showed that our optimizations were capable of accommodating up to five, AHCI controller attached, SATA 3.0 SSD devices at 671k IOPS, while current Linux SCSI based I/O path was limited at 354k IOPS failing to accommodate more than three devices. Evaluation on an SSD backed key value system also showed IOPS improvement using our I/O optimizations.

Increasingly, smart phones are becoming one of the most popular mobile devices in personal computing environment. As the need for a variety of mobile applications is increasing, the target mobile platform is a primary concern for mobile application developers. To reduce design complexity for different platforms and enhance the compatibility of applications on various mobile OSes, a JavaScript-based web environment became a main target framework for smart phone applications. Computing-intensive and rich graphics-based applications in a smart phone may fully utilize the CPU, and consume a large amount of the battery power accordingly. In this paper, we propose PIOS, a platform-independent offloading system, which is a delegated system for a mobile web environment. Our evaluation shows that PIOS increases the response time of the application, and reduces power consumption of the device. Our web-based offloading architecture creates a new mobile computing environment.

Increasingly, smartphones are becoming one of the most popular mobile devices in the personal computing environment. As the need for a variety of mobile applications increases, the target mobile platform is a primary concern for mobile application developers. To reduce design complexity for different platforms and enhance the compatibility of applications on various mobile OSes, a JavaScript-based web environment became a main target framework for smartphone applications. Two particular characteristics of a smartphone are restricted power supply and low-end hardware resources, compared to high-end servers. Computing-intensive and rich graphics-based applications in a smartphone may fully utilize the CPU and consume a large amount of the battery power accordingly.In this paper, we propose a platform-independent mobile offloading system, which is a delegated system for a web centric devices environment. Our offloading architecture uses a built-in proxy system that splits the original JavaScript-based application codes into the following two parts: a lightweight code for the mobile client and a computationally heavy code that runs on the server system. We adopt one of the web applications utilizing a combinatory search for our case study. Our evaluation shows that our mobile offloading system reduces the response time of the application running in the web browser and enables a high workload application to run on relatively low-end mobile devices. In addition, this method reduces power consumption of the device. Therefore, this web-based offloading architecture creates a new mobile computing environment and supports various OS platforms of mobile clients.

As the popularity of mobile devices increase, more and more smart phones are being utilized as main computing devices in recent years. Applications for mobile devices have been widely developing even more prevalent than those for PCs. Most mobile applications also integrate with web browsers, with JavaScript serving as an important framework for web-based mobile applications. However, these applications require great amounts of computational power and energy. In addition, relatively low-end mobile devices that pose some limitations in supporting complicated web resource are widely used in developing countries. In this paper, we propose SOME architecture, which is an offloading system for mobile applications, in an effort to reduce the computational cost of mobile devices. We design and implement a delegated system that splits the original JavaScript-based application codes into two parts: a lightweight code for the client and a computationally heavy code to run on a server machine. In our evaluation, our system shows better performance in casual turn-based applications. Overall, the SOME architecture creates a new mobile computing environment that increases the total performance and overcomes resource limitation without platform dependence of mobile clients.