Using the small-world model to improve Freenet performance

Multi-core processors improve performance, but they can create unpredictability owing to shared resources such as caches interfering. Cache partitioning is used to alleviate the Worst-Case Execution Time (WCET) estimation by isolating the shared cache across each thread to reduce interference. It does, however, prohibit data from being transferred between parallel threads running on different cores. In this paper we present (SRCP) a cache replacement mechanism for partitioned caches that is aware of data being shared across threads, prevents shared data from being replicated across partitions and frequently used data from being evicted from caches. Our technique outperforms TA-DRRIP and EHC, which are existing state-of-the-art cache replacement algorithms, by 13.34% in cache hit-rate and 10.4% in performance over LRU (least recently used) cache replacement policy.

Achieving high system execution performance is challenging due to the variety of application features, the erratic nature of memory resources, and the erratic use of the cache application programming interface (API).Ineffective cache replacement procedures can lead to a variety of performance issues, including lengthy application execution times, low memory use, frequent replacements, and even program execution failures owing to memory outages.Spark is presently using the least recently used (LRU) cache refilling technique.Despite being a popular classical strategy, LRU ignores environmental conditions and workloads.It cannot therefore function well in a variety of situations.The model in this paper introduces a new cache replacement technique called least partition weight (LPW).LPW considers several parameters, such as the partition size, computational cost, and reference count, in evaluating the performance of a system.Once the LPW algorithm was integrated into Spark, it was evaluated against the LRU and other cutting-edge methods.The cache replacement model's functionality is substantially improved by the recommended model with the application of auto data division and weighted tree technique.Therefore, the focus of this review paper is on examining previous research to comprehend the cache replacement process and present an improved version of the catch replacement using LPW in conjunction with parallel computation, which will be described in the paper's next edition.

For applications in worst-case execution time analysis and in security, it is desirable to statically classify memory accesses into those that result in cache hits, and those that result in cache misses. Among cache replacement policies, the least recently used (LRU) policy has been studied the most and is considered to be the most predictable. The state-of-the-art in LRU cache analysis presents a tradeoff between precision and analysis efficiency: The classical approach to analyzing programs running on LRU caches, an abstract interpretation based on a range abstraction, is very fast but can be imprecise. An exact analysis was recently presented, but, as a last resort, it calls a model checker, which is expensive. In this paper, we develop an analysis based on abstract interpretation that comes close to the efficiency of the classical approach, while achieving exact classification of all memory accesses as the model-checking approach. Compared with the model-checking approach we observe speedups of several orders of magnitude. As a secondary contribution we show that LRU cache analysis problems are in general NP-complete.

It is estimated that the annual network traffic of the internet will go beyond the threshold. Named Data Network will enter a new era in the world of networks because NDN nodes can store the data that has been requested by consumers in the content store so that one day when the data is requested by another consumer, it will be fast in the distribution of data. There are several optimization techniques based on replacement algorithms, one example is Least Recently Used (LRU), which is more focused on content that is rarely accessed and stores popular content in the content store. But the LRU has a weakness, which is only using the latest reference time and cannot distinguish between frequently or rarely the object being accessed. LRU modification is made to combine frequency and recently files in the decision stage to replace files so that the Modified-LRU can improve performance more optimally. In this paper, it is proposed the Modified-LRU algorithm. Modified-LRU takes an idea of SF-LRU but it is more simple in the process of deleting files. So, it can reduce the processing load. In this paper, the performance of LRU and Modified-LRU are compared. The simulation results show that the Modified-LRU is feasible to improve the LRU performance. The hit ratio is 8.7% greater compared to LRU, reducing delay by 60% and packet drop by 95%.

