Summary: add class SimCache(base class with instrumentation api) and SimLRUCache(derived class with detailed implementation) which is used as an instrumented block cache that can predict hit rate for different cache size Test Plan: Add a test case in `db_block_cache_test.cc` called `SimCacheTest` to test basic logic of SimCache. Also add option `-simcache_size` in db_bench. if set with a value other than -1, then the benchmark will use this value as the size of the simulator cache and finally output the simulation result. ``` [gzh@dev9927.prn1 ~/local/rocksdb] ./db_bench -benchmarks "fillseq,readrandom" -cache_size 1000000 -simcache_size 1000000 RocksDB: version 4.8 Date: Tue May 17 16:56:16 2016 CPU: 32 * Intel(R) Xeon(R) CPU E5-2660 0 @ 2.20GHz CPUCache: 20480 KB Keys: 16 bytes each Values: 100 bytes each (50 bytes after compression) Entries: 1000000 Prefix: 0 bytes Keys per prefix: 0 RawSize: 110.6 MB (estimated) FileSize: 62.9 MB (estimated) Write rate: 0 bytes/second Compression: Snappy Memtablerep: skip_list Perf Level: 0 WARNING: Assertions are enabled; benchmarks unnecessarily slow ------------------------------------------------ DB path: [/tmp/rocksdbtest-112628/dbbench] fillseq : 6.809 micros/op 146874 ops/sec; 16.2 MB/s DB path: [/tmp/rocksdbtest-112628/dbbench] readrandom : 6.343 micros/op 157665 ops/sec; 17.4 MB/s (1000000 of 1000000 found) SIMULATOR CACHE STATISTICS: SimCache LOOKUPs: 986559 SimCache HITs: 264760 SimCache HITRATE: 26.84% [gzh@dev9927.prn1 ~/local/rocksdb] ./db_bench -benchmarks "fillseq,readrandom" -cache_size 1000000 -simcache_size 10000000 RocksDB: version 4.8 Date: Tue May 17 16:57:10 2016 CPU: 32 * Intel(R) Xeon(R) CPU E5-2660 0 @ 2.20GHz CPUCache: 20480 KB Keys: 16 bytes each Values: 100 bytes each (50 bytes after compression) Entries: 1000000 Prefix: 0 bytes Keys per prefix: 0 RawSize: 110.6 MB (estimated) FileSize: 62.9 MB (estimated) Write rate: 0 bytes/second Compression: Snappy Memtablerep: skip_list Perf Level: 0 WARNING: Assertions are enabled; benchmarks unnecessarily slow ------------------------------------------------ DB path: [/tmp/rocksdbtest-112628/dbbench] fillseq : 5.066 micros/op 197394 ops/sec; 21.8 MB/s DB path: [/tmp/rocksdbtest-112628/dbbench] readrandom : 6.457 micros/op 154870 ops/sec; 17.1 MB/s (1000000 of 1000000 found) SIMULATOR CACHE STATISTICS: SimCache LOOKUPs: 1059764 SimCache HITs: 374501 SimCache HITRATE: 35.34% [gzh@dev9927.prn1 ~/local/rocksdb] ./db_bench -benchmarks "fillseq,readrandom" -cache_size 1000000 -simcache_size 100000000 RocksDB: version 4.8 Date: Tue May 17 16:57:32 2016 CPU: 32 * Intel(R) Xeon(R) CPU E5-2660 0 @ 2.20GHz CPUCache: 20480 KB Keys: 16 bytes each Values: 100 bytes each (50 bytes after compression) Entries: 1000000 Prefix: 0 bytes Keys per prefix: 0 RawSize: 110.6 MB (estimated) FileSize: 62.9 MB (estimated) Write rate: 0 bytes/second Compression: Snappy Memtablerep: skip_list Perf Level: 0 WARNING: Assertions are enabled; benchmarks unnecessarily slow ------------------------------------------------ DB path: [/tmp/rocksdbtest-112628/dbbench] fillseq : 5.632 micros/op 177572 ops/sec; 19.6 MB/s DB path: [/tmp/rocksdbtest-112628/dbbench] readrandom : 6.892 micros/op 145094 ops/sec; 16.1 MB/s (1000000 of 1000000 found) SIMULATOR CACHE STATISTICS: SimCache LOOKUPs: 1150767 SimCache HITs: 1034535 SimCache HITRATE: 89.90% ``` Reviewers: IslamAbdelRahman, andrewkr, sdong Reviewed By: sdong Subscribers: MarkCallaghan, andrewkr, dhruba, leveldb Differential Revision: https://reviews.facebook.net/D57999main
Aaron Gao
8 years ago
parent
d379d110ee
commit
5d660258e7
@ -0,0 +1,67 @@ |
||||
// Copyright (c) 2011-present, 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.
|
||||
|
||||
#pragma once |
||||
|
||||
#include <stdint.h> |
||||
#include <memory> |
||||
#include <string> |
||||
#include "rocksdb/cache.h" |
||||
#include "rocksdb/slice.h" |
||||
#include "rocksdb/status.h" |
||||
#include "util/lru_cache_handle.h" |
||||
|
||||
namespace rocksdb { |
||||
|
||||
class SimCache; |
||||
|
||||
// For instrumentation purpose, use NewSimCache instead of NewLRUCache API
|
||||
// NewSimCache is a wrapper function returning a SimCache instance that can
|
||||
// have additional interface provided in Simcache class besides Cache interface
|
||||
// to predict block cache hit rate without actually allocating the memory. It
|
||||
// can help users tune their current block cache size, and determine how
|
||||
// efficient they are using the memory.
|
||||
extern std::shared_ptr<SimCache> NewSimCache(std::shared_ptr<Cache> cache, |
||||
size_t sim_capacity, |
||||
int num_shard_bits); |
||||
|
||||
class SimCache : public Cache { |
||||
public: |
||||
SimCache() {} |
||||
|
||||
virtual ~SimCache() {} |
||||
|
||||
// returns the maximum configured capacity of the simcache for simulation
|
||||
virtual size_t GetSimCapacity() const = 0; |
||||
|
||||
// simcache doesn't provide internal handler reference to user, so always
|
||||
// PinnedUsage = 0 and the behavior will be not exactly consistent the
|
||||
// with real cache.
|
||||
// returns the memory size for the entries residing in the simcache.
|
||||
virtual size_t GetSimUsage() const = 0; |
||||
|
||||
// sets the maximum configured capacity of the simcache. When the new
|
||||
// capacity is less than the old capacity and the existing usage is
|
||||
// greater than new capacity, the implementation will purge old entries
|
||||
// to fit new capapicty.
|
||||
virtual void SetSimCapacity(size_t capacity) = 0; |
||||
|
||||
// returns the lookup times of simcache
|
||||
virtual uint64_t get_lookup_counter() const = 0; |
||||
// returns the hit times of simcache
|
||||
virtual uint64_t get_hit_counter() const = 0; |
||||
// returns the hit rate of simcache
|
||||
virtual double get_hit_rate() const = 0; |
||||
// reset the lookup and hit counters
|
||||
virtual void reset_counter() = 0; |
||||
// String representation of the statistics of the simcache
|
||||
virtual std::string ToString() const = 0; |
||||
|
||||
private: |
||||
SimCache(const SimCache&); |
||||
SimCache& operator=(const SimCache&); |
||||
}; |
||||
|
||||
} // namespace rocksdb
|
||||
@ -0,0 +1,71 @@ |
||||
// Copyright (c) 2011-present, 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.
|
||||
//
|
||||
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style license that can be
|
||||
// found in the LICENSE file. See the AUTHORS file for names of contributors.
|
||||
|
||||
#pragma once |
||||
|
||||
#include <cassert> |
||||
#include <cstdint> |
||||
|
||||
#include "port/port.h" |
||||
#include "rocksdb/slice.h" |
||||
|
||||
namespace rocksdb { |
||||
// An entry is a variable length heap-allocated structure.
|
||||
// Entries are referenced by cache and/or by any external entity.
|
||||
// The cache keeps all its entries in table. Some elements
|
||||
// are also stored on LRU list.
|
||||
//
|
||||
// LRUHandle can be in these states:
|
||||
// 1. Referenced externally AND in hash table.
|
||||
// In that case the entry is *not* in the LRU. (refs > 1 && in_cache == true)
|
||||
// 2. Not referenced externally and in hash table. In that case the entry is
|
||||
// in the LRU and can be freed. (refs == 1 && in_cache == true)
|
||||
// 3. Referenced externally and not in hash table. In that case the entry is
|
||||
// in not on LRU and not in table. (refs >= 1 && in_cache == false)
|
||||
//
|
||||
// All newly created LRUHandles are in state 1. If you call LRUCache::Release
|
||||
// on entry in state 1, it will go into state 2. To move from state 1 to
|
||||
// state 3, either call LRUCache::Erase or LRUCache::Insert with the same key.
|
||||
// To move from state 2 to state 1, use LRUCache::Lookup.
|
||||
// Before destruction, make sure that no handles are in state 1. This means
|
||||
// that any successful LRUCache::Lookup/LRUCache::Insert have a matching
|
||||
// RUCache::Release (to move into state 2) or LRUCache::Erase (for state 3)
|
||||
|
||||
struct LRUHandle { |
||||
void* value; |
||||
void (*deleter)(const Slice&, void* value); |
||||
LRUHandle* next_hash; |
||||
LRUHandle* next; |
||||
LRUHandle* prev; |
||||
size_t charge; // TODO(opt): Only allow uint32_t?
|
||||
size_t key_length; |
||||
uint32_t refs; // a number of refs to this entry
|
||||
// cache itself is counted as 1
|
||||
bool in_cache; // true, if this entry is referenced by the hash table
|
||||
uint32_t hash; // Hash of key(); used for fast sharding and comparisons
|
||||
char key_data[1]; // Beginning of key
|
||||
|
||||
Slice key() const { |
||||
// For cheaper lookups, we allow a temporary Handle object
|
||||
// to store a pointer to a key in "value".
|
||||
if (next == this) { |
||||
return *(reinterpret_cast<Slice*>(value)); |
||||
} else { |
||||
return Slice(key_data, key_length); |
||||
} |
||||
} |
||||
|
||||
void Free() { |
||||
assert((refs == 1 && in_cache) || (refs == 0 && !in_cache)); |
||||
(*deleter)(key(), value); |
||||
delete[] reinterpret_cast<char*>(this); |
||||
} |
||||
}; |
||||
|
||||
} // end namespace rocksdb
|
||||
@ -0,0 +1,155 @@ |
||||
// Copyright (c) 2011-present, 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.
|
||||
|
||||
#include "rocksdb/utilities/sim_cache.h" |
||||
#include <atomic> |
||||
|
||||
namespace rocksdb { |
||||
|
||||
namespace { |
||||
// SimCacheImpl definition
|
||||
class SimCacheImpl : public SimCache { |
||||
public: |
||||
// capacity for real cache (ShardedLRUCache)
|
||||
// test_capacity for key only cache
|
||||
SimCacheImpl(std::shared_ptr<Cache> cache, size_t sim_capacity, |
||||
int num_shard_bits) |
||||
: cache_(cache), |
||||
key_only_cache_(NewLRUCache(sim_capacity, num_shard_bits)), |
||||
lookup_times_(0), |
||||
hit_times_(0) {} |
||||
|
||||
virtual ~SimCacheImpl() {} |
||||
virtual void SetCapacity(size_t capacity) override { |
||||
cache_->SetCapacity(capacity); |
||||
} |
||||
|
||||
virtual void SetStrictCapacityLimit(bool strict_capacity_limit) override { |
||||
cache_->SetStrictCapacityLimit(strict_capacity_limit); |
||||
} |
||||
|
||||
virtual Status Insert(const Slice& key, void* value, size_t charge, |
||||
void (*deleter)(const Slice& key, void* value), |
||||
Handle** handle) override { |
||||
// The handle and value passed in are for real cache, so we pass nullptr
|
||||
// to key_only_cache_ for both instead. Also, the deleter function pointer
|
||||
// will be called by user to perform some external operation which should
|
||||
// be applied only once. Thus key_only_cache accepts an empty function.
|
||||
// *Lambda function without capture can be assgined to a function pointer
|
||||
Handle* h = key_only_cache_->Lookup(key); |
||||
if (h == nullptr) { |
||||
key_only_cache_->Insert(key, nullptr, charge, |
||||
[](const Slice& k, void* v) {}, nullptr); |
||||
} else { |
||||
key_only_cache_->Release(h); |
||||
} |
||||
return cache_->Insert(key, value, charge, deleter, handle); |
||||
} |
||||
|
||||
virtual Handle* Lookup(const Slice& key) override { |
||||
inc_lookup_counter(); |
||||
Handle* h = key_only_cache_->Lookup(key); |
||||
if (h != nullptr) { |
||||
key_only_cache_->Release(h); |
||||
inc_hit_counter(); |
||||
} |
||||
return cache_->Lookup(key); |
||||
} |
||||
|
||||
virtual void Release(Handle* handle) override { cache_->Release(handle); } |
||||
|
||||
virtual void Erase(const Slice& key) override { |
||||
cache_->Erase(key); |
||||
key_only_cache_->Erase(key); |
||||
} |
||||
|
||||
virtual void* Value(Handle* handle) override { |
||||
return reinterpret_cast<LRUHandle*>(handle)->value; |
||||
} |
||||
|
||||
virtual uint64_t NewId() override { return cache_->NewId(); } |
||||
|
||||
virtual size_t GetCapacity() const override { return cache_->GetCapacity(); } |
||||
|
||||
virtual bool HasStrictCapacityLimit() const override { |
||||
return cache_->HasStrictCapacityLimit(); |
||||
} |
||||
|
||||
virtual size_t GetUsage() const override { return cache_->GetUsage(); } |
||||
|
||||
virtual size_t GetUsage(Handle* handle) const override { |
||||
return reinterpret_cast<LRUHandle*>(handle)->charge; |
||||
} |
||||
|
||||
virtual size_t GetPinnedUsage() const override { |
||||
return cache_->GetPinnedUsage(); |
||||
} |
||||
|
||||
virtual void DisownData() override { |
||||
cache_->DisownData(); |
||||
key_only_cache_->DisownData(); |
||||
} |
||||
|
||||
virtual void ApplyToAllCacheEntries(void (*callback)(void*, size_t), |
||||
bool thread_safe) override { |
||||
// only apply to _cache since key_only_cache doesn't hold value
|
||||
cache_->ApplyToAllCacheEntries(callback, thread_safe); |
||||
} |
||||
|
||||
virtual void EraseUnRefEntries() override { |
||||
cache_->EraseUnRefEntries(); |
||||
key_only_cache_->EraseUnRefEntries(); |
||||
} |
||||
|
||||
virtual size_t GetSimCapacity() const override { |
||||
return key_only_cache_->GetCapacity(); |
||||
} |
||||
virtual size_t GetSimUsage() const override { |
||||
return key_only_cache_->GetUsage(); |
||||
} |
||||
virtual void SetSimCapacity(size_t capacity) override { |
||||
key_only_cache_->SetCapacity(capacity); |
||||
} |
||||
|
||||
virtual uint64_t get_lookup_counter() const override { return lookup_times_; } |
||||
virtual uint64_t get_hit_counter() const override { return hit_times_; } |
||||
virtual double get_hit_rate() const override { |
||||
return hit_times_ * 1.0f / lookup_times_; |
||||
} |
||||
virtual void reset_counter() override { hit_times_ = lookup_times_ = 0; } |
||||
|
||||
virtual std::string ToString() const override { |
||||
std::string res; |
||||
res.append("SimCache LOOKUPs: " + std::to_string(get_lookup_counter()) + |
||||
"\n"); |
||||
res.append("SimCache HITs: " + std::to_string(get_hit_counter()) + "\n"); |
||||
char buff[100]; |
||||
snprintf(buff, sizeof(buff), "SimCache HITRATE: %.2f%%\n", |
||||
get_hit_rate() * 100); |
||||
res.append(buff); |
||||
return res; |
||||
} |
||||
|
||||
private: |
||||
std::shared_ptr<Cache> cache_; |
||||
std::shared_ptr<Cache> key_only_cache_; |
||||
std::atomic<uint64_t> lookup_times_; |
||||
std::atomic<uint64_t> hit_times_; |
||||
void inc_lookup_counter() { lookup_times_++; } |
||||
void inc_hit_counter() { hit_times_++; } |
||||
}; |
||||
|
||||
} // end anonymous namespace
|
||||
|
||||
// For instrumentation purpose, use NewSimCache instead
|
||||
std::shared_ptr<SimCache> NewSimCache(std::shared_ptr<Cache> cache, |
||||
size_t sim_capacity, int num_shard_bits) { |
||||
if (num_shard_bits >= 20) { |
||||
return nullptr; // the cache cannot be sharded into too many fine pieces
|
||||
} |
||||
return std::make_shared<SimCacheImpl>(cache, sim_capacity, num_shard_bits); |
||||
} |
||||
|
||||
} // end namespace rocksdb
|
||||
@ -0,0 +1,146 @@ |
||||
// Copyright (c) 2011-present, 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.
|
||||
|
||||
#include "rocksdb/utilities/sim_cache.h" |
||||
#include <cstdlib> |
||||
#include "db/db_test_util.h" |
||||
#include "port/stack_trace.h" |
||||
|
||||
namespace rocksdb { |
||||
|
||||
class SimCacheTest : public DBTestBase { |
||||
private: |
||||
size_t miss_count_ = 0; |
||||
size_t hit_count_ = 0; |
||||
size_t insert_count_ = 0; |
||||
size_t failure_count_ = 0; |
||||
|
||||
public: |
||||
const size_t kNumBlocks = 5; |
||||
const size_t kValueSize = 100; |
||||
|
||||
SimCacheTest() : DBTestBase("/sim_cache_test") {} |
||||
|
||||
BlockBasedTableOptions GetTableOptions() { |
||||
BlockBasedTableOptions table_options; |
||||
// Set a small enough block size so that each key-value get its own block.
|
||||
table_options.block_size = 1; |
||||
return table_options; |
||||
} |
||||
|
||||
Options GetOptions(const BlockBasedTableOptions& table_options) { |
||||
Options options = CurrentOptions(); |
||||
options.create_if_missing = true; |
||||
// options.compression = kNoCompression;
|
||||
options.statistics = rocksdb::CreateDBStatistics(); |
||||
options.table_factory.reset(new BlockBasedTableFactory(table_options)); |
||||
return options; |
||||
} |
||||
|
||||
void InitTable(const Options& options) { |
||||
std::string value(kValueSize, 'a'); |
||||
for (size_t i = 0; i < kNumBlocks * 2; i++) { |
||||
ASSERT_OK(Put(ToString(i), value.c_str())); |
||||
} |
||||
} |
||||
|
||||
void RecordCacheCounters(const Options& options) { |
||||
miss_count_ = TestGetTickerCount(options, BLOCK_CACHE_MISS); |
||||
hit_count_ = TestGetTickerCount(options, BLOCK_CACHE_HIT); |
||||
insert_count_ = TestGetTickerCount(options, BLOCK_CACHE_ADD); |
||||
failure_count_ = TestGetTickerCount(options, BLOCK_CACHE_ADD_FAILURES); |
||||
} |
||||
|
||||
void CheckCacheCounters(const Options& options, size_t expected_misses, |
||||
size_t expected_hits, size_t expected_inserts, |
||||
size_t expected_failures) { |
||||
size_t new_miss_count = TestGetTickerCount(options, BLOCK_CACHE_MISS); |
||||
size_t new_hit_count = TestGetTickerCount(options, BLOCK_CACHE_HIT); |
||||
size_t new_insert_count = TestGetTickerCount(options, BLOCK_CACHE_ADD); |
||||
size_t new_failure_count = |
||||
TestGetTickerCount(options, BLOCK_CACHE_ADD_FAILURES); |
||||
ASSERT_EQ(miss_count_ + expected_misses, new_miss_count); |
||||
ASSERT_EQ(hit_count_ + expected_hits, new_hit_count); |
||||
ASSERT_EQ(insert_count_ + expected_inserts, new_insert_count); |
||||
ASSERT_EQ(failure_count_ + expected_failures, new_failure_count); |
||||
miss_count_ = new_miss_count; |
||||
hit_count_ = new_hit_count; |
||||
insert_count_ = new_insert_count; |
||||
failure_count_ = new_failure_count; |
||||
} |
||||
}; |
||||
|
||||
TEST_F(SimCacheTest, SimCache) { |
||||
ReadOptions read_options; |
||||
auto table_options = GetTableOptions(); |
||||
auto options = GetOptions(table_options); |
||||
InitTable(options); |
||||
std::shared_ptr<SimCache> simCache = |
||||
NewSimCache(NewLRUCache(0, 0, false), 10000, 0); |
||||
table_options.block_cache = simCache; |
||||
options.table_factory.reset(new BlockBasedTableFactory(table_options)); |
||||
Reopen(options); |
||||
RecordCacheCounters(options); |
||||
|
||||
std::vector<std::unique_ptr<Iterator>> iterators(kNumBlocks); |
||||
Iterator* iter = nullptr; |
||||
|
||||
// Load blocks into cache.
|
||||
for (size_t i = 0; i < kNumBlocks; i++) { |
||||
iter = db_->NewIterator(read_options); |
||||
iter->Seek(ToString(i)); |
||||
ASSERT_OK(iter->status()); |
||||
CheckCacheCounters(options, 1, 0, 1, 0); |
||||
iterators[i].reset(iter); |
||||
} |
||||
ASSERT_EQ(kNumBlocks, simCache->get_lookup_counter()); |
||||
ASSERT_EQ(0, simCache->get_hit_counter()); |
||||
size_t usage = simCache->GetUsage(); |
||||
ASSERT_LT(0, usage); |
||||
ASSERT_EQ(usage, simCache->GetSimUsage()); |
||||
simCache->SetCapacity(usage); |
||||
simCache->SetSimCapacity(usage * 2); |
||||
ASSERT_EQ(usage, simCache->GetPinnedUsage()); |
||||
|
||||
// Test with strict capacity limit.
|
||||
simCache->SetStrictCapacityLimit(true); |
||||
iter = db_->NewIterator(read_options); |
||||
iter->Seek(ToString(kNumBlocks * 2 - 1)); |
||||
ASSERT_TRUE(iter->status().IsIncomplete()); |
||||
CheckCacheCounters(options, 1, 0, 0, 1); |
||||
delete iter; |
||||
iter = nullptr; |
||||
|
||||
// Release iterators and access cache again.
|
||||
for (size_t i = 0; i < kNumBlocks; i++) { |
||||
iterators[i].reset(); |
||||
CheckCacheCounters(options, 0, 0, 0, 0); |
||||
} |
||||
// Add kNumBlocks again
|
||||
for (size_t i = 0; i < kNumBlocks; i++) { |
||||
std::unique_ptr<Iterator> it(db_->NewIterator(read_options)); |
||||
it->Seek(ToString(i)); |
||||
ASSERT_OK(it->status()); |
||||
CheckCacheCounters(options, 0, 1, 0, 0); |
||||
} |
||||
ASSERT_EQ(5, simCache->get_hit_counter()); |
||||
for (size_t i = kNumBlocks; i < kNumBlocks * 2; i++) { |
||||
std::unique_ptr<Iterator> it(db_->NewIterator(read_options)); |
||||
it->Seek(ToString(i)); |
||||
ASSERT_OK(it->status()); |
||||
CheckCacheCounters(options, 1, 0, 1, 0); |
||||
} |
||||
ASSERT_EQ(0, simCache->GetPinnedUsage()); |
||||
ASSERT_EQ(3 * kNumBlocks + 1, simCache->get_lookup_counter()); |
||||
ASSERT_EQ(6, simCache->get_hit_counter()); |
||||
} |
||||
|
||||
} // namespace rocksdb
|
||||
|
||||
int main(int argc, char** argv) { |
||||
rocksdb::port::InstallStackTraceHandler(); |
||||
::testing::InitGoogleTest(&argc, argv); |
||||
return RUN_ALL_TESTS(); |
||||
} |
||||
Loading…
Reference in new issue