Protobuf: Remove protobuf globals patch

third_party/protobuf/src/google/protobuf/arena.cc

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
@@ skipping 21 matching lines @@
 
 
 #ifdef ADDRESS_SANITIZER
 #include <sanitizer/asan_interface.h>
 #endif
 
 namespace google {
 namespace protobuf {
 
 
+google::protobuf::internal::SequenceNumber Arena::lifecycle_id_generator_;
 #if defined(GOOGLE_PROTOBUF_NO_THREADLOCAL)
-Arena::ThreadCache& Arena::cr_thread_cache() {
+Arena::ThreadCache& Arena::thread_cache() {
   static internal::ThreadLocalStorage<ThreadCache>* thread_cache_ =
       new internal::ThreadLocalStorage<ThreadCache>();
   return *thread_cache_->Get();
 }
-#elif !defined(PROTOBUF_USE_DLLS)
+#elif defined(PROTOBUF_USE_DLLS)
+Arena::ThreadCache& Arena::thread_cache() {
+  static GOOGLE_THREAD_LOCAL ThreadCache thread_cache_ = { -1, NULL };
+  return thread_cache_;
+}
+#else
 GOOGLE_THREAD_LOCAL Arena::ThreadCache Arena::thread_cache_ = { -1, NULL };
 #endif
 
 void Arena::Init() {
-  lifecycle_id_ = internal::cr_lifecycle_id_generator_.GetNext();
+  lifecycle_id_ = lifecycle_id_generator_.GetNext();
   blocks_ = 0;
   hint_ = 0;
   owns_first_block_ = true;
   cleanup_list_ = 0;
 
   if (options_.initial_block != NULL && options_.initial_block_size > 0) {
     GOOGLE_CHECK_GE(options_.initial_block_size, sizeof(Block))
         << ": Initial block size too small for header.";
 
     // Add first unowned block to list.
     Block* first_block = reinterpret_cast<Block*>(options_.initial_block);
     first_block->size = options_.initial_block_size;
     first_block->pos = kHeaderSize;
     first_block->next = NULL;
     // Thread which calls Init() owns the first block. This allows the
     // single-threaded case to allocate on the first block without taking any
     // locks.
-    first_block->owner = &cr_thread_cache();
+    first_block->owner = &thread_cache();
     SetThreadCacheBlock(first_block);
     AddBlockInternal(first_block);
     owns_first_block_ = false;
   }
 
   // Call the initialization hook
   if (options_.on_arena_init != NULL) {
     hooks_cookie_ = options_.on_arena_init(this);
   } else {
     hooks_cookie_ = NULL;
   }
 }
 
 Arena::~Arena() {
   uint64 space_allocated = ResetInternal();
 
   // Call the destruction hook
   if (options_.on_arena_destruction != NULL) {
     options_.on_arena_destruction(this, hooks_cookie_, space_allocated);
   }
 }
 
 uint64 Arena::Reset() {
   // Invalidate any ThreadCaches pointing to any blocks we just destroyed.
-  lifecycle_id_ = internal::cr_lifecycle_id_generator_.GetNext();
+  lifecycle_id_ = lifecycle_id_generator_.GetNext();
   return ResetInternal();
 }
 
 uint64 Arena::ResetInternal() {
   CleanupList();
   uint64 space_allocated = FreeBlocks();
 
   // Call the reset hook
   if (options_.on_arena_reset != NULL) {
     options_.on_arena_reset(this, hooks_cookie_, space_allocated);
@@ skipping 64 matching lines @@
 
   // Monitor allocation if needed.
   if (GOOGLE_PREDICT_FALSE(hooks_cookie_ != NULL) &&
       options_.on_arena_allocation != NULL) {
     options_.on_arena_allocation(allocated, n, hooks_cookie_);
   }
 
   // If this thread already owns a block in this arena then try to use that.
   // This fast path optimizes the case where multiple threads allocate from the
   // same arena.
-  if (cr_thread_cache().last_lifecycle_id_seen == lifecycle_id_ &&
-      cr_thread_cache().last_block_used_ != NULL) {
-    if (cr_thread_cache().last_block_used_->avail() < n) {
+  if (thread_cache().last_lifecycle_id_seen == lifecycle_id_ &&
+      thread_cache().last_block_used_ != NULL) {
+    if (thread_cache().last_block_used_->avail() < n) {
       return SlowAlloc(n);
     }
-    return AllocFromBlock(cr_thread_cache().last_block_used_, n);
+    return AllocFromBlock(thread_cache().last_block_used_, n);
   }
 
   // Check whether we own the last accessed block on this arena.
   // This fast path optimizes the case where a single thread uses multiple
   // arenas.
-  void* me = &cr_thread_cache();
+  void* me = &thread_cache();
   Block* b = reinterpret_cast<Block*>(google::protobuf::internal::Acquire_Load(&hint_));
   if (!b || b->owner != me || b->avail() < n) {
     return SlowAlloc(n);
   }
   return AllocFromBlock(b, n);
 }
 
 void* Arena::AllocFromBlock(Block* b, size_t n) {
   size_t p = b->pos;
   b->pos = p + n;
 #ifdef ADDRESS_SANITIZER
   ASAN_UNPOISON_MEMORY_REGION(reinterpret_cast<char*>(b) + p, n);
 #endif
   return reinterpret_cast<char*>(b) + p;
 }
 
 void* Arena::SlowAlloc(size_t n) {
-  void* me = &cr_thread_cache();
+  void* me = &thread_cache();
   Block* b = FindBlock(me);  // Find block owned by me.
   // See if allocation fits in my latest block.
   if (b != NULL && b->avail() >= n) {
     SetThreadCacheBlock(b);
     google::protobuf::internal::NoBarrier_Store(&hint_, reinterpret_cast<google::protobuf::internal::AtomicWord>(b));
     return AllocFromBlock(b, n);
   }
   b = NewBlock(me, b, n, options_.start_block_size, options_.max_block_size);
   AddBlock(b);
   if (b->owner == me) {  // If this block can be reused (see NewBlock()).
@@ skipping 56 matching lines @@
   }
   blocks_ = 0;
   hint_ = 0;
   if (!owns_first_block_) {
     // Make the first block that was passed in through ArenaOptions
     // available for reuse.
     first_block->pos = kHeaderSize;
     // Thread which calls Reset() owns the first block. This allows the
     // single-threaded case to allocate on the first block without taking any
     // locks.
-    first_block->owner = &cr_thread_cache();
+    first_block->owner = &thread_cache();
     SetThreadCacheBlock(first_block);
     AddBlockInternal(first_block);
   }
   return space_allocated;
 }
 
 void Arena::CleanupList() {
   Node* head =
       reinterpret_cast<Node*>(google::protobuf::internal::NoBarrier_Load(&cleanup_list_));
   while (head != NULL) {
     head->cleanup(head->elem);
     head = head->next;
   }
   cleanup_list_ = 0;
 }
 
 Arena::Block* Arena::FindBlock(void* me) {
   // TODO(sanjay): We might want to keep a separate list with one
   // entry per thread.
   Block* b = reinterpret_cast<Block*>(google::protobuf::internal::Acquire_Load(&blocks_));
   while (b != NULL && b->owner != me) {
     b = b->next;
   }
   return b;
 }
 
 }  // namespace protobuf
 }  // namespace google