The increasing popularity of photo sharing in social networking service (SNS) complicates the challenge of storing and transmitting large photo data for SNS providers. Distributed web caches are generally used by SNS providers to improve data transmission performance effectively. Two critical factors affect the efficiency of web caches: storage media and replacement algorithms. Solid-state drive (SSD) is often used in web caches due to its good performance. Random write performance and SSD endurance are directly affected by the characteristic of write amplification, this characteristic is also related to replacement algorithms. The least recently used (LRU) algorithm effectively computes cache hit ratio but induces severe write amplification. First in first out (FIFO) method minimizes write amplification, whereas a weak hit ratio increases bandwidth consumption. In this paper, we present a hybrid replacement strategy, namely, F-SkLRU. This strategy facilitates a good trade-off between performance and the cost of web cache. F-SkLRU takes advantage of sequential writing to reduce SSD wear. This strategy also consolidates multiple factors to improve hit ratio. Simulation results show that F-SkLRU can reduce bandwidth consumption by 14.11% to 23.4% in comparison with that of FIFO and LRU. The proposed strategy can also reduce the cost of SSD by up to 300% more than LRU can in extreme situations.

Caching systems using the Least Recently Used (LRU) principle have now become ubiquitous. A fundamental question for these systems is whether the cache space should be pooled together or divided to serve multiple flows of data item requests in order to minimize the miss probabilities. In this paper, we show that there is no straight yes or no answer to this question, depending on complex combinations of critical factors, including, e.g., request rates, overlapped data items across different request flows, data item popularities and their sizes. To this end, we characterize the performance of multiple flows of data item requests under resource pooling and separation for LRU caching when the cache size is large. Analytically, we show that it is asymptotically optimal to jointly serve multiple flows if their data item sizes and popularity distributions are similar and their arrival rates do not differ significantly; the self-organizing property of LRU caching automatically optimizes the resource allocation among them asymptotically. Otherwise, separating these flows could be better, e.g., when data sizes vary significantly. We also quantify critical points beyond which resource pooling is better than separation for each of the flows when the overlapped data items exceed certain levels. Technically, for a broad class of heavy-tailed distributions we derive the asymptotic miss probabilities of multiple flows of requests with varying data item sizes in a shared LRU cache space. It also validates the characteristic time approximation under certain conditions. These results provide new insights on improving the performance of caching systems.

Caching has been introduced and applied in prototype and commercial Web-based information systems in order to reduce the overall bandwidth and increase system's fault tolerance. This paper presents a track of Web cache replacement algorithms based on the Least Recently Used (LRU) idea. We propose an extension to the conventional LRU algorithm by considering the number of references to Web objects as a critical parameter for the cache content replacement. The proposed algorithms are validated and experimented under Web cache traces provided by a major Squid proxy cache server installation environment. Cache and bytes hit rates are reported showing that the proposed cache replacement algorithms improve cache content.

Caching systems using the Least Recently Used (LRU) principle have now become ubiquitous. A fundamental question for these systems is whether the cache space should be pooled together or divided to serve multiple flows of data item requests in order to minimize the miss probabilities. In this paper, we show that there is no straight yes or no answer to this question, and depends on complex combinations of critical factors, including, e.g., request rates, overlapped data items across different request flows, data item popularities and their sizes. To this end, we characterize the performance of multiple flows of data item requests under resource pooling and separation when the cache size is large. Analytically we show that it is asymptotically optimal to jointly serve multiple flows if their data item sizes and popularity distributions are similar, and their arrival rates do not differ significantly; the self-organizing property of LRU caching automatically optimizes the resource allocation among them asymptotically. Otherwise, separating these flows could be better, e.g., when data sizes vary significantly. We also quantify critical points beyond which resource pooling is better than separation for each of the flows when the overlapped data items exceed certain levels. These results provide new insights on the performance of caching systems.

