With object storage systems being increasingly recognized as a preferred way to expose one's storage infrastructure to the web, the past few years have witnessed an explosion in the acceptance of these systems. Unfortunately, the proliferation of available solutions and the complexity of each individual one, coupled with a lack of dedicated workload, makes it very challenging for one to evaluate and tune the performance of different systems. To help address this problem, we present the Cloud Object Storage Benchmark (COSBench). It is a benchmark tool that we have developed at Intel with the goal of facilitating both performance comparison and system optimization of these systems. In this paper, we describe the design and implementation of this tool, focusing on its extensibility and scalability. In addition, we discuss how people can use this tool to perform system characterization and how the latter can facilitate system comparison and optimization. To demonstrate the value of our tool, we report the results of our experiments conducted on two Swift setups we built in our lab. We also share some of our experiences in turning our setups to achieve higher performance.

With object storage services becoming increasingly accepted as replacements for traditional file or block systems, it is important to effectively measure the performance of these services. Thus people can compare different solutions or tune their systems for better performance. However, little has been reported on this specific topic as yet. To address this problem, we present COSBench (Cloud Object Storage Benchmark), a benchmark tool that we are currently working on in Intel for cloud object storage services. In addition, in this paper, we also share the results of the experiments we have performed so far.

With the fast development of highly-integrated distributed systems (cluster systems), designers face interesting memory hierarchy design choices while attempting to avoid the notorious disk swapping. Swapping to the free remote memory through Memory Collaboration has demonstrated its cost-effectiveness compared to over provisioning the cluster for peak load requirements. Recent memory collaboration studies propose several ways on accessing the under-utilized remote memory in static system configurations, without detailed exploration of the dynamic memory collaboration. Dynamic collaboration is an important aspect given the run-time memory usage fluctuations in clustered systems. Further, as the interest in memory collaboration grows, it is crucial to understand the existing performance bottlenecks, overheads, and potential optimization. In this paper we address these two issues. First, we propose an Autonomous Collaborative Memory System (ACMS) that manages memory resources dynamically at run time to optimize performance. We implement a prototype realizing the proposed ACMS, experiment with a wide range of real-world applications, and show up to 3× performance speedup compared to a non-collaborative memory system without perceivable performance impact on nodes that provide memory. Second, we analyze, in depth, the end-to-end memory collaboration overhead and pinpoint the corresponding bottlenecks.

In today's data center, there is a growing virtualization evolving trend to consolidate multiple servers into a single physical system. New architecture design that couples more and more cores into one processor furthers this trend. However, virtualization also poses new challenges such as lock holder preemption. In this work, we first demonstrate that lock holder preemption could bring dramatic performance degradation in virtualization environment. Then we propose ANOLE, a runtime adaptive lock waiter detection approach for lock holder preemption overhead reduction of MP guests. It leverages the modern hardware feature without any modification to spin lock implementation. ANOLE implements a hyper visor framework to preempt virtual CPUs adaptively and a user agent for guest spin lock profiling on KVM. We present in-depth performance evaluation under different scenarios, covering simple OS workloads, SPECvirt, and windows guest workloads. The experiment results demonstrate the solid performance benefit of ANOLE, it brings up to 50% performance improvement under different usage scenarios, with better lock waiter detection and load balance.

Server consolidation, by running multiple virtual machines on top of a single platform with virtualization, provides an efficient solu-tion to parallelism and utilization of modern multi-core processors system. However, the performance and scalability of server con-solidation solution on modern massive advanced server is not well addressed. In this paper, we conduct a comprehensive study of Xen per-formance and scalability characterization running SPECvirt_sc2010, and identify that large memory and cache footprint, due to the unnecessary high frequent context switch, introduce additional challenges to the system performance and scalability. We propose two optimizations (dynamically-allocable tasklets and context-switch rate controller) to improve the performance. The results show the improved memory and cache efficiency with a reduction of the overall CPI, resulting in an improvement of server consolidation capability by 15% in SPECvirt_sc2010. In the meantime, our optimization achieves an up to 50% acceleration of service response, which greatly improves the QoS of Xen virtualization solution.

A layered depth image (LDI) is a new popular representation and rendering method for objects with complex geometries. Similar to a two-dimensional (2-D) image, the LDI consists of an array of pixels. However, unlike the 2-D image, an LDI pixel has depth information, and there are multiple layers at a pixel location. We develop a novel LDI compression algorithm that handles the multiple layers and the depth coding. The algorithm records the number of LDI layers at each pixel location, and compresses LDI color and depth components separately. For LDI layer with sparse pixels, the data is aggregated and then encoded. An empirical rate-distortion model is used to optimally allocate bits among different components. Compared with the benchmark compression tools such as JPEG-2000 and MPEG-4, our scheme improves the compression performance significantly.

A layered depth image (LDI) is a new popular representation and rendering method for objects with complex geometries. Similar to a 2D image, the LDI consists of an array of pixels. However, unlike the 2D image, an LDI pixel has depth information, and there are multiple layers at a pixel location. In this paper, we develop a novel LDI compression algorithm that handles the multiple layers and the depth coding. The algorithm records the number of LDI layers at each pixel location, and compresses LDI color and depth components separately. For LDI layer with sparse pixels, the data is aggregated and then encoded. An empirical rate-distortion model is used to optimally allocate bits among different components. Compared with benchmark compression tools such as JPEG-2000 and MPEG-4, our scheme improves the compression performance significantly.