tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

hb-cache.hh (4195B)

      1 /*
      2 * Copyright © 2012  Google, Inc.
      3 *
      4 *  This is part of HarfBuzz, a text shaping library.
      5 *
      6 * Permission is hereby granted, without written agreement and without
      7 * license or royalty fees, to use, copy, modify, and distribute this
      8 * software and its documentation for any purpose, provided that the
      9 * above copyright notice and the following two paragraphs appear in
     10 * all copies of this software.
     11 *
     12 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
     13 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
     14 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
     15 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
     16 * DAMAGE.
     17 *
     18 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
     19 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
     20 * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
     21 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
     22 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
     23 *
     24 * Google Author(s): Behdad Esfahbod
     25 */
     26 
     27 #ifndef HB_CACHE_HH
     28 #define HB_CACHE_HH
     29 
     30 #include "hb.hh"
     31 
     32 
     33 /* Implements a lockfree and thread-safe cache for int->int functions,
     34 * using (optionally) _relaxed_ atomic integer operations.
     35 *
     36 * The cache is a fixed-size array of 16-bit or 32-bit integers,
     37 * typically 256 elements.
     38 *
     39 * The key is split into two parts: the cache index (high bits)
     40 * and the rest (low bits).
     41 *
     42 * The cache index is used to index into the array.  The array
     43 * member is a 16-bit or 32-bit integer that is used *both*
     44 * to store the low bits of the key, and the value.
     45 *
     46 * The value is stored in the least significant bits of the integer.
     47 * The low bits of the key are stored in the most significant bits
     48 * of the integer.
     49 *
     50 * A cache hit is detected by comparing the low bits of the key
     51 * with the high bits of the integer at the array position indexed
     52 * by the high bits of the key. If they match, the value is extracted
     53 * from the least significant bits of the integer and returned.
     54 * Otherwise, a cache miss is reported.
     55 *
     56 * Cache operations (storage and retrieval) involve just a few
     57 * arithmetic operations and a single memory access.
     58 */
     59 
     60 template <unsigned int key_bits=16,
     61  unsigned int value_bits=8 + 32 - key_bits,
     62  unsigned int cache_bits=8,
     63  bool thread_safe=true>
     64 struct hb_cache_t
     65 {
     66  using item_t = typename std::conditional<thread_safe,
     67 				   typename std::conditional<key_bits + value_bits - cache_bits <= 8,
     68 							     hb_atomic_t<unsigned char>,
     69 							     typename std::conditional<key_bits + value_bits - cache_bits <= 16,
     70 										       hb_atomic_t<unsigned short>,
     71 										       hb_atomic_t<unsigned int>>::type>::type,
     72 				   typename std::conditional<key_bits + value_bits - cache_bits <= 8,
     73 							     unsigned char,
     74 							     typename std::conditional<key_bits + value_bits - cache_bits <= 16,
     75 										       unsigned short,
     76 										       unsigned int>::type>::type
     77 				  >::type;
     78 
     79  static_assert ((key_bits >= cache_bits), "");
     80  static_assert ((key_bits + value_bits <= cache_bits + 8 * sizeof (item_t)), "");
     81 
     82  static constexpr unsigned MAX_VALUE = (1u << value_bits) - 1;
     83 
     84  hb_cache_t () { clear (); }
     85 
     86  void clear ()
     87  {
     88    for (auto &v : values)
     89      v = -1;
     90  }
     91 
     92  HB_HOT
     93  bool get (unsigned int key, unsigned int *value) const
     94  {
     95    unsigned int k = key & ((1u<<cache_bits)-1);
     96    unsigned int v = values[k];
     97    if ((key_bits + value_bits - cache_bits == 8 * sizeof (item_t) && (item_t) v == (item_t) -1) ||
     98 (v >> value_bits) != (key >> cache_bits))
     99      return false;
    100    *value = v & ((1u<<value_bits)-1);
    101    return true;
    102  }
    103 
    104  HB_HOT
    105  void set (unsigned int key, unsigned int value)
    106  {
    107    if (unlikely ((key >> key_bits) || (value >> value_bits)))
    108      return; /* Overflows */
    109    set_unchecked (key, value);
    110  }
    111 
    112  HB_HOT
    113  void set_unchecked (unsigned int key, unsigned int value)
    114  {
    115    unsigned int k = key & ((1u<<cache_bits)-1);
    116    unsigned int v = ((key>>cache_bits)<<value_bits) | value;
    117    values[k] = v;
    118  }
    119 
    120  private:
    121  item_t values[1u<<cache_bits];
    122 };
    123 
    124 
    125 #endif /* HB_CACHE_HH */