Caching systems using the Least Recently Used (LRU) principle have now become ubiquitous. A fundamental question for these systems is whether the cache space should be pooled together or divided to serve multiple flows of data item requests in order to minimize the miss probabilities. In this paper, we show that there is no straight yes or no answer to this question, and depends on complex combinations of critical factors, including, e.g., request rates, overlapped data items across different request flows, data item popularities and their sizes. To this end, we characterize the performance of multiple flows of data item requests under resource pooling and separation when the cache size is large. Analytically we show that it is asymptotically optimal to jointly serve multiple flows if their data item sizes and popularity distributions are similar, and their arrival rates do not differ significantly; the self-organizing property of LRU caching automatically optimizes the resource allocation among them asymptotically. Otherwise, separating these flows could be better, e.g., when data sizes vary significantly. We also quantify critical points beyond which resource pooling is better than separation for each of the flows when the overlapped data items exceed certain levels. These results provide new insights on the performance of caching systems.

Support vector machines (SVMs) can solve structured multioutput learning problems such as multilabel classification, multiclass classification, and vector regression. SVM training is expensive, especially for large and high-dimensional data sets. The bottleneck of the SVM training often lies in the kernel value computation. In many real-world problems, the same kernel values are used in many iterations during the training, which makes the caching of kernel values potentially useful. The majority of the existing studies simply adopt the least recently used (LRU) replacement strategy for caching kernel values. However, as we analyze in this article, the LRU strategy generally achieves high hit ratio near the final stage of the training but does not work well in the whole training process. Therefore, we propose a new caching strategy called EFU (less frequently used), which replaces the EFU kernel values that enhance least frequently used (LFU). Our experimental results show that EFU often has 20% higher hit ratio than LRU in the training with the Gaussian kernel. To further optimize the strategy, we propose a caching strategy called hybrid caching for the SVM training (HCST), which has a novel mechanism to automatically adapt the better caching strategy in different stages of the training. We have integrated the caching strategy into ThunderSVM, a recent SVM library on many-core processors. Our experiments show that HCST adaptively achieves high hit ratios with little runtime overhead among different problems including multilabel classification, multiclass classification, and regression problems. Compared with other existing caching strategies, HCST achieves 20% more reduction in training time on average.

The buffer cache plays an essential role in smoothing the gap between the upper level computational components and the lower level storage devices. A good buffer cache management scheme should be beneficial to not only the computational components, but also the storage components by reducing disk I/Os. Existing cache replacement algorithms are well optimized for disks in normal mode, but inefficient under faulty scenarios, such as a parity-based disk array with faulty disk(s). To address this issue, we propose a novel penalty-aware buffer cache replacement strategy, named Victim Disk(s) First (VDF) cache, to improve the reliability and performance of a storage system consisting of a buffer cache and disk arrays. VDF cache gives higher priority to cache the blocks on the faulty disks when the disk array fails, thus reducing the I/Os addressed directly to the faulty disks. To verify the effectiveness of the VDF cache, we have integrated VDF into the popular cache algorithms least frequently used (LFU) and least recently used (LRU), named VDF-LFU and VDF-LRU, respectively. We have conducted intensive simulations as well as a prototype implementation for disk arrays to tolerate one disk failure (RAID-5) and two disk failures (RAID-6). The simulation results have shown that VDF-LFU can reduce disk I/Os to surviving disks by up to 42.3 percent in RAID-5 and 50.7 percent in RAID-6, and VDF-LRU can reduce those by up to 36.2 percent in RAID-5 and 48.9 percent in RAID-6. Our measurement results also show that VDF-LFU can speed up the online recovery by up to 46.3 percent in RAID-5 and 47.2 percent in RAID-6 under spare-rebuilding mode, or improve the maximum system service rate by up to 47.7 percent in RAID-5 under degraded mode without a reconstruction workload. Similarly, VDF-LRU can speed up the online recovery by up to 34.6 percent in RAID-5 and 38.2 percent in RAID-6, or improve the system service rate by up to 28.4 percent in RAID-5.

We consider the problem of on-chip L2 cache management and replacement policies. We propose a new adaptive cache replacement policy, called Dueling CLOCK (DC), that has several advantages over the Least Recently Used (LRU) cache replacement policy.

