Restoring authorship annotation for <[email protected]>. Commit 1 of 2.

1 files changed, 135 insertions, 135 deletions

diff --git a/contrib/restricted/abseil-cpp/absl/synchronization/internal/create_thread_identity.cc b/contrib/restricted/abseil-cpp/absl/synchronization/internal/create_thread_identity.cc
index 53a71b342b9..2d4250f8a8d 100644
--- a/contrib/restricted/abseil-cpp/absl/synchronization/internal/create_thread_identity.cc
+++ b/contrib/restricted/abseil-cpp/absl/synchronization/internal/create_thread_identity.cc
@@ -1,140 +1,140 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <stdint.h>
-#include <new>
-
-// This file is a no-op if the required LowLevelAlloc support is missing.
-#include "absl/base/internal/low_level_alloc.h"
-#ifndef ABSL_LOW_LEVEL_ALLOC_MISSING
-
-#include <string.h>
-
-#include "absl/base/attributes.h"
-#include "absl/base/internal/spinlock.h"
-#include "absl/base/internal/thread_identity.h"
-#include "absl/synchronization/internal/per_thread_sem.h"
-
-namespace absl {
+// Copyright 2017 The Abseil Authors. 
+// 
+// Licensed under the Apache License, Version 2.0 (the "License"); 
+// you may not use this file except in compliance with the License. 
+// You may obtain a copy of the License at 
+// 
+//      https://www.apache.org/licenses/LICENSE-2.0 
+// 
+// Unless required by applicable law or agreed to in writing, software 
+// distributed under the License is distributed on an "AS IS" BASIS, 
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+// See the License for the specific language governing permissions and 
+// limitations under the License. 
+ 
+#include <stdint.h> 
+#include <new> 
+ 
+// This file is a no-op if the required LowLevelAlloc support is missing. 
+#include "absl/base/internal/low_level_alloc.h" 
+#ifndef ABSL_LOW_LEVEL_ALLOC_MISSING 
+ 
+#include <string.h> 
+ 
+#include "absl/base/attributes.h" 
+#include "absl/base/internal/spinlock.h" 
+#include "absl/base/internal/thread_identity.h" 
+#include "absl/synchronization/internal/per_thread_sem.h" 
+ 
+namespace absl { 
 ABSL_NAMESPACE_BEGIN
-namespace synchronization_internal {
-
-// ThreadIdentity storage is persistent, we maintain a free-list of previously
-// released ThreadIdentity objects.
+namespace synchronization_internal { 
+ 
+// ThreadIdentity storage is persistent, we maintain a free-list of previously 
+// released ThreadIdentity objects. 
 ABSL_CONST_INIT static base_internal::SpinLock freelist_lock(
     absl::kConstInit, base_internal::SCHEDULE_KERNEL_ONLY);
 ABSL_CONST_INIT static base_internal::ThreadIdentity* thread_identity_freelist;
-
-// A per-thread destructor for reclaiming associated ThreadIdentity objects.
-// Since we must preserve their storage we cache them for re-use.
-void ReclaimThreadIdentity(void* v) {
-  base_internal::ThreadIdentity* identity =
-      static_cast<base_internal::ThreadIdentity*>(v);
-
-  // all_locks might have been allocated by the Mutex implementation.
-  // We free it here when we are notified that our thread is dying.
-  if (identity->per_thread_synch.all_locks != nullptr) {
-    base_internal::LowLevelAlloc::Free(identity->per_thread_synch.all_locks);
-  }
-
-  PerThreadSem::Destroy(identity);
-
-  // We must explicitly clear the current thread's identity:
-  // (a) Subsequent (unrelated) per-thread destructors may require an identity.
-  //     We must guarantee a new identity is used in this case (this instructor
-  //     will be reinvoked up to PTHREAD_DESTRUCTOR_ITERATIONS in this case).
-  // (b) ThreadIdentity implementations may depend on memory that is not
-  //     reinitialized before reuse.  We must allow explicit clearing of the
-  //     association state in this case.
-  base_internal::ClearCurrentThreadIdentity();
-  {
-    base_internal::SpinLockHolder l(&freelist_lock);
-    identity->next = thread_identity_freelist;
-    thread_identity_freelist = identity;
-  }
-}
-
-// Return value rounded up to next multiple of align.
-// Align must be a power of two.
-static intptr_t RoundUp(intptr_t addr, intptr_t align) {
-  return (addr + align - 1) & ~(align - 1);
-}
-
-static void ResetThreadIdentity(base_internal::ThreadIdentity* identity) {
-  base_internal::PerThreadSynch* pts = &identity->per_thread_synch;
-  pts->next = nullptr;
-  pts->skip = nullptr;
-  pts->may_skip = false;
-  pts->waitp = nullptr;
-  pts->suppress_fatal_errors = false;
-  pts->readers = 0;
-  pts->priority = 0;
-  pts->next_priority_read_cycles = 0;
-  pts->state.store(base_internal::PerThreadSynch::State::kAvailable,
-                   std::memory_order_relaxed);
-  pts->maybe_unlocking = false;
-  pts->wake = false;
-  pts->cond_waiter = false;
-  pts->all_locks = nullptr;
-  identity->blocked_count_ptr = nullptr;
-  identity->ticker.store(0, std::memory_order_relaxed);
-  identity->wait_start.store(0, std::memory_order_relaxed);
-  identity->is_idle.store(false, std::memory_order_relaxed);
-  identity->next = nullptr;
-}
-
-static base_internal::ThreadIdentity* NewThreadIdentity() {
-  base_internal::ThreadIdentity* identity = nullptr;
-
-  {
-    // Re-use a previously released object if possible.
-    base_internal::SpinLockHolder l(&freelist_lock);
-    if (thread_identity_freelist) {
-      identity = thread_identity_freelist;  // Take list-head.
-      thread_identity_freelist = thread_identity_freelist->next;
-    }
-  }
-
-  if (identity == nullptr) {
-    // Allocate enough space to align ThreadIdentity to a multiple of
-    // PerThreadSynch::kAlignment. This space is never released (it is
-    // added to a freelist by ReclaimThreadIdentity instead).
-    void* allocation = base_internal::LowLevelAlloc::Alloc(
-        sizeof(*identity) + base_internal::PerThreadSynch::kAlignment - 1);
-    // Round up the address to the required alignment.
-    identity = reinterpret_cast<base_internal::ThreadIdentity*>(
-        RoundUp(reinterpret_cast<intptr_t>(allocation),
-                base_internal::PerThreadSynch::kAlignment));
-  }
-  ResetThreadIdentity(identity);
-
-  return identity;
-}
-
-// Allocates and attaches ThreadIdentity object for the calling thread.  Returns
-// the new identity.
-// REQUIRES: CurrentThreadIdentity(false) == nullptr
-base_internal::ThreadIdentity* CreateThreadIdentity() {
-  base_internal::ThreadIdentity* identity = NewThreadIdentity();
-  PerThreadSem::Init(identity);
-  // Associate the value with the current thread, and attach our destructor.
-  base_internal::SetCurrentThreadIdentity(identity, ReclaimThreadIdentity);
-  return identity;
-}
-
-}  // namespace synchronization_internal
+ 
+// A per-thread destructor for reclaiming associated ThreadIdentity objects. 
+// Since we must preserve their storage we cache them for re-use. 
+void ReclaimThreadIdentity(void* v) { 
+  base_internal::ThreadIdentity* identity = 
+      static_cast<base_internal::ThreadIdentity*>(v); 
+ 
+  // all_locks might have been allocated by the Mutex implementation. 
+  // We free it here when we are notified that our thread is dying. 
+  if (identity->per_thread_synch.all_locks != nullptr) { 
+    base_internal::LowLevelAlloc::Free(identity->per_thread_synch.all_locks); 
+  } 
+ 
+  PerThreadSem::Destroy(identity); 
+ 
+  // We must explicitly clear the current thread's identity: 
+  // (a) Subsequent (unrelated) per-thread destructors may require an identity. 
+  //     We must guarantee a new identity is used in this case (this instructor 
+  //     will be reinvoked up to PTHREAD_DESTRUCTOR_ITERATIONS in this case). 
+  // (b) ThreadIdentity implementations may depend on memory that is not 
+  //     reinitialized before reuse.  We must allow explicit clearing of the 
+  //     association state in this case. 
+  base_internal::ClearCurrentThreadIdentity(); 
+  { 
+    base_internal::SpinLockHolder l(&freelist_lock); 
+    identity->next = thread_identity_freelist; 
+    thread_identity_freelist = identity; 
+  } 
+} 
+ 
+// Return value rounded up to next multiple of align. 
+// Align must be a power of two. 
+static intptr_t RoundUp(intptr_t addr, intptr_t align) { 
+  return (addr + align - 1) & ~(align - 1); 
+} 
+ 
+static void ResetThreadIdentity(base_internal::ThreadIdentity* identity) { 
+  base_internal::PerThreadSynch* pts = &identity->per_thread_synch; 
+  pts->next = nullptr; 
+  pts->skip = nullptr; 
+  pts->may_skip = false; 
+  pts->waitp = nullptr; 
+  pts->suppress_fatal_errors = false; 
+  pts->readers = 0; 
+  pts->priority = 0; 
+  pts->next_priority_read_cycles = 0; 
+  pts->state.store(base_internal::PerThreadSynch::State::kAvailable, 
+                   std::memory_order_relaxed); 
+  pts->maybe_unlocking = false; 
+  pts->wake = false; 
+  pts->cond_waiter = false; 
+  pts->all_locks = nullptr; 
+  identity->blocked_count_ptr = nullptr; 
+  identity->ticker.store(0, std::memory_order_relaxed); 
+  identity->wait_start.store(0, std::memory_order_relaxed); 
+  identity->is_idle.store(false, std::memory_order_relaxed); 
+  identity->next = nullptr; 
+} 
+ 
+static base_internal::ThreadIdentity* NewThreadIdentity() { 
+  base_internal::ThreadIdentity* identity = nullptr; 
+ 
+  { 
+    // Re-use a previously released object if possible. 
+    base_internal::SpinLockHolder l(&freelist_lock); 
+    if (thread_identity_freelist) { 
+      identity = thread_identity_freelist;  // Take list-head. 
+      thread_identity_freelist = thread_identity_freelist->next; 
+    } 
+  } 
+ 
+  if (identity == nullptr) { 
+    // Allocate enough space to align ThreadIdentity to a multiple of 
+    // PerThreadSynch::kAlignment. This space is never released (it is 
+    // added to a freelist by ReclaimThreadIdentity instead). 
+    void* allocation = base_internal::LowLevelAlloc::Alloc( 
+        sizeof(*identity) + base_internal::PerThreadSynch::kAlignment - 1); 
+    // Round up the address to the required alignment. 
+    identity = reinterpret_cast<base_internal::ThreadIdentity*>( 
+        RoundUp(reinterpret_cast<intptr_t>(allocation), 
+                base_internal::PerThreadSynch::kAlignment)); 
+  } 
+  ResetThreadIdentity(identity); 
+ 
+  return identity; 
+} 
+ 
+// Allocates and attaches ThreadIdentity object for the calling thread.  Returns 
+// the new identity. 
+// REQUIRES: CurrentThreadIdentity(false) == nullptr 
+base_internal::ThreadIdentity* CreateThreadIdentity() { 
+  base_internal::ThreadIdentity* identity = NewThreadIdentity(); 
+  PerThreadSem::Init(identity); 
+  // Associate the value with the current thread, and attach our destructor. 
+  base_internal::SetCurrentThreadIdentity(identity, ReclaimThreadIdentity); 
+  return identity; 
+} 
+ 
+}  // namespace synchronization_internal 
 ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_LOW_LEVEL_ALLOC_MISSING
+}  // namespace absl 
+ 
+#endif  // ABSL_LOW_LEVEL_ALLOC_MISSING