Add an ABSL_ prefix to thread_annotation.h macros. (#432)

This is a change Abseil is making on their end.

Also un-pin Abseil dep with CMake back to master branch.

Author: g-easy

cmake/OpenCensusDeps.cmake

@@ -21,7 +21,7 @@ FetchContent_Declare(
 FetchContent_Declare(
   abseil
   GIT_REPOSITORY https://github.com/abseil/abseil-cpp
-  GIT_TAG 2c8421e1c6cef0da9e8a20b01c15256ec9ec116d)
+  GIT_TAG master)
 FetchContent_Declare(
   prometheus
   GIT_REPOSITORY https://github.com/jupp0r/prometheus-cpp

opencensus/common/internal/random.h

@@ -31,13 +31,13 @@ class Generator {
   Generator() : rng_(absl::GetCurrentTimeNanos()) {}
   explicit Generator(uint64_t seed) : rng_(seed) {}
 
-  uint64_t Random64() LOCKS_EXCLUDED(mu_);
+  uint64_t Random64() ABSL_LOCKS_EXCLUDED(mu_);
 
  private:
   friend class Random;
 
   absl::Mutex mu_;
-  std::mt19937_64 rng_ GUARDED_BY(mu_);
+  std::mt19937_64 rng_ ABSL_GUARDED_BY(mu_);
 };
 
 class Random {

opencensus/exporters/stats/stackdriver/internal/stackdriver_exporter.cc

@@ -53,7 +53,7 @@ class Handler : public ::opencensus::stats::StatsExporter::Handler {
   void ExportViewData(
       const std::vector<std::pair<opencensus::stats::ViewDescriptor,
                                   opencensus::stats::ViewData>>& data)
-      LOCKS_EXCLUDED(mu_) override;
+      ABSL_LOCKS_EXCLUDED(mu_) override;
 
  private:
   // Registers 'descriptor' with Stackdriver if no view by that name has been
@@ -62,12 +62,13 @@ class Handler : public ::opencensus::stats::StatsExporter::Handler {
   // successful, and false if the registration fails or the name has already
   // been registered with different parameters.
   bool MaybeRegisterView(const opencensus::stats::ViewDescriptor& descriptor,
-                         bool add_task_label) EXCLUSIVE_LOCKS_REQUIRED(mu_);
+                         bool add_task_label)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
   const StackdriverOptions opts_;
   mutable absl::Mutex mu_;
   std::unordered_map<std::string, opencensus::stats::ViewDescriptor>
-      registered_descriptors_ GUARDED_BY(mu_);
+      registered_descriptors_ ABSL_GUARDED_BY(mu_);
 };
 
 StackdriverOptions SetOptionDefaults(StackdriverOptions&& o) {

opencensus/stats/internal/delta_producer.h

@@ -79,10 +79,10 @@ class DeltaProducer final {
   void AddBoundaries(uint64_t index, const BucketBoundaries& boundaries);
 
   void Record(std::initializer_list<Measurement> measurements,
-              opencensus::tags::TagMap tags) LOCKS_EXCLUDED(delta_mu_);
+              opencensus::tags::TagMap tags) ABSL_LOCKS_EXCLUDED(delta_mu_);
 
   // Flushes the active delta and blocks until it is harvested.
-  void Flush() LOCKS_EXCLUDED(delta_mu_, harvester_mu_);
+  void Flush() ABSL_LOCKS_EXCLUDED(delta_mu_, harvester_mu_);
 
  private:
   DeltaProducer();
@@ -92,9 +92,9 @@ class DeltaProducer final {
   // ConsumeLastDelta so that Record() is blocked for as little time as
   // possible. SwapDeltas should never be called without then calling
   // ConsumeLastDelta--otherwise the delta will be lost.
-  void SwapDeltas() EXCLUSIVE_LOCKS_REQUIRED(delta_mu_, harvester_mu_);
-  void ConsumeLastDelta() EXCLUSIVE_LOCKS_REQUIRED(harvester_mu_)
-      LOCKS_EXCLUDED(delta_mu_);
+  void SwapDeltas() ABSL_EXCLUSIVE_LOCKS_REQUIRED(delta_mu_, harvester_mu_);
+  void ConsumeLastDelta() ABSL_EXCLUSIVE_LOCKS_REQUIRED(harvester_mu_)
+      ABSL_LOCKS_EXCLUDED(delta_mu_);
 
   // Loops flushing the active delta (calling SwapDeltas and ConsumeLastDelta())
   // every harvest_interval_.
@@ -112,16 +112,16 @@ class DeltaProducer final {
   // The BucketBoundaries of each registered view with Distribution aggregation,
   // by measure. Array indices in the outer array correspond to measure indices.
   std::vector<std::vector<BucketBoundaries>> registered_boundaries_
-      GUARDED_BY(delta_mu_);
-  Delta active_delta_ GUARDED_BY(delta_mu_);
+      ABSL_GUARDED_BY(delta_mu_);
+  Delta active_delta_ ABSL_GUARDED_BY(delta_mu_);
 
   // Guards the last_delta_; acquired by the main thread when triggering a
   // flush.
-  mutable absl::Mutex harvester_mu_ ACQUIRED_AFTER(delta_mu_);
+  mutable absl::Mutex harvester_mu_ ABSL_ACQUIRED_AFTER(delta_mu_);
   // TODO: consider making this a lockless queue to avoid blocking the main
   // thread when calling a flush during harvesting.
-  Delta last_delta_ GUARDED_BY(harvester_mu_);
-  std::thread harvester_thread_ GUARDED_BY(harvester_mu_);
+  Delta last_delta_ ABSL_GUARDED_BY(harvester_mu_);
+  std::thread harvester_thread_ ABSL_GUARDED_BY(harvester_mu_);
 };
 
 }  // namespace stats

opencensus/stats/internal/measure_registry_impl.h

@@ -39,23 +39,23 @@ class MeasureRegistryImpl {
   template <typename MeasureT>
   Measure<MeasureT> Register(absl::string_view name,
                              absl::string_view description,
-                             absl::string_view units) LOCKS_EXCLUDED(mu_);
+                             absl::string_view units) ABSL_LOCKS_EXCLUDED(mu_);
 
   const MeasureDescriptor& GetDescriptorByName(absl::string_view name) const
-      LOCKS_EXCLUDED(mu_);
+      ABSL_LOCKS_EXCLUDED(mu_);
 
   MeasureDouble GetMeasureDoubleByName(absl::string_view name) const
-      LOCKS_EXCLUDED(mu_);
+      ABSL_LOCKS_EXCLUDED(mu_);
   MeasureInt64 GetMeasureInt64ByName(absl::string_view name) const
-      LOCKS_EXCLUDED(mu_);
+      ABSL_LOCKS_EXCLUDED(mu_);
 
   // The following methods are for internal use by the library, and not exposed
   // in the public MeasureRegistry.
-  uint64_t GetIdByName(absl::string_view name) const LOCKS_EXCLUDED(mu_);
+  uint64_t GetIdByName(absl::string_view name) const ABSL_LOCKS_EXCLUDED(mu_);
 
   template <typename MeasureT>
   const MeasureDescriptor& GetDescriptor(Measure<MeasureT> measure) const
-      LOCKS_EXCLUDED(mu_);
+      ABSL_LOCKS_EXCLUDED(mu_);
 
   // Measure ids contain a sequential index, a validity bit, and a
   // type bit; these functions access the individual parts.
@@ -69,7 +69,7 @@ class MeasureRegistryImpl {
  private:
   MeasureRegistryImpl() = default;
 
-  uint64_t RegisterImpl(MeasureDescriptor descriptor) LOCKS_EXCLUDED(mu_);
+  uint64_t RegisterImpl(MeasureDescriptor descriptor) ABSL_LOCKS_EXCLUDED(mu_);
 
   static uint64_t CreateMeasureId(uint64_t index, bool is_valid,
                                   MeasureDescriptor::Type type);
@@ -80,9 +80,9 @@ class MeasureRegistryImpl {
   // descriptors themselves don't move around when the vector storage moves due
   // to resize.
   std::vector<std::unique_ptr<MeasureDescriptor>> registered_descriptors_
-      GUARDED_BY(mu_);
+      ABSL_GUARDED_BY(mu_);
   // A map from measure names to IDs.
-  std::unordered_map<std::string, uint64_t> id_map_ GUARDED_BY(mu_);
+  std::unordered_map<std::string, uint64_t> id_map_ ABSL_GUARDED_BY(mu_);
 };
 
 template <>

opencensus/stats/internal/stats_exporter.cc

@@ -94,7 +94,7 @@ void StatsExporterImpl::ClearHandlersForTesting() {
   handlers_.clear();
 }
 
-void StatsExporterImpl::StartExportThread() EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+void StatsExporterImpl::StartExportThread() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
   t_ = std::thread(&StatsExporterImpl::RunWorkerLoop, this);
   thread_started_ = true;
 }

opencensus/stats/internal/stats_exporter_impl.h

@@ -50,18 +50,19 @@ class StatsExporterImpl {
  private:
   StatsExporterImpl() = default;
 
-  void StartExportThread() EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  void StartExportThread() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
   // Loops forever, calling Export() every export_interval_.
   void RunWorkerLoop();
 
   mutable absl::Mutex mu_;
-  absl::Duration export_interval_ GUARDED_BY(mu_) = absl::Seconds(10);
+  absl::Duration export_interval_ ABSL_GUARDED_BY(mu_) = absl::Seconds(10);
   std::vector<std::unique_ptr<StatsExporter::Handler>> handlers_
-      GUARDED_BY(mu_);
-  std::unordered_map<std::string, std::unique_ptr<View>> views_ GUARDED_BY(mu_);
-  bool thread_started_ GUARDED_BY(mu_) = false;
-  std::thread t_ GUARDED_BY(mu_);
+      ABSL_GUARDED_BY(mu_);
+  std::unordered_map<std::string, std::unique_ptr<View>> views_
+      ABSL_GUARDED_BY(mu_);
+  bool thread_started_ ABSL_GUARDED_BY(mu_) = false;
+  std::thread t_ ABSL_GUARDED_BY(mu_);
 };
 
 }  // namespace stats

opencensus/stats/internal/stats_exporter_test.cc

@@ -38,7 +38,7 @@ struct ExportedData {
   }
 
   mutable absl::Mutex mu;
-  std::vector<std::pair<ViewDescriptor, ViewData>> data GUARDED_BY(mu);
+  std::vector<std::pair<ViewDescriptor, ViewData>> data ABSL_GUARDED_BY(mu);
 };
 
 // A mock exporter that assigns exported data to the provided pointer.

opencensus/stats/internal/stats_manager.h

@@ -62,7 +62,7 @@ class StatsManager final {
                           const MeasureData& data, absl::Time now);
 
     // Retrieves a copy of the data.
-    std::unique_ptr<ViewDataImpl> GetData() LOCKS_EXCLUDED(*mu_);
+    std::unique_ptr<ViewDataImpl> GetData() ABSL_LOCKS_EXCLUDED(*mu_);
 
     const ViewDescriptor& view_descriptor() const { return descriptor_; }
 
@@ -72,33 +72,33 @@ class StatsManager final {
     absl::Mutex* const mu_;  // Not owned.
     // The number of View objects backed by this ViewInformation, for
     // reference-counted GC.
-    int num_consumers_ GUARDED_BY(*mu_) = 1;
+    int num_consumers_ ABSL_GUARDED_BY(*mu_) = 1;
 
     // Possible types of stored data.
     enum class DataType { kDouble, kUint64, kDistribution, kInterval };
     static DataType DataTypeForDescriptor(const ViewDescriptor& descriptor);
 
-    ViewDataImpl data_ GUARDED_BY(*mu_);
+    ViewDataImpl data_ ABSL_GUARDED_BY(*mu_);
   };
 
  public:
   static StatsManager* Get();
 
   // Merges all data from 'delta' at the present time.
-  void MergeDelta(const Delta& delta) LOCKS_EXCLUDED(mu_);
+  void MergeDelta(const Delta& delta) ABSL_LOCKS_EXCLUDED(mu_);
 
   // Adds a measure--this is necessary for views to be added under that measure.
   template <typename MeasureT>
-  void AddMeasure(Measure<MeasureT> measure) LOCKS_EXCLUDED(mu_);
+  void AddMeasure(Measure<MeasureT> measure) ABSL_LOCKS_EXCLUDED(mu_);
 
   // Returns a handle that can be used to retrieve data for 'descriptor' (which
   // may point to a new or re-used ViewInformation).
   ViewInformation* AddConsumer(const ViewDescriptor& descriptor)
-      LOCKS_EXCLUDED(mu_);
+      ABSL_LOCKS_EXCLUDED(mu_);
 
   // Removes a consumer from the ViewInformation 'handle', and deletes it if
   // that was the last consumer.
-  void RemoveConsumer(ViewInformation* handle) LOCKS_EXCLUDED(mu_);
+  void RemoveConsumer(ViewInformation* handle) ABSL_LOCKS_EXCLUDED(mu_);
 
  private:
   // MeasureInformation stores all ViewInformation objects for a given measure.
@@ -118,7 +118,7 @@ class StatsManager final {
     absl::Mutex* const mu_;  // Not owned.
     // View objects hold a pointer to ViewInformation directly, so we do not
     // need fast lookup--lookup is only needed for view removal.
-    std::vector<std::unique_ptr<ViewInformation>> views_ GUARDED_BY(*mu_);
+    std::vector<std::unique_ptr<ViewInformation>> views_ ABSL_GUARDED_BY(*mu_);
   };
 
   // TODO: PERF: Global synchronization is only needed for adding or
@@ -127,7 +127,7 @@ class StatsManager final {
   mutable absl::Mutex mu_;
 
   // All registered measures.
-  std::vector<MeasureInformation> measures_ GUARDED_BY(mu_);
+  std::vector<MeasureInformation> measures_ ABSL_GUARDED_BY(mu_);
 };
 
 extern template void StatsManager::AddMeasure(MeasureDouble measure);

opencensus/tags/internal/tag_key.cc

@@ -36,9 +36,9 @@ class TagKeyRegistry {
     return global_tag_key_registry;
   }
 
-  TagKey Register(absl::string_view name) LOCKS_EXCLUDED(mu_);
+  TagKey Register(absl::string_view name) ABSL_LOCKS_EXCLUDED(mu_);
 
-  const std::string& TagKeyName(TagKey key) const LOCKS_EXCLUDED(mu_) {
+  const std::string& TagKeyName(TagKey key) const ABSL_LOCKS_EXCLUDED(mu_) {
     absl::ReaderMutexLock l(&mu_);
     return *registered_tag_keys_[key.id_];
   }
@@ -49,10 +49,10 @@ class TagKeyRegistry {
   // are allocated individually so that they don't move around when the vector
   // storage moves due to resize.
   std::vector<std::unique_ptr<std::string>> registered_tag_keys_
-      GUARDED_BY(mu_);
+      ABSL_GUARDED_BY(mu_);
   // A map from names to IDs.
   // TODO: change to string_view when a suitable hash is available.
-  std::unordered_map<std::string, uint64_t> id_map_ GUARDED_BY(mu_);
+  std::unordered_map<std::string, uint64_t> id_map_ ABSL_GUARDED_BY(mu_);
 };
 
 TagKey TagKeyRegistry::Register(absl::string_view name) {