Virtualization is used for various purposes such as cloud computing and a virtualized environment has been one of the most important platforms. In many virtualized environments, access to its persistent storage device, e.g. hard disk drive (HDD) or solid-state drive (SSD), is performed via two caches, which are page caches of guest and host operating systems. Both caches are usually managed based on the least recently used (LRU) algorithm. Previous work demonstrated that accesses to the host operating system page cache have a negative temporal locality of reference in these cases. Namely, an accessed block will probably not be accessed again in the near future. This locality severely decreases the hit ratio of a host operating system page cache. For addressing this issue, a method for improving the locality of reference in the accesses in the host operating system page cache by fixing data stored in the guest operating system page cache was proposed. However, the method assumed that the hot spot, which is the data area aggressively accessed, was given. Because of this limitation, the method can rarely be used. In this paper, we propose a method for improving the hit ratio of a host operating system page cache by enhancing the locality of reference at the cache. First, we explain the negative temporal locality of reference in virtualized environments. Second, we propose a method for enhancing the locality of reference in the host operating system page cache for improving its hit ratio without an assumption that its hotspot is given. This method observes file accesses in the system using an operating system kernel function and automatically detects the hotspot. This then stores the area in the guest operating system page cache. As a result, the locality of reference in the host operating system cache increases. Lastly, we evaluate this proposed method, then show that this method outperforms the normal method and can provide comparable performance with an existing method even if the hot spot is not given.

With the rapid growth of Internet data, the performance of big data processing platforms is attracting more and more attention. In Spark, cache data are replaced by the Least Recently Used (LRU) Algorithm. LRU cannot identify the cost of cache data, which leads to replacing some important cache data. In addition, the placement of cache data is random, which lacks a measure to find efficient cache servers. Focusing on the above problems, a remote cache management framework (RCM) for the Spark platform was proposed, including a cache weight generation module (CWG), cache replacement module (CREP), and cache placement module (CPL). CWG establishes initial weights from three main factors: the response time of the query database, the number of queries, and the data size. Then, CWG reduces the old data weight through a time loss function. CREP promises that the sum of cache data weights is maximized by a greedy strategy. CPL allocates the best cache server for data based on the Kuhn-Munkres matching algorithm to improve cooperation efficiency. To verify the effectiveness of RCM, RCM is implemented on Redis and deployed on eight computing nodes and four cache servers. Three groups of benchmark jobs, PageRank, K-means and WordCount, is tested. The result of experiments confirmed that compared with MCM, SACM and DMAOM, the execution time of RCM is reduced by 42.1% at most.

Recent studies have shown that, in highly associative caches, the performance gap between the least recently used (LRU) and the theoretical optimal replacement algorithms is large, motivating the design of alternative replacement algorithms to improve cache performance. In LRU replacement, a line, after its last use, remains in the cache for a long time until it becomes the LRU line. Such deadlines unnecessarily reduce the cache capacity available for other lines. In addition, in multilevel caches, temporal reuse patterns are often inverted, showing in the L1 cache but, due to the filtering effect of the L1 cache, not showing in the L2 cache. At the L2, these lines appear to be brought in the cache but are never reaccessed until they are replaced. These lines unnecessarily pollute the L2 cache. This paper proposes a new counter-based approach to deal with the above problems. For the former problem, we predict lines that have become dead and replace them early from the L2 cache. For the latter problem, we identify never-reaccessed lines, bypass the L2 cache, and place them directly in the L1 cache. Both techniques are achieved through a single counter-based mechanism. In our approach, each line in the L2 cache is augmented with an event counter that is incremented when an event of interest such as certain cache accesses occurs. When the counter reaches a threshold, the line ";expires"; and becomes replaceable. Each line's threshold is unique and is dynamically learned. We propose and evaluate two new replacement algorithms: Access interval predictor (AIP) and live-time predictor (LvP). AIP and LvP speed up 10 capacity-constrained SPEC2000 benchmarks by up to 48 percent and 15 percent on average (7 percent on average for the whole 21 Spec2000 benchmarks). Cache bypassing further reduces L2 cache pollution and improves the average speedups to 17 percent (8 percent for the whole 21 Spec2000 benchmarks).