You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
rocksdb/utilities/persistent_cache/block_cache_tier_metadata.h

128 lines
3.5 KiB

// Copyright (c) 2013, Facebook, Inc. All rights reserved.
// This source code is licensed under the BSD-style license found in the
// LICENSE file in the root directory of this source tree. An additional grant
// of patent rights can be found in the PATENTS file in the same directory.
// This source code is also licensed under the GPLv2 license found in the
// COPYING file in the root directory of this source tree.
#pragma once
#ifndef ROCKSDB_LITE
#include <functional>
#include <string>
#include <unordered_map>
#include "rocksdb/slice.h"
#include "utilities/persistent_cache/block_cache_tier_file.h"
#include "utilities/persistent_cache/hash_table.h"
#include "utilities/persistent_cache/hash_table_evictable.h"
#include "utilities/persistent_cache/lrulist.h"
namespace rocksdb {
//
// Block Cache Tier Metadata
//
// The BlockCacheTierMetadata holds all the metadata associated with block
// cache. It
// fundamentally contains 2 indexes and an LRU.
//
// Block Cache Index
//
// This is a forward index that maps a given key to a LBA (Logical Block
// Address). LBA is a disk pointer that points to a record on the cache.
//
// LBA = { cache-id, offset, size }
//
// Cache File Index
//
// This is a forward index that maps a given cache-id to a cache file object.
// Typically you would lookup using LBA and use the object to read or write
struct BlockInfo {
explicit BlockInfo(const Slice& key, const LBA& lba = LBA())
: key_(key.ToString()), lba_(lba) {}
std::string key_;
LBA lba_;
};
class BlockCacheTierMetadata {
public:
explicit BlockCacheTierMetadata(const uint32_t blocks_capacity = 1024 * 1024,
const uint32_t cachefile_capacity = 10 * 1024)
: cache_file_index_(cachefile_capacity), block_index_(blocks_capacity) {}
virtual ~BlockCacheTierMetadata() {}
// Insert a given cache file
bool Insert(BlockCacheFile* file);
// Lookup cache file based on cache_id
BlockCacheFile* Lookup(const uint32_t cache_id);
// Insert block information to block index
BlockInfo* Insert(const Slice& key, const LBA& lba);
// bool Insert(BlockInfo* binfo);
// Lookup block information from block index
bool Lookup(const Slice& key, LBA* lba);
// Remove a given from the block index
BlockInfo* Remove(const Slice& key);
// Find and evict a cache file using LRU policy
BlockCacheFile* Evict();
// Clear the metadata contents
virtual void Clear();
protected:
// Remove all block information from a given file
virtual void RemoveAllKeys(BlockCacheFile* file);
private:
// Cache file index definition
//
// cache-id => BlockCacheFile
struct BlockCacheFileHash {
uint64_t operator()(const BlockCacheFile* rec) {
return std::hash<uint32_t>()(rec->cacheid());
}
};
struct BlockCacheFileEqual {
uint64_t operator()(const BlockCacheFile* lhs, const BlockCacheFile* rhs) {
return lhs->cacheid() == rhs->cacheid();
}
};
typedef EvictableHashTable<BlockCacheFile, BlockCacheFileHash,
BlockCacheFileEqual>
CacheFileIndexType;
// Block Lookup Index
//
// key => LBA
struct Hash {
size_t operator()(BlockInfo* node) const {
return std::hash<std::string>()(node->key_);
}
};
struct Equal {
size_t operator()(BlockInfo* lhs, BlockInfo* rhs) const {
return lhs->key_ == rhs->key_;
}
};
typedef HashTable<BlockInfo*, Hash, Equal> BlockIndexType;
CacheFileIndexType cache_file_index_;
BlockIndexType block_index_;
};
} // namespace rocksdb
#endif