From 47a82288814ed47c8129a5dc924d2a0b8d396ed8 Mon Sep 17 00:00:00 2001 From: sdong Date: Mon, 17 Jul 2017 15:31:03 -0700 Subject: [PATCH] [FB Internal] use gcc-5 --- Makefile | 2 +- build_tools/build_detect_platform | 10 +- build_tools/dependencies.sh | 18 ++++ build_tools/fbcode_config.sh | 147 ++++++++++++++++++++++++++++++ db/db_bench.cc | 22 ++--- db/prefix_test.cc | 2 +- table/table_reader_bench.cc | 4 +- tools/db_repl_stress.cc | 4 +- tools/db_stress.cc | 30 +++--- util/bloom_test.cc | 2 +- util/dynamic_bloom_test.cc | 2 +- 11 files changed, 201 insertions(+), 42 deletions(-) create mode 100644 build_tools/dependencies.sh create mode 100644 build_tools/fbcode_config.sh diff --git a/Makefile b/Makefile index 258b951ae..3e32a6dd0 100644 --- a/Makefile +++ b/Makefile @@ -170,7 +170,7 @@ dbg: $(LIBRARY) $(PROGRAMS) # Will also generate shared libraries. release: $(MAKE) clean - OPT="-DNDEBUG -O2" $(MAKE) all -j32 + OPT="-DNDEBUG -O2" $(MAKE) $(LIBRARY) db_bench sst_dump ldb -j32 coverage: $(MAKE) clean diff --git a/build_tools/build_detect_platform b/build_tools/build_detect_platform index 2ff64afe2..9b3749ddd 100755 --- a/build_tools/build_detect_platform +++ b/build_tools/build_detect_platform @@ -47,13 +47,7 @@ COMMON_FLAGS="-DROCKSDB_PLATFORM_POSIX" if [ -d /mnt/gvfs/third-party -a -z "$CXX" ]; then FBCODE_BUILD="true" if [ -z "$USE_CLANG" ]; then - CENTOS_VERSION=`rpm -q --qf "%{VERSION}" \ - $(rpm -q --whatprovides redhat-release)` - if [ "$CENTOS_VERSION" -ge "6" ]; then - source $PWD/build_tools/fbcode.gcc481.sh - else - source $PWD/build_tools/fbcode.gcc471.sh - fi + source $PWD/build_tools/fbcode_config.sh else source $PWD/build_tools/fbcode.clang31.sh fi @@ -228,7 +222,7 @@ EOF int main() {} EOF if [ "$?" = 0 ]; then - COMMON_FLAGS="$COMMON_FLAGS -DGFLAGS" + COMMON_FLAGS="$COMMON_FLAGS -DGFLAGS=gflags" PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lgflags" fi diff --git a/build_tools/dependencies.sh b/build_tools/dependencies.sh new file mode 100644 index 000000000..868753b8a --- /dev/null +++ b/build_tools/dependencies.sh @@ -0,0 +1,18 @@ +GCC_BASE=/mnt/gvfs/third-party2/gcc/2928bb3ed95bf64f5b388ee88c30dc74710c3b35/5.x/centos6-native/f4950a1 +CLANG_BASE=/mnt/gvfs/third-party2/llvm-fb/a5fea028cb7ba43498976e1f8054b0b2e790c295/stable/centos6-native/6aaf4de +LIBGCC_BASE=/mnt/gvfs/third-party2/libgcc/7a9099f6587ee4378c0b1fa32bb8934019d30ca4/5.x/gcc-5-glibc-2.23/339d858 +GLIBC_BASE=/mnt/gvfs/third-party2/glibc/3b7c6469854dfc7832a1c3cc5b86919a84e5f865/2.23/gcc-5-glibc-2.23/ca1d1c0 +SNAPPY_BASE=/mnt/gvfs/third-party2/snappy/8c38a4c1e52b4c2cc8a9cdc31b9c947ed7dbfcb4/1.1.3/gcc-5-glibc-2.23/9bc6787 +ZLIB_BASE=/mnt/gvfs/third-party2/zlib/d7861abe6f0e27ab98c9303b95a662f0e4cdedb5/1.2.8/gcc-5-glibc-2.23/9bc6787 +BZIP2_BASE=/mnt/gvfs/third-party2/bzip2/740325875f6729f42d28deaa2147b0854f3a347e/1.0.6/gcc-5-glibc-2.23/9bc6787 +LZ4_BASE=/mnt/gvfs/third-party2/lz4/0815d59804160c96caac5f27ca004f51af893dc6/r131/gcc-5-glibc-2.23/9bc6787 +ZSTD_BASE=/mnt/gvfs/third-party2/zstd/c15a4f5f619a2930478d01e2e34dc1e0652b0873/1.1.4/gcc-5-glibc-2.23/03859b5 +GFLAGS_BASE=/mnt/gvfs/third-party2/gflags/f905a5e1032fb30c05db3d3752319857388c0c49/2.2.0/gcc-5-glibc-2.23/9bc6787 +JEMALLOC_BASE=/mnt/gvfs/third-party2/jemalloc/8d60633d822a2a55849c73db24e74a25e52b71db/master/gcc-5-glibc-2.23/1c32b4b +NUMA_BASE=/mnt/gvfs/third-party2/numa/17c514c4d102a25ca15f4558be564eeed76f4b6a/2.0.8/gcc-5-glibc-2.23/9bc6787 +LIBUNWIND_BASE=/mnt/gvfs/third-party2/libunwind/8db74270cd6d0212ac92d69e7fc7beefe617d772/trunk/gcc-5-glibc-2.23/b1847cb +TBB_BASE=/mnt/gvfs/third-party2/tbb/9d9a554877d0c5bef330fe818ab7178806dd316a/4.0_update2/gcc-5-glibc-2.23/9bc6787 +KERNEL_HEADERS_BASE=/mnt/gvfs/third-party2/kernel-headers/90c9734afc5579c9d1db529fa788d09f97763b85/4.0.9-36_fbk5_2933_gd092e3f/gcc-5-glibc-2.23/da39a3e +BINUTILS_BASE=/mnt/gvfs/third-party2/binutils/9e829389ef61b92c62de8748c80169aaf25ce1f0/2.26.1/centos6-native/da39a3e +VALGRIND_BASE=/mnt/gvfs/third-party2/valgrind/d7f4d4d86674a57668e3a96f76f0e17dd0eb8765/3.11.0/gcc-5-glibc-2.23/9bc6787 +LUA_BASE=/mnt/gvfs/third-party2/lua/61e4abf5813bbc39bc4f548757ccfcadde175a48/5.2.3/gcc-5-glibc-2.23/65372bd diff --git a/build_tools/fbcode_config.sh b/build_tools/fbcode_config.sh new file mode 100644 index 000000000..add15980e --- /dev/null +++ b/build_tools/fbcode_config.sh @@ -0,0 +1,147 @@ +#!/bin/sh +# +# Set environment variables so that we can compile rocksdb using +# fbcode settings. It uses the latest g++ and clang compilers and also +# uses jemalloc +# Environment variables that change the behavior of this script: +# PIC_BUILD -- if true, it will only take pic versions of libraries from fbcode. libraries that don't have pic variant will not be included + + +BASEDIR=`dirname $BASH_SOURCE` +source "$BASEDIR/dependencies.sh" + +CFLAGS="" + +# libgcc +LIBGCC_INCLUDE="$LIBGCC_BASE/include" +LIBGCC_LIBS=" -L $LIBGCC_BASE/lib" + +# glibc +GLIBC_INCLUDE="$GLIBC_BASE/include" +GLIBC_LIBS=" -L $GLIBC_BASE/lib" + +# snappy +SNAPPY_INCLUDE=" -I $SNAPPY_BASE/include/" +if test -z $PIC_BUILD; then + SNAPPY_LIBS=" $SNAPPY_BASE/lib/libsnappy.a" +else + SNAPPY_LIBS=" $SNAPPY_BASE/lib/libsnappy_pic.a" +fi +CFLAGS+=" -DSNAPPY" + +if test -z $PIC_BUILD; then + # location of zlib headers and libraries + ZLIB_INCLUDE=" -I $ZLIB_BASE/include/" + ZLIB_LIBS=" $ZLIB_BASE/lib/libz.a" + CFLAGS+=" -DZLIB" + + LZ4_INCLUDE=" -I $LZ4_BASE/include/" + LZ4_LIBS=" $LZ4_BASE/lib/liblz4.a" + CFLAGS+=" -DLZ4" +fi + +# location of gflags headers and libraries +GFLAGS_INCLUDE=" -I $GFLAGS_BASE/include/" +if test -z $PIC_BUILD; then + GFLAGS_LIBS=" $GFLAGS_BASE/lib/libgflags.a" +else + GFLAGS_LIBS=" $GFLAGS_BASE/lib/libgflags_pic.a" +fi +CFLAGS+=" -DGFLAGS=gflags" + +# location of jemalloc +JEMALLOC_INCLUDE=" -I $JEMALLOC_BASE/include/" +JEMALLOC_LIB=" $JEMALLOC_BASE/lib/libjemalloc.a" + +if test -z $PIC_BUILD; then + # location of numa + NUMA_INCLUDE=" -I $NUMA_BASE/include/" + NUMA_LIB=" $NUMA_BASE/lib/libnuma.a" + CFLAGS+=" -DNUMA" + + # location of libunwind + LIBUNWIND="$LIBUNWIND_BASE/lib/libunwind.a" +fi + +# location of TBB +TBB_INCLUDE=" -isystem $TBB_BASE/include/" +if test -z $PIC_BUILD; then + TBB_LIBS="$TBB_BASE/lib/libtbb.a" +else + TBB_LIBS="$TBB_BASE/lib/libtbb_pic.a" +fi +CFLAGS+=" -DTBB" + +# use Intel SSE support for checksum calculations +export USE_SSE=" -msse -msse4.2 " + +BINUTILS="$BINUTILS_BASE/bin" +AR="$BINUTILS/ar" + +DEPS_INCLUDE="$SNAPPY_INCLUDE $ZLIB_INCLUDE $LZ4_INCLUDE $GFLAGS_INCLUDE" + +STDLIBS="-L $GCC_BASE/lib64" + +CLANG_BIN="$CLANG_BASE/bin" +CLANG_LIB="$CLANG_BASE/lib" +CLANG_SRC="$CLANG_BASE/../../src" + +CLANG_ANALYZER="$CLANG_BIN/clang++" +CLANG_SCAN_BUILD="$CLANG_SRC/llvm/tools/clang/tools/scan-build/bin/scan-build" + +if [ -z "$USE_CLANG" ]; then + # gcc + CC="$GCC_BASE/bin/gcc" + CXX="$GCC_BASE/bin/g++" + + CFLAGS+=" -B$BINUTILS/gold" + CFLAGS+=" -isystem $GLIBC_INCLUDE" + CFLAGS+=" -isystem $LIBGCC_INCLUDE" + JEMALLOC=1 +else + # clang + CLANG_INCLUDE="$CLANG_LIB/clang/stable/include" + CC="$CLANG_BIN/clang" + CXX="$CLANG_BIN/clang++" + + KERNEL_HEADERS_INCLUDE="$KERNEL_HEADERS_BASE/include" + + CFLAGS+=" -B$BINUTILS/gold -nostdinc -nostdlib" + CFLAGS+=" -isystem $LIBGCC_BASE/include/c++/5.x " + CFLAGS+=" -isystem $LIBGCC_BASE/include/c++/5.x/x86_64-facebook-linux " + CFLAGS+=" -isystem $GLIBC_INCLUDE" + CFLAGS+=" -isystem $LIBGCC_INCLUDE" + CFLAGS+=" -isystem $CLANG_INCLUDE" + CFLAGS+=" -isystem $KERNEL_HEADERS_INCLUDE/linux " + CFLAGS+=" -isystem $KERNEL_HEADERS_INCLUDE " + CFLAGS+=" -Wno-expansion-to-defined " + CXXFLAGS="-nostdinc++" +fi + +CFLAGS+=" $DEPS_INCLUDE" +CFLAGS+=" -DROCKSDB_PLATFORM_POSIX -DROCKSDB_LIB_IO_POSIX -DROCKSDB_FALLOCATE_PRESENT -DROCKSDB_MALLOC_USABLE_SIZE -DROCKSDB_RANGESYNC_PRESENT -DROCKSDB_SCHED_GETCPU_PRESENT -DROCKSDB_SUPPORT_THREAD_LOCAL -DHAVE_SSE42" +CXXFLAGS+=" $CFLAGS" + +EXEC_LDFLAGS=" $SNAPPY_LIBS $ZLIB_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS $NUMA_LIB $TBB_LIBS" +EXEC_LDFLAGS+=" -B$BINUTILS/gold" +EXEC_LDFLAGS+=" -Wl,--dynamic-linker,/usr/local/fbcode/gcc-5-glibc-2.23/lib/ld.so" +EXEC_LDFLAGS+=" $LIBUNWIND" +EXEC_LDFLAGS+=" -Wl,-rpath=/usr/local/fbcode/gcc-5-glibc-2.23/lib" +# required by libtbb +EXEC_LDFLAGS+=" -ldl" + +PLATFORM_LDFLAGS="$LIBGCC_LIBS $GLIBC_LIBS $STDLIBS -lgcc -lstdc++" + +EXEC_LDFLAGS_SHARED="$SNAPPY_LIBS $ZLIB_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS $TBB_LIBS" + +VALGRIND_VER="$VALGRIND_BASE/bin/" + +LUA_PATH="$LUA_BASE" + +if test -z $PIC_BUILD; then + LUA_LIB=" $LUA_PATH/lib/liblua.a" +else + LUA_LIB=" $LUA_PATH/lib/liblua_pic.a" +fi + +export CC CXX AR CFLAGS CXXFLAGS EXEC_LDFLAGS EXEC_LDFLAGS_SHARED VALGRIND_VER JEMALLOC_LIB JEMALLOC_INCLUDE CLANG_ANALYZER CLANG_SCAN_BUILD LUA_PATH LUA_LIB diff --git a/db/db_bench.cc b/db/db_bench.cc index 17c5a9e55..bde25e2fa 100644 --- a/db/db_bench.cc +++ b/db/db_bench.cc @@ -378,7 +378,7 @@ static bool ValidateCompressionLevel(const char* flagname, int32_t value) { } static const bool FLAGS_compression_level_dummy __attribute__((unused)) = - google::RegisterFlagValidator(&FLAGS_compression_level, + GFLAGS::RegisterFlagValidator(&FLAGS_compression_level, &ValidateCompressionLevel); DEFINE_int32(min_level_to_compress, -1, "If non-negative, compression starts" @@ -535,32 +535,32 @@ DEFINE_string(merge_operator, "", "The merge operator to use with the database." " utilities/merge_operators.h"); static const bool FLAGS_soft_rate_limit_dummy __attribute__((unused)) = - google::RegisterFlagValidator(&FLAGS_soft_rate_limit, + GFLAGS::RegisterFlagValidator(&FLAGS_soft_rate_limit, &ValidateRateLimit); static const bool FLAGS_hard_rate_limit_dummy __attribute__((unused)) = - google::RegisterFlagValidator(&FLAGS_hard_rate_limit, &ValidateRateLimit); + GFLAGS::RegisterFlagValidator(&FLAGS_hard_rate_limit, &ValidateRateLimit); static const bool FLAGS_prefix_size_dummy __attribute__((unused)) = - google::RegisterFlagValidator(&FLAGS_prefix_size, &ValidatePrefixSize); + GFLAGS::RegisterFlagValidator(&FLAGS_prefix_size, &ValidatePrefixSize); static const bool FLAGS_key_size_dummy __attribute__((unused)) = - google::RegisterFlagValidator(&FLAGS_key_size, &ValidateKeySize); + GFLAGS::RegisterFlagValidator(&FLAGS_key_size, &ValidateKeySize); static const bool FLAGS_cache_numshardbits_dummy __attribute__((unused)) = - google::RegisterFlagValidator(&FLAGS_cache_numshardbits, + GFLAGS::RegisterFlagValidator(&FLAGS_cache_numshardbits, &ValidateCacheNumshardbits); static const bool FLAGS_readwritepercent_dummy __attribute__((unused)) = - google::RegisterFlagValidator(&FLAGS_readwritepercent, + GFLAGS::RegisterFlagValidator(&FLAGS_readwritepercent, &ValidateInt32Percent); static const bool FLAGS_deletepercent_dummy __attribute__((unused)) = - google::RegisterFlagValidator(&FLAGS_deletepercent, + GFLAGS::RegisterFlagValidator(&FLAGS_deletepercent, &ValidateInt32Percent); static const bool FLAGS_table_cache_numshardbits_dummy __attribute__((unused)) = - google::RegisterFlagValidator(&FLAGS_table_cache_numshardbits, + GFLAGS::RegisterFlagValidator(&FLAGS_table_cache_numshardbits, &ValidateTableCacheNumshardbits); namespace rocksdb { @@ -2775,9 +2775,9 @@ class Benchmark { int main(int argc, char** argv) { rocksdb::InstallStackTraceHandler(); - google::SetUsageMessage(std::string("\nUSAGE:\n") + std::string(argv[0]) + + GFLAGS::SetUsageMessage(std::string("\nUSAGE:\n") + std::string(argv[0]) + " [OPTIONS]..."); - google::ParseCommandLineFlags(&argc, &argv, true); + GFLAGS::ParseCommandLineFlags(&argc, &argv, true); FLAGS_compaction_style_e = (rocksdb::CompactionStyle) FLAGS_compaction_style; if (FLAGS_statistics) { diff --git a/db/prefix_test.cc b/db/prefix_test.cc index 89e31b60c..e7d1cc31e 100644 --- a/db/prefix_test.cc +++ b/db/prefix_test.cc @@ -620,7 +620,7 @@ TEST(PrefixTest, PrefixHash) { } int main(int argc, char** argv) { - google::ParseCommandLineFlags(&argc, &argv, true); + GFLAGS::ParseCommandLineFlags(&argc, &argv, true); std::cout << kDbName << "\n"; rocksdb::test::RunAllTests(); diff --git a/table/table_reader_bench.cc b/table/table_reader_bench.cc index ab86521f2..78765c511 100644 --- a/table/table_reader_bench.cc +++ b/table/table_reader_bench.cc @@ -233,9 +233,9 @@ DEFINE_string(time_unit, "microsecond", "`microsecond` (default) or `nanosecond`"); int main(int argc, char** argv) { - google::SetUsageMessage(std::string("\nUSAGE:\n") + std::string(argv[0]) + + GFLAGS::SetUsageMessage(std::string("\nUSAGE:\n") + std::string(argv[0]) + " [OPTIONS]..."); - google::ParseCommandLineFlags(&argc, &argv, true); + GFLAGS::ParseCommandLineFlags(&argc, &argv, true); rocksdb::TableFactory* tf = new rocksdb::BlockBasedTableFactory(); rocksdb::Options options; diff --git a/tools/db_repl_stress.cc b/tools/db_repl_stress.cc index 27cb6d5ab..d91e07fa1 100644 --- a/tools/db_repl_stress.cc +++ b/tools/db_repl_stress.cc @@ -87,10 +87,10 @@ DEFINE_uint64(wal_size_limit_MB, 10, "the wal size limit for the run" "(in MB)"); int main(int argc, const char** argv) { - google::SetUsageMessage(std::string("\nUSAGE:\n") + std::string(argv[0]) + + GFLAGS::SetUsageMessage(std::string("\nUSAGE:\n") + std::string(argv[0]) + " --num_inserts= --wal_ttl_seconds=" + " --wal_size_limit_MB="); - google::ParseCommandLineFlags(&argc, const_cast(&argv), true); + GFLAGS::ParseCommandLineFlags(&argc, const_cast(&argv), true); Env* env = Env::Default(); std::string default_db_path; diff --git a/tools/db_stress.cc b/tools/db_stress.cc index 32404c65d..30f0a1dc7 100644 --- a/tools/db_stress.cc +++ b/tools/db_stress.cc @@ -61,7 +61,7 @@ static bool ValidateUint32Range(const char* flagname, uint64_t value) { } DEFINE_uint64(seed, 2341234, "Seed for PRNG"); static const bool FLAGS_seed_dummy = - google::RegisterFlagValidator(&FLAGS_seed, &ValidateUint32Range); + GFLAGS::RegisterFlagValidator(&FLAGS_seed, &ValidateUint32Range); DEFINE_int64(max_key, 1 * KB * KB * KB, "Max number of key/values to place in database"); @@ -171,7 +171,7 @@ static bool ValidateInt32Positive(const char* flagname, int32_t value) { } DEFINE_int32(reopen, 10, "Number of times database reopens"); static const bool FLAGS_reopen_dummy = - google::RegisterFlagValidator(&FLAGS_reopen, &ValidateInt32Positive); + GFLAGS::RegisterFlagValidator(&FLAGS_reopen, &ValidateInt32Positive); DEFINE_int32(bloom_bits, 10, "Bloom filter bits per key. " "Negative means use default settings."); @@ -199,7 +199,7 @@ DEFINE_int32(kill_random_test, 0, "If non-zero, kill at various points in source code with " "probability 1/this"); static const bool FLAGS_kill_random_test_dummy = - google::RegisterFlagValidator(&FLAGS_kill_random_test, + GFLAGS::RegisterFlagValidator(&FLAGS_kill_random_test, &ValidateInt32Positive); extern int rocksdb_kill_odds; @@ -227,32 +227,32 @@ static bool ValidateInt32Percent(const char* flagname, int32_t value) { DEFINE_int32(readpercent, 10, "Ratio of reads to total workload (expressed as a percentage)"); static const bool FLAGS_readpercent_dummy = - google::RegisterFlagValidator(&FLAGS_readpercent, &ValidateInt32Percent); + GFLAGS::RegisterFlagValidator(&FLAGS_readpercent, &ValidateInt32Percent); DEFINE_int32(prefixpercent, 20, "Ratio of prefix iterators to total workload (expressed as a" " percentage)"); static const bool FLAGS_prefixpercent_dummy = - google::RegisterFlagValidator(&FLAGS_prefixpercent, &ValidateInt32Percent); + GFLAGS::RegisterFlagValidator(&FLAGS_prefixpercent, &ValidateInt32Percent); DEFINE_int32(writepercent, 45, " Ratio of deletes to total workload (expressed as a percentage)"); static const bool FLAGS_writepercent_dummy = - google::RegisterFlagValidator(&FLAGS_writepercent, &ValidateInt32Percent); + GFLAGS::RegisterFlagValidator(&FLAGS_writepercent, &ValidateInt32Percent); DEFINE_int32(delpercent, 15, "Ratio of deletes to total workload (expressed as a percentage)"); static const bool FLAGS_delpercent_dummy = - google::RegisterFlagValidator(&FLAGS_delpercent, &ValidateInt32Percent); + GFLAGS::RegisterFlagValidator(&FLAGS_delpercent, &ValidateInt32Percent); DEFINE_int32(iterpercent, 10, "Ratio of iterations to total workload" " (expressed as a percentage)"); static const bool FLAGS_iterpercent_dummy = - google::RegisterFlagValidator(&FLAGS_iterpercent, &ValidateInt32Percent); + GFLAGS::RegisterFlagValidator(&FLAGS_iterpercent, &ValidateInt32Percent); DEFINE_uint64(num_iterations, 10, "Number of iterations per MultiIterate run"); static const bool FLAGS_num_iterations_dummy = - google::RegisterFlagValidator(&FLAGS_num_iterations, &ValidateUint32Range); + GFLAGS::RegisterFlagValidator(&FLAGS_num_iterations, &ValidateUint32Range); DEFINE_bool(disable_seek_compaction, false, "Option to disable compation triggered by read."); @@ -292,18 +292,18 @@ static rocksdb::Env* FLAGS_env = rocksdb::Env::Default(); DEFINE_uint64(ops_per_thread, 600000, "Number of operations per thread."); static const bool FLAGS_ops_per_thread_dummy = - google::RegisterFlagValidator(&FLAGS_ops_per_thread, &ValidateUint32Range); + GFLAGS::RegisterFlagValidator(&FLAGS_ops_per_thread, &ValidateUint32Range); DEFINE_uint64(log2_keys_per_lock, 2, "Log2 of number of keys per lock"); static const bool FLAGS_log2_keys_per_lock_dummy = - google::RegisterFlagValidator(&FLAGS_log2_keys_per_lock, + GFLAGS::RegisterFlagValidator(&FLAGS_log2_keys_per_lock, &ValidateUint32Range); DEFINE_int32(purge_redundant_percent, 50, "Percentage of times we want to purge redundant keys in memory " "before flushing"); static const bool FLAGS_purge_redundant_percent_dummy = - google::RegisterFlagValidator(&FLAGS_purge_redundant_percent, + GFLAGS::RegisterFlagValidator(&FLAGS_purge_redundant_percent, &ValidateInt32Percent); DEFINE_bool(filter_deletes, false, "On true, deletes use KeyMayExist to drop" @@ -340,7 +340,7 @@ static bool ValidatePrefixSize(const char* flagname, int32_t value) { } DEFINE_int32(prefix_size, 7, "Control the prefix size for HashSkipListRep"); static const bool FLAGS_prefix_size_dummy = - google::RegisterFlagValidator(&FLAGS_prefix_size, &ValidatePrefixSize); + GFLAGS::RegisterFlagValidator(&FLAGS_prefix_size, &ValidatePrefixSize); DEFINE_bool(use_merge, false, "On true, replaces all writes with a Merge " "that behaves like a Put"); @@ -1502,9 +1502,9 @@ class StressTest { int main(int argc, char** argv) { - google::SetUsageMessage(std::string("\nUSAGE:\n") + std::string(argv[0]) + + GFLAGS::SetUsageMessage(std::string("\nUSAGE:\n") + std::string(argv[0]) + " [OPTIONS]..."); - google::ParseCommandLineFlags(&argc, &argv, true); + GFLAGS::ParseCommandLineFlags(&argc, &argv, true); if (FLAGS_statistics) { dbstats = rocksdb::CreateDBStatistics(); diff --git a/util/bloom_test.cc b/util/bloom_test.cc index 2c430e203..6b2dd378d 100644 --- a/util/bloom_test.cc +++ b/util/bloom_test.cc @@ -164,7 +164,7 @@ TEST(BloomTest, VaryingLengths) { } // namespace rocksdb int main(int argc, char** argv) { - google::ParseCommandLineFlags(&argc, &argv, true); + GFLAGS::ParseCommandLineFlags(&argc, &argv, true); return rocksdb::test::RunAllTests(); } diff --git a/util/dynamic_bloom_test.cc b/util/dynamic_bloom_test.cc index 4a34d509a..91bd452bb 100644 --- a/util/dynamic_bloom_test.cc +++ b/util/dynamic_bloom_test.cc @@ -196,7 +196,7 @@ TEST(DynamicBloomTest, perf) { } // namespace rocksdb int main(int argc, char** argv) { - google::ParseCommandLineFlags(&argc, &argv, true); + GFLAGS::ParseCommandLineFlags(&argc, &argv, true); return rocksdb::test::RunAllTests(); }