run make format for PR 3838 (facebook#3954)

Summary:
PR facebook#3838 made some changes that triggers lint warnings.
Run `make format` to fix formatting as suggested by siying .
Also piggyback two changes:
1) fix singleton destruction order for windows and posix env
2) fix two clang warnings
Closes facebook#3954

Differential Revision: D8272041

Pulled By: miasantreble

fbshipit-source-id: 7c4fd12bd17aac13534520de0c733328aa3c6c9f

db/comparator_db_test.cc

@@ -260,7 +260,6 @@ class ComparatorDBTest
   DB* db_;
   Options last_options_;
   std::unique_ptr<const Comparator> comparator_guard;
-  uint32_t format_;
 
  public:
   ComparatorDBTest() : env_(Env::Default()), db_(nullptr) {

env/env_posix.cc

@@ -49,6 +49,7 @@
 #include "rocksdb/options.h"
 #include "rocksdb/slice.h"
 #include "util/coding.h"
+#include "util/compression_context_cache.h"
 #include "util/logging.h"
 #include "util/random.h"
 #include "util/string_util.h"
@@ -1057,6 +1058,7 @@ Env* Env::Default() {
   // the destructor of static PosixEnv will go first, then the
   // the singletons of ThreadLocalPtr.
   ThreadLocalPtr::InitSingletons();
+  CompressionContextCache::InitSingleton();
   INIT_SYNC_POINT_SINGLETONS();
   static PosixEnv default_env;
   return &default_env;

port/win/env_default.cc

@@ -12,6 +12,7 @@
 #include <rocksdb/env.h>
 #include "port/win/env_win.h"
 #include "util/compression_context_cache.h"
+#include "util/sync_point.h"
 #include "util/thread_local.h"
 
 namespace rocksdb {
@@ -32,9 +33,9 @@ Env* Env::Default() {
   using namespace port;
   ThreadLocalPtr::InitSingletons();
   CompressionContextCache::InitSingleton();
+  INIT_SYNC_POINT_SINGLETONS();
   std::call_once(winenv_once_flag, []() { envptr = new WinEnv(); });
   return envptr;
 }
 
 }
-

port/win/win_jemalloc.cc

@@ -26,7 +26,7 @@ void JemallocDeallocateForZSTD(void* /* opaque */, void* address) {
   je_free(address);
 }
 ZSTD_customMem GetJeZstdAllocationOverrides() {
-  return { JemallocAllocateForZSTD, JemallocDeallocateForZSTD, nullptr };
+  return {JemallocAllocateForZSTD, JemallocDeallocateForZSTD, nullptr};
 }
 } // namespace port
 } // namespace rocksdb
@@ -63,4 +63,3 @@ void operator delete[](void* p) {
     je_free(p);
   }
 }
-

table/block_based_table_builder.cc

@@ -103,8 +103,7 @@ bool GoodCompressionRatio(size_t compressed_size, size_t raw_size) {
 }  // namespace
 
 // format_version is the block format as defined in include/rocksdb/table.h
-Slice CompressBlock(const Slice& raw,
-                    const CompressionContext& compression_ctx,
+Slice CompressBlock(const Slice& raw, const CompressionContext& compression_ctx,
                     CompressionType* type, uint32_t format_version,
                     std::string* compressed_output) {
   *type = compression_ctx.type();
@@ -262,8 +261,8 @@ struct BlockBasedTableBuilder::Rep {
 
   std::string last_key;
   // Compression dictionary or nullptr
-  const std::string*  compression_dict;
-  CompressionContext  compression_ctx;
+  const std::string* compression_dict;
+  CompressionContext compression_ctx;
   std::unique_ptr<UncompressionContext> verify_ctx;
   TableProperties props;
 
@@ -343,15 +342,14 @@ struct BlockBasedTableBuilder::Rep {
             _moptions.prefix_extractor != nullptr));
     if (table_options.verify_compression) {
       verify_ctx.reset(new UncompressionContext(UncompressionContext::NoCache(),
-        compression_ctx.type()));
+                                                compression_ctx.type()));
     }
   }
 
   Rep(const Rep&) = delete;
   Rep& operator=(const Rep&) = delete;
 
-  ~Rep() {
-  }
+  ~Rep() {}
 };
 
 BlockBasedTableBuilder::BlockBasedTableBuilder(
@@ -513,20 +511,19 @@ void BlockBasedTableBuilder::WriteBlock(const Slice& raw_block_contents,
       }
     }
 
