QueryCache.h

Go to the documentation of this file.

/* -*- c++ -*-
 * Copyright (C) 2007-2015 Hypertable, Inc.
 *
 * This file is part of Hypertable.
 *
 * Hypertable is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; version 3 of the
 * License, or any later version.
 *
 * Hypertable is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */

#ifndef Hypertable_RangeServer_QueryCache_h
#define Hypertable_RangeServer_QueryCache_h

#include <Common/Checksum.h>
#include <Common/Mutex.h>

#include <boost/multi_index_container.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/mem_fun.hpp>
#include <boost/multi_index/sequenced_index.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/shared_array.hpp>

#include <algorithm>
#include <cstring>
#include <fstream>
#include <set>

namespace Hypertable {
  using namespace boost::multi_index;


  class QueryCache {

  public:

    class Key {
    public:
      bool operator==(const Key &other) const {
        return memcmp(digest, other.digest, 16) == 0;
      }
      uint64_t digest[2];
    };

    class RowKey {
    public:
      RowKey(const char *t, const char *r) : tablename(t), row(r) {
        hash = fletcher32(t, strlen(t)) ^ fletcher32(r, strlen(r));
      }
      bool operator==(const RowKey &other) const {
        return !strcmp(tablename, other.tablename) && !strcmp(row, other.row);
      }
      const char *tablename;
      const char *row;
      uint32_t hash;
    };

    QueryCache(uint64_t max_memory);

    bool insert(Key *key, const char *tablename, const char *row,
                std::set<uint8_t> &columns, uint32_t cell_count,
                boost::shared_array<uint8_t> &result, uint32_t result_length);

    bool lookup(Key *key, boost::shared_array<uint8_t> &result, uint32_t *lenp,
                uint32_t *cell_count);

    void invalidate(const char * tablename, const char *row, std::set<uint8_t> &columns);

    uint64_t available_memory() {
      std::lock_guard<MutexWithStatistics> lock(m_mutex);
      return m_avail_memory;
    }

    uint64_t memory_used() {
      std::lock_guard<MutexWithStatistics> lock(m_mutex);
      return m_max_memory-m_avail_memory;
    }

    void get_stats(uint64_t *max_memoryp, uint64_t *available_memoryp,
                   uint64_t *total_lookupsp, uint64_t *total_hitsp,
                   int32_t *total_waiters);

    void dump_keys(std::ofstream &out);

  private:

    class QueryCacheEntry {
    public:
      QueryCacheEntry(Key &k, const char *tname, const char *rw,
                      std::set<uint8_t> &column_ids, uint32_t cells,
                      boost::shared_array<uint8_t> &res, uint32_t rlen) :
        key(k), row_key(tname, rw), result(res), result_length(rlen), cell_count(cells) {
        columns.swap(column_ids);
      }
      Key lookup_key() const { return key; }
      RowKey invalidate_key() const { return row_key; }
      void dump() { std::cout << row_key.tablename << ":" << row_key.row << "\n"; }
      Key key;
      RowKey row_key;
      std::set<uint8_t> columns;
      boost::shared_array<uint8_t> result;
      uint32_t result_length;
      uint32_t cell_count;
    };

    struct KeyHash {
      std::size_t operator()(const Key k) const {
        return (std::size_t)k.digest[0];
      }
    };

    struct RowKeyHash {
      std::size_t operator()(const RowKey k) const {
        return k.hash;
      }
    };

    typedef boost::multi_index_container<
      QueryCacheEntry,
      indexed_by<
        sequenced<>,
        hashed_unique<const_mem_fun<QueryCacheEntry, Key,
                      &QueryCacheEntry::lookup_key>, KeyHash>,
        hashed_non_unique<const_mem_fun<QueryCacheEntry, RowKey,
                          &QueryCacheEntry::invalidate_key>, RowKeyHash>
      >
    > Cache;

    typedef Cache::nth_index<0>::type Sequence;
    typedef Cache::nth_index<1>::type LookupHashIndex;
    typedef Cache::nth_index<2>::type InvalidateHashIndex;

    MutexWithStatistics m_mutex;

    Cache m_cache;

    uint64_t m_max_memory {};

    uint64_t m_avail_memory {};
    
    uint64_t m_total_lookup_count {};

    uint64_t m_total_hit_count {};

    uint32_t m_recent_hit_count {};
  };

  typedef std::shared_ptr<QueryCache> QueryCachePtr;


}


#endif // Hypertable_RangeServer_QueryCache_h