Use reader/writer locks to reduce contention for key parsing and serialization.

PiperOrigin-RevId: 556014241

2 files changed, 11 insertions, 9 deletions

diff --git a/cc/internal/mutable_serialization_registry.cc b/cc/internal/mutable_serialization_registry.cc
index 250d026a7..88277a368 100644
--- a/cc/internal/mutable_serialization_registry.cc
+++ b/cc/internal/mutable_serialization_registry.cc
@@ -48,7 +48,7 @@ MutableSerializationRegistry& MutableSerializationRegistry::GlobalInstance() {
 
 util::Status MutableSerializationRegistry::RegisterParametersParser(
     ParametersParser* parser) {
-  absl::MutexLock lock(&registry_mutex_);
+  absl::WriterMutexLock lock(&registry_mutex_);
   SerializationRegistry::Builder builder(registry_);
   util::Status status = builder.RegisterParametersParser(parser);
   if (!status.ok()) return status;
@@ -58,7 +58,7 @@ util::Status MutableSerializationRegistry::RegisterParametersParser(
 
 util::Status MutableSerializationRegistry::RegisterParametersSerializer(
     ParametersSerializer* serializer) {
-  absl::MutexLock lock(&registry_mutex_);
+  absl::WriterMutexLock lock(&registry_mutex_);
   SerializationRegistry::Builder builder(registry_);
   util::Status status = builder.RegisterParametersSerializer(serializer);
   if (!status.ok()) return status;
@@ -68,7 +68,7 @@ util::Status MutableSerializationRegistry::RegisterParametersSerializer(
 
 util::Status MutableSerializationRegistry::RegisterKeyParser(
     KeyParser* parser) {
-  absl::MutexLock lock(&registry_mutex_);
+  absl::WriterMutexLock lock(&registry_mutex_);
   SerializationRegistry::Builder builder(registry_);
   util::Status status = builder.RegisterKeyParser(parser);
   if (!status.ok()) return status;
@@ -78,7 +78,7 @@ util::Status MutableSerializationRegistry::RegisterKeyParser(
 
 util::Status MutableSerializationRegistry::RegisterKeySerializer(
     KeySerializer* serializer) {
-  absl::MutexLock lock(&registry_mutex_);
+  absl::WriterMutexLock lock(&registry_mutex_);
   SerializationRegistry::Builder builder(registry_);
   util::Status status = builder.RegisterKeySerializer(serializer);
   if (!status.ok()) return status;
@@ -89,14 +89,14 @@ util::Status MutableSerializationRegistry::RegisterKeySerializer(
 util::StatusOr<std::unique_ptr<Parameters>>
 MutableSerializationRegistry::ParseParameters(
     const Serialization& serialization) {
-  absl::MutexLock lock(&registry_mutex_);
+  absl::ReaderMutexLock lock(&registry_mutex_);
   return registry_.ParseParameters(serialization);
 }
 
 util::StatusOr<std::unique_ptr<Key>> MutableSerializationRegistry::ParseKey(
     const Serialization& serialization,
     absl::optional<SecretKeyAccessToken> token) {
-  absl::MutexLock lock(&registry_mutex_);
+  absl::ReaderMutexLock lock(&registry_mutex_);
   return registry_.ParseKey(serialization, token);
 }
 
diff --git a/cc/internal/mutable_serialization_registry.h b/cc/internal/mutable_serialization_registry.h
index a9914dda5..ac235bb59 100644
--- a/cc/internal/mutable_serialization_registry.h
+++ b/cc/internal/mutable_serialization_registry.h
@@ -75,7 +75,7 @@ class MutableSerializationRegistry {
   template <typename SerializationT>
   util::StatusOr<std::unique_ptr<Serialization>> SerializeParameters(
       const Parameters& parameters) ABSL_LOCKS_EXCLUDED(registry_mutex_) {
-    absl::MutexLock lock(&registry_mutex_);
+    absl::ReaderMutexLock lock(&registry_mutex_);
     return registry_.SerializeParameters<SerializationT>(parameters);
   }
 
@@ -95,18 +95,20 @@ class MutableSerializationRegistry {
   util::StatusOr<std::unique_ptr<Serialization>> SerializeKey(
       const Key& key, absl::optional<SecretKeyAccessToken> token)
       ABSL_LOCKS_EXCLUDED(registry_mutex_) {
-    absl::MutexLock lock(&registry_mutex_);
+    absl::ReaderMutexLock lock(&registry_mutex_);
     return registry_.SerializeKey<SerializationT>(key, token);
   }
 
   // Resets to a new empty registry.
   void Reset() ABSL_LOCKS_EXCLUDED(registry_mutex_) {
-    absl::MutexLock lock(&registry_mutex_);
+    absl::WriterMutexLock lock(&registry_mutex_);
     registry_ = SerializationRegistry();
   }
 
  private:
   mutable absl::Mutex registry_mutex_;
+  // Simple wrappers around const methods of `registry_` may safely acquire a
+  // shared (reader) lock. Other calls require an exclusive (writer) lock.
   SerializationRegistry registry_ ABSL_GUARDED_BY(registry_mutex_);
 };