-    block_contents = CompressBlock(raw_block_contents, r->compression_ctx,
-                                  &type, r->table_options.format_version,
-                                  &r->compressed_output);
+    block_contents =
+        CompressBlock(raw_block_contents, r->compression_ctx, &type,
+                      r->table_options.format_version, &r->compressed_output);
 
     // Some of the compression algorithms are known to be unreliable. If
     // the verify_compression flag is set then try to de-compress the
     // compressed data and compare to the input.
     if (type != kNoCompression && r->table_options.verify_compression) {
       // Retrieve the uncompressed contents into a new buffer
       BlockContents contents;
-      Status stat = UncompressBlockContentsForCompressionType(*r->verify_ctx,
-          block_contents.data(), block_contents.size(), &contents,
-          r->table_options.format_version,
-          r->ioptions);
+      Status stat = UncompressBlockContentsForCompressionType(
+          *r->verify_ctx, block_contents.data(), block_contents.size(),
+          &contents, r->table_options.format_version, r->ioptions);
 
       if (stat.ok()) {
         bool compressed_ok = contents.data.compare(raw_block_contents) == 0;
@@ -759,7 +756,8 @@ Status BlockBasedTableBuilder::Finish() {
       r->props.merge_operator_name = r->ioptions.merge_operator != nullptr
                                          ? r->ioptions.merge_operator->Name()
                                          : "nullptr";
-      r->props.compression_name = CompressionTypeToString(r->compression_ctx.type());
+      r->props.compression_name =
+          CompressionTypeToString(r->compression_ctx.type());
       r->props.prefix_extractor_name =
           r->moptions.prefix_extractor != nullptr
               ? r->moptions.prefix_extractor->Name()

table/block_based_table_builder.h

@@ -122,8 +122,7 @@ class BlockBasedTableBuilder : public TableBuilder {
   const uint64_t kCompressionSizeLimit = std::numeric_limits<int>::max();
 };
 
-Slice CompressBlock(const Slice& raw,
-                    const CompressionContext& compression_ctx,
+Slice CompressBlock(const Slice& raw, const CompressionContext& compression_ctx,
                     CompressionType* type, uint32_t format_version,
                     std::string* compressed_output);
 

table/block_based_table_reader.cc

@@ -1103,12 +1103,10 @@ Status BlockBasedTable::GetDataBlockFromCache(
   // Retrieve the uncompressed contents into a new buffer
   BlockContents contents;
   UncompressionContext uncompresssion_ctx(compressed_block->compression_type(),
-    compression_dict);
-  s = UncompressBlockContents(uncompresssion_ctx,
-                              compressed_block->data(),
+                                          compression_dict);
+  s = UncompressBlockContents(uncompresssion_ctx, compressed_block->data(),
                               compressed_block->size(), &contents,
-                              format_version,
-                              ioptions);
+                              format_version, ioptions);
 
   // Insert uncompressed block into block cache
   if (s.ok()) {
@@ -1183,10 +1181,11 @@ Status BlockBasedTable::PutDataBlockToCache(
   BlockContents contents;
   Statistics* statistics = ioptions.statistics;
   if (raw_block->compression_type() != kNoCompression) {
-    UncompressionContext uncompression_ctx(raw_block->compression_type(), compression_dict);
+    UncompressionContext uncompression_ctx(raw_block->compression_type(),
+                                           compression_dict);
     s = UncompressBlockContents(uncompression_ctx, raw_block->data(),
-                                raw_block->size(), &contents,
-                                format_version, ioptions);
+                                raw_block->size(), &contents, format_version,
+                                ioptions);
   }
   if (!s.ok()) {
     delete raw_block;

table/block_fetcher.cc

@@ -226,10 +226,9 @@ Status BlockFetcher::ReadBlockContents() {
   if (do_uncompress_ && compression_type != kNoCompression) {
     // compressed page, uncompress, update cache
     UncompressionContext uncompression_ctx(compression_type, compression_dict_);
-    status_ = UncompressBlockContents(uncompression_ctx, 
-                                      slice_.data(), block_size_, contents_,
-                                      footer_.version(),
-                                      ioptions_);
+    status_ =
+        UncompressBlockContents(uncompression_ctx, slice_.data(), block_size_,
+                                contents_, footer_.version(), ioptions_);
   } else {
     GetBlockContents();
   }

table/format.cc

@@ -264,12 +264,14 @@ Status ReadFooterFromFile(RandomAccessFileReader* file,
   return Status::OK();
 }
 
-Status UncompressBlockContentsForCompressionType(const UncompressionContext& uncompression_ctx,
-    const char* data, size_t n, BlockContents* contents,
-    uint32_t format_version, const ImmutableCFOptions &ioptions) {
+Status UncompressBlockContentsForCompressionType(
+    const UncompressionContext& uncompression_ctx, const char* data, size_t n,
+    BlockContents* contents, uint32_t format_version,
+    const ImmutableCFOptions& ioptions) {
   std::unique_ptr<char[]> ubuf;
 
-  assert(uncompression_ctx.type() != kNoCompression && "Invalid compression type");
+  assert(uncompression_ctx.type() != kNoCompression &&
+         "Invalid compression type");
 
   StopWatchNano timer(ioptions.env,
     ShouldReportDetailedTime(ioptions.env, ioptions.statistics));
@@ -290,8 +292,8 @@ Status UncompressBlockContentsForCompressionType(const UncompressionContext& unc
       break;
     }
     case kZlibCompression:
-      ubuf.reset(Zlib_Uncompress(uncompression_ctx,
-          data, n, &decompress_size,
+      ubuf.reset(Zlib_Uncompress(
+          uncompression_ctx, data, n, &decompress_size,
           GetCompressFormatForVersion(kZlibCompression, format_version)));
       if (!ubuf) {
         static char zlib_corrupt_msg[] =
@@ -314,8 +316,8 @@ Status UncompressBlockContentsForCompressionType(const UncompressionContext& unc
           BlockContents(std::move(ubuf), decompress_size, true, kNoCompression);
       break;
     case kLZ4Compression:
-      ubuf.reset(LZ4_Uncompress(uncompression_ctx,
-          data, n, &decompress_size,
+      ubuf.reset(LZ4_Uncompress(
+          uncompression_ctx, data, n, &decompress_size,
           GetCompressFormatForVersion(kLZ4Compression, format_version)));
       if (!ubuf) {
         static char lz4_corrupt_msg[] =
@@ -326,8 +328,8 @@ Status UncompressBlockContentsForCompressionType(const UncompressionContext& unc
           BlockContents(std::move(ubuf), decompress_size, true, kNoCompression);
       break;
     case kLZ4HCCompression:
-      ubuf.reset(LZ4_Uncompress(uncompression_ctx,
-          data, n, &decompress_size,
+      ubuf.reset(LZ4_Uncompress(
+          uncompression_ctx, data, n, &decompress_size,
           GetCompressFormatForVersion(kLZ4HCCompression, format_version)));
       if (!ubuf) {
         static char lz4hc_corrupt_msg[] =
@@ -382,12 +384,11 @@ Status UncompressBlockContentsForCompressionType(const UncompressionContext& unc
 Status UncompressBlockContents(const UncompressionContext& uncompression_ctx,
                                const char* data, size_t n,
                                BlockContents* contents, uint32_t format_version,
-                               const ImmutableCFOptions &ioptions) {
+                               const ImmutableCFOptions& ioptions) {
   assert(data[n] != kNoCompression);
   assert(data[n] == uncompression_ctx.type());
   return UncompressBlockContentsForCompressionType(
-      uncompression_ctx, data, n, contents,
-      format_version, ioptions);
+      uncompression_ctx, data, n, contents, format_version, ioptions);
 }
 
 }  // namespace rocksdb

table/format.h

@@ -228,19 +228,17 @@ extern Status ReadBlockContents(
 // free this buffer.
 // For description of compress_format_version and possible values, see
 // util/compression.h
-extern Status UncompressBlockContents(const UncompressionContext& uncompression_ctx,
-                                      const char* data, size_t n,
-                                      BlockContents* contents,
-                                      uint32_t compress_format_version,
-                                      const ImmutableCFOptions &ioptions);
+extern Status UncompressBlockContents(
+    const UncompressionContext& uncompression_ctx, const char* data, size_t n,
+    BlockContents* contents, uint32_t compress_format_version,
+    const ImmutableCFOptions& ioptions);
 
 // This is an extension to UncompressBlockContents that accepts
 // a specific compression type. This is used by un-wrapped blocks
 // with no compression header.
 extern Status UncompressBlockContentsForCompressionType(
-    const UncompressionContext& uncompression_ctx,
-    const char* data, size_t n, BlockContents* contents,
-    uint32_t compress_format_version,
+    const UncompressionContext& uncompression_ctx, const char* data, size_t n,
+    BlockContents* contents, uint32_t compress_format_version,
     const ImmutableCFOptions& ioptions);
 
 // Implementation details follow.  Clients should ignore,