Mailing-List: contact issues-help@hbase.apache.org; run by ezmlm
Precedence: bulk
Date: Thu, 13 Oct 2016 07:34:20 +0000 (UTC)
From: "Eshcar Hillel (JIRA)" <jira@apache.org>
To: issues@hbase.apache.org
Message-ID: <JIRA.12954389.1459277882000.814184.1476344060674@Atlassian.JIRA>
In-Reply-To: <JIRA.12954389.1459277882000@Atlassian.JIRA>
References: <JIRA.12954389.1459277882000@Atlassian.JIRA> <JIRA.12954389.1459277882361@arcas>
Subject: [jira] [Commented] (HBASE-15560) TinyLFU-based BlockCache
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: 7bit
archived-at: Thu, 13 Oct 2016 07:34:23 -0000


    [ https://issues.apache.org/jira/browse/HBASE-15560?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=15571144#comment-15571144 ] 

Eshcar Hillel commented on HBASE-15560:
---------------------------------------

Also, the request distribution is zipfian. Memstore is flushed to disk at 128MB then it is compacted (removing duplicates) and compressed creating a file of 60-80MB ([~ben.manes] you can verify this in your logs), second flush creates a new file; at this point total size of files is more than the cache size. The third flush triggers a compaction resulting in a single file of less than 100MB (again, due to removing duplicates and compression), and so on and so forth.
With 1M operations you have about 6-7 flushes and about 3 compactions on the disk. So about 50% of the execution time data can fit in memory (cache) and 50% of the time it cannot fit into the cache.
I would say this scenario demonstrates the benefit of tinylfu over lru: 90% hit rate vs 85% hit rate, ~30% improvement in mean read latency, and 20-25% improvement in tail latency (95-99th percentiles). 
However, I can't explain the improvement in the update latency. [~ben.manes] can you explain this? Have you ever measured update latency in your previous work? 

> TinyLFU-based BlockCache
> ------------------------
>
>                 Key: HBASE-15560
>                 URL: https://issues.apache.org/jira/browse/HBASE-15560
>             Project: HBase
>          Issue Type: Improvement
>          Components: BlockCache
>    Affects Versions: 2.0.0
>            Reporter: Ben Manes
>            Assignee: Ben Manes
>         Attachments: HBASE-15560.patch, HBASE-15560.patch, HBASE-15560.patch, HBASE-15560.patch, HBASE-15560.patch, HBASE-15560.patch, HBASE-15560.patch, tinylfu.patch
>
>
> LruBlockCache uses the Segmented LRU (SLRU) policy to capture frequency and recency of the working set. It achieves concurrency by using an O( n ) background thread to prioritize the entries and evict. Accessing an entry is O(1) by a hash table lookup, recording its logical access time, and setting a frequency flag. A write is performed in O(1) time by updating the hash table and triggering an async eviction thread. This provides ideal concurrency and minimizes the latencies by penalizing the thread instead of the caller. However the policy does not age the frequencies and may not be resilient to various workload patterns.
> W-TinyLFU ([research paper|http://arxiv.org/pdf/1512.00727.pdf]) records the frequency in a counting sketch, ages periodically by halving the counters, and orders entries by SLRU. An entry is discarded by comparing the frequency of the new arrival (candidate) to the SLRU's victim, and keeping the one with the highest frequency. This allows the operations to be performed in O(1) time and, though the use of a compact sketch, a much larger history is retained beyond the current working set. In a variety of real world traces the policy had [near optimal hit rates|https://github.com/ben-manes/caffeine/wiki/Efficiency].
> Concurrency is achieved by buffering and replaying the operations, similar to a write-ahead log. A read is recorded into a striped ring buffer and writes to a queue. The operations are applied in batches under a try-lock by an asynchronous thread, thereby track the usage pattern without incurring high latencies ([benchmarks|https://github.com/ben-manes/caffeine/wiki/Benchmarks#server-class]).
> In YCSB benchmarks the results were inconclusive. For a large cache (99% hit rates) the two caches have near identical throughput and latencies with LruBlockCache narrowly winning. At medium and small caches, TinyLFU had a 1-4% hit rate improvement and therefore lower latencies. The lack luster result is because a synthetic Zipfian distribution is used, which SLRU performs optimally. In a more varied, real-world workload we'd expect to see improvements by being able to make smarter predictions.
> The provided patch implements BlockCache using the [Caffeine|https://github.com/ben-manes/caffeine] caching library (see HighScalability [article|http://highscalability.com/blog/2016/1/25/design-of-a-modern-cache.html]).
> Edward Bortnikov and Eshcar Hillel have graciously provided guidance for evaluating this patch ([github branch|https://github.com/ben-manes/hbase/tree/tinylfu]).


--
This message was sent by Atlassian JIRA
(v6.3.4#6332)