Various performance optimizations (#1452)

Mostly removing excess copying, or unnecessary allocations.

Relates-To: OLPEDGE-2848

Signed-off-by: Andrey Kashcheev <[email protected]>

Author: andrey-kashcheev

olp-cpp-sdk-core/include/olp/core/generated/parser/ParserWrapper.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019-2021 HERE Europe B.V.
+ * Copyright (C) 2019-2023 HERE Europe B.V.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -24,8 +24,8 @@
 #include <string>
 #include <vector>
 
-#include <boost/optional.hpp>
 #include <rapidjson/rapidjson.h>
+#include <boost/optional.hpp>
 
 namespace olp {
 namespace parser {
@@ -80,7 +80,7 @@ inline void from_json(const rapidjson::Value& value, std::vector<T>& results) {
        itr != value.End(); ++itr) {
     T result;
     from_json(*itr, result);
-    results.push_back(result);
+    results.emplace_back(std::move(result));
   }
 }
 

olp-cpp-sdk-core/src/cache/KeyGenerator.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021 HERE Europe B.V.
+ * Copyright (C) 2021-2023 HERE Europe B.V.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,6 +21,12 @@
 
 namespace olp {
 namespace cache {
+namespace {
+const std::string kColons = "::";
+const std::string kDataSuffix = "Data";
+const std::string kPartitionSuffix = "partition";
+}  // namespace
+
 std::string KeyGenerator::CreateApiKey(const std::string& hrn,
                                        const std::string& service,
                                        const std::string& version) {
@@ -38,8 +44,27 @@ std::string KeyGenerator::CreateLatestVersionKey(const std::string& hrn) {
 std::string KeyGenerator::CreatePartitionKey(
     const std::string& hrn, const std::string& layer_id,
     const std::string& partition_id, const boost::optional<int64_t>& version) {
-  return hrn + "::" + layer_id + "::" + partition_id +
-         "::" + (version ? std::to_string(*version) + "::" : "") + "partition";
+  // Key format: hrn::layer_id::partition_id::[version::]partition
+
+  std::string version_str =
+      version ? std::to_string(*version) + kColons : std::string();
+
+  std::string result;
+  result.reserve(hrn.size() + layer_id.size() + partition_id.size() +
+                 version_str.size() + kPartitionSuffix.size() +
+                 3 * kColons.size());
+
+  result.append(hrn);
+  result.append(kColons);
+  result.append(layer_id);
+  result.append(kColons);
+  result.append(partition_id);
+  result.append(kColons);
+  result.append(version_str);
+  // No need to append colons here, since they are already in version_str.
+  result.append(kPartitionSuffix);
+
+  return result;
 }
 
 std::string KeyGenerator::CreatePartitionsKey(
@@ -65,7 +90,21 @@ std::string KeyGenerator::CreateQuadTreeKey(
 std::string KeyGenerator::CreateDataHandleKey(const std::string& hrn,
                                               const std::string& layer_id,
                                               const std::string& data_handle) {
-  return hrn + "::" + layer_id + "::" + data_handle + "::Data";
+  // Key format: hrn::layer_id::data_handle::Data
+
+  std::string result;
+  result.reserve(hrn.size() + layer_id.size() + data_handle.size() +
+                 kDataSuffix.size() + 3 * kColons.size());
+
+  result.append(hrn);
+  result.append(kColons);
+  result.append(layer_id);
+  result.append(kColons);
+  result.append(data_handle);
+  result.append(kColons);
+  result.append(kDataSuffix);
+
+  return result;
 }
 
 }  // namespace cache

olp-cpp-sdk-dataservice-read/include/olp/dataservice/read/model/Partitions.h

@@ -82,8 +82,8 @@ class DATASERVICE_READ_API Partition {
    *
    * @param value The partition checksum.
    */
-  void SetChecksum(const boost::optional<std::string>& value) {
-    this->checksum_ = value;
+  void SetChecksum(boost::optional<std::string> value) {
+    this->checksum_ = std::move(value);
   }
 
   /**
@@ -120,7 +120,7 @@ class DATASERVICE_READ_API Partition {
    *
    * @param value The compressed size of the partition data.
    */
-  void SetCompressedDataSize(const boost::optional<int64_t>& value) {
+  void SetCompressedDataSize(boost::optional<int64_t> value) {
     this->compressed_data_size_ = value;
   }
 
@@ -151,7 +151,9 @@ class DATASERVICE_READ_API Partition {
    *
    * @param value The partition data handle.
    */
-  void SetDataHandle(const std::string& value) { this->data_handle_ = value; }
+  void SetDataHandle(std::string value) {
+    this->data_handle_ = std::move(value);
+  }
 
   /**
    * @brief (Optional) Gets the uncompressed size of the partition data in
@@ -184,9 +186,7 @@ class DATASERVICE_READ_API Partition {
    *
    * @param value The uncompressed size of the partition data.
    */
-  void SetDataSize(const boost::optional<int64_t>& value) {
-    this->data_size_ = value;
-  }
+  void SetDataSize(boost::optional<int64_t> value) { this->data_size_ = value; }
 
   /**
    * Optional value for the CRC of the partition data in bytes.
@@ -243,7 +243,7 @@ class DATASERVICE_READ_API Partition {
    *
    * @param value The partition key.
    */
-  void SetPartition(const std::string& value) { this->partition_ = value; }
+  void SetPartition(std::string value) { this->partition_ = std::move(value); }
 
   /**
    * @brief (Optional) Gets the version of the catalog when this partition was
@@ -274,9 +274,7 @@ class DATASERVICE_READ_API Partition {
    * @param value The version of the catalog when this partition was last
    * changed.
    */
-  void SetVersion(const boost::optional<int64_t>& value) {
-    this->version_ = value;
-  }
+  void SetVersion(boost::optional<int64_t> value) { this->version_ = value; }
 };
 
 /**
@@ -313,8 +311,8 @@ class Partitions {
    *
    * @param value The list of partitions for the given layer and layer version.
    */
-  void SetPartitions(const std::vector<Partition>& value) {
-    this->partitions_ = value;
+  void SetPartitions(std::vector<Partition> value) {
+    this->partitions_ = std::move(value);
   }
 };
 

olp-cpp-sdk-dataservice-read/src/repositories/DataCacheRepository.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019-2021 HERE Europe B.V.
+ * Copyright (C) 2019-2023 HERE Europe B.V.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -43,16 +43,15 @@ namespace repository {
 DataCacheRepository::DataCacheRepository(
     const client::HRN& hrn, std::shared_ptr<cache::KeyValueCache> cache,
     std::chrono::seconds default_expiry)
-    : hrn_(hrn),
+    : hrn_(hrn.ToCatalogHRNString()),
       cache_(std::move(cache)),
       default_expiry_(ConvertTime(default_expiry)) {}
 
 client::ApiNoResponse DataCacheRepository::Put(const model::Data& data,
                                                const std::string& layer_id,
                                                const std::string& data_handle) {
-  const std::string hrn(hrn_.ToCatalogHRNString());
   const auto key =
-      cache::KeyGenerator::CreateDataHandleKey(hrn, layer_id, data_handle);
+      cache::KeyGenerator::CreateDataHandleKey(hrn_, layer_id, data_handle);
   OLP_SDK_LOG_DEBUG_F(kLogTag, "Put -> '%s'", key.c_str());
 
   if (!cache_->Put(key, data, default_expiry_)) {
@@ -65,9 +64,8 @@ client::ApiNoResponse DataCacheRepository::Put(const model::Data& data,
 
 boost::optional<model::Data> DataCacheRepository::Get(
     const std::string& layer_id, const std::string& data_handle) {
-  const std::string hrn(hrn_.ToCatalogHRNString());
   const auto key =
-      cache::KeyGenerator::CreateDataHandleKey(hrn, layer_id, data_handle);
+      cache::KeyGenerator::CreateDataHandleKey(hrn_, layer_id, data_handle);
   OLP_SDK_LOG_DEBUG_F(kLogTag, "Get '%s'", key.c_str());
 
   auto cached_data = cache_->Get(key);
@@ -80,19 +78,17 @@ boost::optional<model::Data> DataCacheRepository::Get(
 
 bool DataCacheRepository::IsCached(const std::string& layer_id,
                                    const std::string& data_handle) const {
-  const std::string hrn(hrn_.ToCatalogHRNString());
   const auto key =
-      cache::KeyGenerator::CreateDataHandleKey(hrn, layer_id, data_handle);
+      cache::KeyGenerator::CreateDataHandleKey(hrn_, layer_id, data_handle);
   OLP_SDK_LOG_DEBUG_F(kLogTag, "IsCached key -> '%s'", key.c_str());
 
   return cache_->Contains(key);
 }
 
 bool DataCacheRepository::Clear(const std::string& layer_id,
                                 const std::string& data_handle) {
-  const std::string hrn(hrn_.ToCatalogHRNString());
   const auto key =
-      cache::KeyGenerator::CreateDataHandleKey(hrn, layer_id, data_handle);
+      cache::KeyGenerator::CreateDataHandleKey(hrn_, layer_id, data_handle);
   OLP_SDK_LOG_DEBUG_F(kLogTag, "Clear -> '%s'", key.c_str());
 
   return cache_->RemoveKeysWithPrefix(key);

olp-cpp-sdk-dataservice-read/src/repositories/DataCacheRepository.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019-2021 HERE Europe B.V.
+ * Copyright (C) 2019-2023 HERE Europe B.V.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -55,7 +55,7 @@ class DataCacheRepository final {
   bool Clear(const std::string& layer_id, const std::string& data_handle);
 
  private:
-  client::HRN hrn_;
+  const std::string hrn_;
   std::shared_ptr<cache::KeyValueCache> cache_;
   time_t default_expiry_;
 };

olp-cpp-sdk-dataservice-read/src/repositories/NamedMutex.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2022 HERE Europe B.V.
+ * Copyright (C) 2020-2023 HERE Europe B.V.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -132,12 +132,12 @@ boost::optional<client::ApiError> NamedMutexStorage::GetError(
   return impl_->GetError(resource);
 }
 
-NamedMutex::NamedMutex(NamedMutexStorage& storage, const std::string& name,
+NamedMutex::NamedMutex(NamedMutexStorage& storage, std::string name,
                        client::CancellationContext& context)
     : storage_{storage},
       context_{context},
       is_locked_{false},
-      name_{name},
+      name_{std::move(name)},
       mutex_{storage_.AcquireLock(name_)},
       lock_condition_{storage_.GetLockCondition(name_)},
       lock_mutex_{storage_.GetLockMutex(name_)},

olp-cpp-sdk-dataservice-read/src/repositories/NamedMutex.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2022 HERE Europe B.V.
+ * Copyright (C) 2020-2023 HERE Europe B.V.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -80,7 +80,7 @@ class NamedMutexStorage {
  */
 class NamedMutex final {
  public:
-  NamedMutex(NamedMutexStorage& storage, const std::string& name,
+  NamedMutex(NamedMutexStorage& storage, std::string name,
              client::CancellationContext& context);
 
   NamedMutex(const NamedMutex&) = delete;

olp-cpp-sdk-dataservice-read/src/repositories/PartitionsCacheRepository.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019-2021 HERE Europe B.V.
+ * Copyright (C) 2019-2023 HERE Europe B.V.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -95,10 +95,10 @@ client::ApiNoResponse PartitionsCacheRepository::Put(
         cache::KeyGenerator::CreatePartitionsKey(catalog_, layer_id_, version);
     OLP_SDK_LOG_DEBUG_F(kLogTag, "Put -> '%s'", key.c_str());
 
-    const auto put_result = cache_->Put(
-        key, partition_ids,
-        [&]() { return serializer::serialize(partition_ids); },
-        expiry.get_value_or(default_expiry_));
+    const auto put_result =
+        cache_->Put(key, partition_ids,
+                    [&]() { return serializer::serialize(partition_ids); },
+                    expiry.get_value_or(default_expiry_));
 
     if (!put_result) {
       OLP_SDK_LOG_ERROR_F(kLogTag, "Failed to write -> '%s'", key.c_str());
@@ -128,7 +128,7 @@ model::Partitions PartitionsCacheRepository::Get(
 
     if (!cached_partition.empty()) {
       cached_partitions.emplace_back(
-          boost::any_cast<model::Partition>(cached_partition));
+          std::move(boost::any_cast<model::Partition&&>(cached_partition)));
     }
   }
 
@@ -175,9 +175,9 @@ void PartitionsCacheRepository::Put(
       cache::KeyGenerator::CreateLayerVersionsKey(catalog_, catalog_version);
   OLP_SDK_LOG_DEBUG_F(kLogTag, "Put -> '%s'", key.c_str());
 
-  cache_->Put(
-      key, layer_versions,
-      [&]() { return serializer::serialize(layer_versions); }, default_expiry_);
+  cache_->Put(key, layer_versions,
+              [&]() { return serializer::serialize(layer_versions); },
+              default_expiry_);
 }
 
 boost::optional<model::LayerVersions> PartitionsCacheRepository::Get(
@@ -195,7 +195,8 @@ boost::optional<model::LayerVersions> PartitionsCacheRepository::Get(
     return boost::none;
   }
 
-  return boost::any_cast<model::LayerVersions>(cached_layer_versions);
+  return std::move(
+      boost::any_cast<model::LayerVersions&&>(cached_layer_versions));
 }
 
 client::ApiNoResponse PartitionsCacheRepository::Put(
@@ -284,7 +285,8 @@ bool PartitionsCacheRepository::ClearPartitionMetadata(
     return true;
   }
 
-  out_partition = boost::any_cast<model::Partition>(cached_partition);
+  out_partition =
+      std::move(boost::any_cast<model::Partition&&>(cached_partition));
   return cache_->RemoveKeysWithPrefix(key);
 }
 
@@ -295,6 +297,7 @@ bool PartitionsCacheRepository::GetPartitionHandle(
       catalog_, layer_id_, partition_id, catalog_version);
   OLP_SDK_LOG_DEBUG_F(kLogTag, "IsPartitionCached -> '%s'", key.c_str());
 
+  // Memory cache may save whole boost::any so sometimes there are no parsing
   auto cached_partition =
       cache_->Get(key, [](const std::string& serialized_object) {
         return parser::parse<model::Partition>(serialized_object);
@@ -303,8 +306,8 @@ bool PartitionsCacheRepository::GetPartitionHandle(
   if (cached_partition.empty()) {
     return false;
   }
-  auto partition = boost::any_cast<model::Partition>(cached_partition);
-  data_handle = partition.GetDataHandle();
+  auto& partition = boost::any_cast<model::Partition&>(cached_partition);
+  data_handle = std::move(partition.GetMutableDataHandle());
   return true;
 }
 

olp-cpp-sdk-dataservice-read/src/repositories/PartitionsRepository.cpp

@@ -336,21 +336,16 @@ PartitionsResponse PartitionsRepository::GetPartitionById(
   }
 
   auto fetch_option = request.GetFetchOption();
+  const auto key = request.CreateKey(layer_id_, version);
 
-  const auto request_key =
-      catalog_.ToString() + request.CreateKey(layer_id_, version);
-
-  NamedMutex mutex(storage_, request_key, context);
+  NamedMutex mutex(storage_, catalog_.ToString() + key, context);
   std::unique_lock<repository::NamedMutex> lock(mutex, std::defer_lock);
 
   // If we are not planning to go online or access the cache, do not lock.
   if (fetch_option != CacheOnly && fetch_option != OnlineOnly) {
     lock.lock();
   }
 
-  std::chrono::seconds timeout{settings_.retry_settings.timeout};
-  const auto key = request.CreateKey(layer_id_, version);
-
   const std::vector<std::string> partitions{partition_id.value()};
 
   if (fetch_option != OnlineOnly && fetch_option != CacheWithUpdate) {