Optimized neighbour prefetch and cache for client-server based walkthrough

Data broadcast has been considered a promising way of information dissemination to a massive number of users in a wireless communication environment. Reducing user-waiting time is a major problem in developing a data broadcast system. There are two approaches for this problem; One is to design a broadcast schedule at the server side which reduces the mean response time, and the other is to utilize a local cache at the user side which may respond to a user request instantly. Though these two approaches were addressed separately in the literature, they may be taken jointly for better performance. The performance of system with joint approach depends on several factors such as broadcast schedule, cache size, cache management strategy, etc. In this paper we analyze response time in a data broadcast system with joint approach in which information items are structurally related with each other as in WWW. Based on the worst-case assumption, we derive a lower bound on the system performance for a given set of broadcast schedule, cache size, and cache management strategy. This result will be of help for designing and developing a data broadcast system. We support our analysis by carrying out an extensive simulation on some interesting proposed broadcast schedules and cache management strategies.

Parallel and distributed file systems are widely used to provide high throughput in high-performance computing and Cloud computing systems. To increase the parallelism, I/O requests are partitioned into multiple sub-requests (or `flows') and distributed across different data nodes. The performance of file systems is extremely poor if data nodes have highly unbalanced response time. Client-side caching offers a promising direction for addressing this issue. However, current work has primarily used client-side memory as a read cache and employed a write-through policy which requires synchronous update for every write and significantly under-utilizes the client-side cache when the applications are write-intensive. Realizing that the cost of an I/O request depends on the struggler sub-requests, we propose a cost-aware client-side file caching (CCFC) strategy, that is designed to cache the sub-requests with high I/O cost on the client end. This caching policy enables a new trade-off across write performance, consistency guarantee and cache size dimensions. Using benchmark workloads MADbench2, we evaluate our new cache policy alongside conventional write-through. We find that the proposed CCFC strategy can achieve up to 110% throughput improvement compared to the conventional write-through policies with the same cache size on an 85-node cluster.

In this paper, we propose a static cache management policy for RAID architecture which uses an SSD as a disk cache. Because SSD has several drawbacks, dynamic cache management scheme such as LRU can cause serious problem i.e., too much write operations can be occurred in order to contain most recently used data. Frequent write operations on SSD not only slow down the performance but also shorten the lifetime. For this reason, we propose a static cache management policy which takes popularity and size into account. Popular data of some period is copied into SSD and too large files are excluded since too large files can lower the hit ratio. We used real trace to evaluate our scheme and the results showed that write counts are reduced to 1/37 of LRU policy as we desired. Unfortunately, the average hit ratio was lower than LRU policy but when popular data is similar between two periods, our scheme showed better hit ratio than LRU. This implies that our scheme can be used on web server which follows zipf’s distribution and has smooth changing of popular data.

SummaryTo boost input‐output performance, operating systems employ a kernel‐managed caching space called the buffer cache or page cache. Given the limited size of a buffer cache, an effective cache manager is required to decide which blocks should be evicted from the cache. Previous cache managers use historical information to make replacement decisions. However, existing approaches are unable to maximize performance since they rely on limited historical information. Motivated by the limitations of existing solutions, this paper proposes a novel manager called the Pattern‐assisted Adaptive Recency Caching (PARC) manager. PARC simultaneously uses the historical information of recency, frequency, and access patterns to estimate the locality strengths of blocks and, upon a cache miss, evicts the block with the least strength. Specifically, PARC exploits the reference regularities exhibited in past input‐output behaviors to actively and rapidly adapt the recency and frequency information of blocks so as to precisely distinguish blocks with long‐ and short‐term utility. Through comprehensive simulations on a variety of traces of different access patterns, we show that PARC is robust since, except for random workloads where the performance of each cache manager is similar, PARC always outperforms existing solutions.

A dynamic optimizer is a software-based system that performs code modifications at runtime, and several such systems have been proposed over the past several years. These systems typically perform optimization on the level of an instruction trace, and most use caching mechanisms to store recently optimized portions of code. Since the dynamic optimizers produce variable-length code traces that are modified copies of portions of the original executable, a code cache management scheme must deal with the difficult problem of caching objects that vary in size and cannot be subdivided without adding extra jump instructions. Because of these constraints, many dynamic optimizers have chosen unsophisticated schemes, such as flushing the entire cache when it becomes full. Flushing minimizes the overhead of cache management but tends to discard many useful traces. This paper evaluates several alternative cache management schemes that identify and remove only enough traces to make room for a new trace. We find that by treating the code cache as a circular buffer, we can reduce the code cache miss rate by half of that achieved by flushing. Furthermore, this approach adds very little bookkeeping overhead and avoids the problems associated with code cache fragmentation. These characteristics are extremely important in a dynamic system since more complex strategies will do more harm than good if the overhead is too high.

Non-Uniform Cache Access (NUCA) architectures provide a potential solution to reduce the average latency for the last-level-cache (LLC), where the cache is organized into per-core local and remote partitions. Recent research has demonstrated the benefits of cooperative cache sharing among local and remote partitions. However, ignoring cache access patterns of concurrently executing applications sharing the local and remote partitions can cause inter-partition contention that reduces the overall instruction throughput. We propose a dynamic cache management scheme for LLC in NUCA-based architectures, which reduces inter-partition contention. Our proposed scheme provides efficient cache sharing by adapting migration, insertion, and promotion policies in response to the dynamic requirements of the individual applications with different cache access behaviors. Our adaptive cache management scheme allows individual cores to steal cache capacity from remote partitions to achieve better resource utilization. On average, our proposed scheme increases the performance (instructions per cycle) by 28% (minimum 8.4%, maximum 75%) compared to a private LLC organization.

The user-generated podcasting service over mobile opportunistic networks can facilitate the user generated content dissemination while humans are on the move. However, in such a distributed and dynamic network environment, the design of efficient content forwarding and cache management schemes are challenging due to the lack of global podcast channel popularity information at each individual node. We design a distributed reputation system at each node for estimating the global channel popularity information which is significant for forwarding and cache management decision. Our simulation result shows that, compare to history-based rank scheme, our reputation system can significantly improve system performance under community-based random way-point (C-RWP) mobility model and localized channel popularity distribution.

With modern technologies, it is possible to create annotated interactive non-linear videos (a form of hypervideo) for the Web. These videos have a non-linear structure of linked scenes to which additional information (other media like images, text, audio, or additional videos) can be added. A variety of user interactions—like in- and between-scene navigation or zooming into additional information—are possible in players for this type of video. Like linear video, quality of experience (QoE) with annotated hypervideo experiences is tied to the temporal consistency of the video stream at the client end—its flow. Despite its interactive complexity, users expect this type of video experience to flow as seamlessly as simple linear video. However, the added hypermedia elements bog playback engines down. Download and cache management systems address the flow issue, but their effectiveness is tied to numerous questions respecting user requirements, computational strategy, and evaluative metrics. In this work, we (a) define QoE metrics, (b) examine structural and behavioral patterns of interactive annotated non-linear video, (c) propose download and cache management algorithms and strategies, (d) describe the implementation of an evaluative simulation framework, and (e) present the algorithm test results.

This paper proposes a cache management scheme for continuous partial match queries in mobile computing systems. Conventional cache management methods for mobile clients are record ID-based ones. However, since the partial match query is a content-based retrieval, the conventional record ID-based approach cannot properly manage the cache consistency. We show the pr edicate- based approach is an effective cache management in mobile environments.

The continued growth of the World Wide Web necessitates the use of proxy caches to reduce latency, network traffic and Web server loads. These caches utilize a traditional file-based replacement policy such as Least Recently Used (LRU). A file is commonly used as a unit of fetching and replacement. In this research, we propose two new cache management strategies for proxies. Our strategies exploit Web document structure to improve cache performance. The strategies discussed in the thesis, WOLRU and WOLFU, use a Web object that consists of a Web page source file and all of its embedded files, as a unit of fetching and replacement. Since our proposed strategies use a Web object, we first present our study on Web object characterization. This study is based on collected data concerning the size and structure of the Web objects. Then, through a trace-driven simulation based on a number of access logs, we show that WOLRU and WOLFU perform significantly better than their file-based counterparts: LRU and LFU. We also show that WOLRU and WOLFU are simpler in comparison to a number of existing cache management policies available in the literature, and can be implemented on a real system. Insights are presented into system behaviour that includes the effect of cache size on performance and the cost associated with the policies. We also propose a new Web object-based policy to manage the storage system of a proxy cache. We propose two techniques to improve the storage system performance. In the first technique, a Web object is used as a unit for replacement and prefetching between the disk and main memory. The prefetching part improves performance, as most of the files can be provided from the main memory instead of a proxy disk. The second technique stores the Web object members on contiguous disk blocks in order to reduce the disk access time. This in turn reduces the disk response time. We have used trace-driven simulations together with a disk simulator to study the performance improvements that can be obtained with these two techniques. Our results show that a significant performance improvement can be achieved by using these techniques. Most of this performance improvement accrues from the first (i.e., Web object-based prefetching and replacement between disk and main memory). The performance improvement produced by the second (i.e., contiguous allocation of Web object members on disk) is small in comparison.

A dynamic optimizer is a runtime software system that groups a program's instruction sequences into traces, optimizes those traces, stores the optimized traces in a software-based code cache, and then executes the optimized code in the code cache. To maximize performance, the vast majority of the program's execution should occur in the code cache and not in the different aspects of the dynamic optimization system. In the past, designers of dynamic optimizers have used the SPEC2000 benchmark suite to justify their use of simple code cache management schemes. In this paper, we show that the problem and importance of code cache management changes dramatically as we move from SPEC2000, with its relatively small number of dynamically generated code traces, to large interactive Windows applications. We also propose and evaluate a new cache management algorithm based on generational code caches that results in an average miss rate reduction of 18% over a unified cache, which translates into 19% fewer instructions spent in the dynamic optimizer. The algorithm categorizes code traces based on their expected lifetimes and group traces with similar lifetimes together in separate storage areas. Using this algorithm, short-lived code traces can easily be removed from a code cache without introducing fragmentation and without suffering the performance penalties associated with evicting long-lived code traces.

Modern GPUs suffer from cache contention due to the limited cache size that is shared across tens of concurrently running warps. To increase the per-warp cache size prior techniques proposed warp throttling which limits the number of active warps. Warp throttling leaves several registers to be dynamically unused whenever a warp is throttled. Given the stringent cache size limitation in GPUs this work proposes a new cache management technique named Linebacker (LB) that improves GPU performance by utilizing idle register file space as victim cache space. Whenever a CTA becomes inactive, linebacker backs up the registers of the throttled CTA to the off-chip memory. Then, linebacker utilizes the corresponding register file space as victim cache space. If any load instruction finds data in the victim cache line, the data is directly copied to the destination register through a simple register-register move operation. To further improve the efficiency of victim cache linebacker allocates victim cache space only to a select few load instructions that exhibit high data locality. Through a careful design of victim cache indexing and management scheme linebacker provides 29.0% of speedup compared to the previously proposed warp throttling techniques.

An effective pre-store/pre-load method exploiting intra-request idle time of NAND flash-based storage devices

For intelligent wide area surveillance, distributed cooperative inference between agents should be provided efficiently. In this paper, efficient cache management model for better context inference based on distributed data infrastructure is investigated. Context aware computing with inference based on ontology is widely used in distributed surveillance environment. However even smart devices, they generally have small memory and power which can manage only part of surveillance data. Higher level inference considering related wide area information can cause huge data transmission. Surveillance data integration merges and aligns ontologies according to the semantic similarity for efficient cooperation. For such a collaborative network, ICN(Information Centric Network) is adopted and an effective cache management scheme that can help the efficient ontology integration. In this paper, we propose an efficient cache management model which is adaptive to the actual device demands. Our scheme shows the efficiency of model resulted in better and efficient context inference.

Limiting the peak power consumption of chip multiprocessors (CMPs) has recently received a lot of attention. In order to enable chip-level power capping, the peak power consumption of on-chip L2 caches in a CMP often needs to be constrained by dynamically transitioning selected cache banks into low-power modes. However, dynamic cache resizing for power capping may cause undesired long cache access latencies, and even thread starving and thrashing, for the applications running on the CMP. In this paper, we propose a novel cache management strategy that can limit the peak power consumption of L2 caches and provide fairness guarantees, such that the cache access latencies of the application threads co-scheduled on the CMP are impacted more uniformly. Our strategy is also extended to provide differentiated cache latency guarantees that can help the OS to enforce the desired thread priorities at the architectural level and achieve desired rates of thread progress for co-scheduled applications. Our solution features a two-tier control architecture rigorously designed based on advanced feedback control theory for guaranteed control accuracy and system stability. Extensive experimental results demonstrate that our solution can achieve the desired cache power capping, fair or differentiated cache sharing, and power-performance tradeoffs for many applications.