Various optimizations and cleanup in the render delegate

libs/render_delegate/instancer.cpp

@@ -214,10 +214,10 @@ bool HdArnoldInstancer::ComputeShapeInstancesTransforms(
 
     AtArray* matrices = AiArrayAllocate(instanceCount, sampleArray.count, AI_TYPE_MATRIX);
     std::vector<AtMatrix> matrixVector;
+    matrixVector.reserve(instanceCount);
     for (size_t n = 0; n < sampleArray.count; ++n) {
         const auto& instanceMatrices = sampleArray.values[n];
         matrixVector.clear();
-        matrixVector.reserve(instanceMatrices.size());
         for (const auto& instanceMatrix : instanceMatrices) {
             AtMatrix arnoldMatrix;
             ConvertValue(arnoldMatrix, instanceMatrix);

libs/render_delegate/openvdb_asset.cpp

@@ -39,7 +39,6 @@ PXR_NAMESPACE_OPEN_SCOPE
 HdArnoldOpenvdbAsset::HdArnoldOpenvdbAsset(HdArnoldRenderDelegate* renderDelegate, const SdfPath& id) : 
     HdField(id), _delegate(renderDelegate)
 {
-    TF_UNUSED(renderDelegate);
 }
 
 void HdArnoldOpenvdbAsset::Sync(HdSceneDelegate* sceneDelegate, HdRenderParam* renderParam, HdDirtyBits* dirtyBits)

libs/render_delegate/render_buffer.cpp

@@ -226,18 +226,19 @@ bool HdArnoldRenderBuffer::Allocate(const GfVec3i& dimensions, HdFormat format,
 
 void* HdArnoldRenderBuffer::Map()
 {
-    _mutex.lock();
+    std::unique_lock<std::mutex> lock(_mutex);
     if (_buffer.empty()) {
-        _mutex.unlock();
         return nullptr;
     }
+    lock.release(); // ownership transferred to Unmap()
     return _buffer.data();
 }
 
 void HdArnoldRenderBuffer::Unmap()
 {
     if (!_buffer.empty()) {
-        _mutex.unlock();
+        // The mutex was acquired (and ownership released) by Map(); adopt it here so it is unlocked via RAII.
+        std::unique_lock<std::mutex> lock(_mutex, std::adopt_lock);
     }
 }
 

libs/render_delegate/render_delegate.cpp

@@ -574,7 +574,7 @@ HdArnoldRenderDelegate::HdArnoldRenderDelegate(bool isBatch, const TfToken &cont
     }
     std::lock_guard<std::mutex> guard(_mutexResourceRegistry);
     if (_counterResourceRegistry.fetch_add(1) == 0) {
-        _resourceRegistry.reset(new HdResourceRegistry());
+        _resourceRegistry = std::make_shared<HdResourceRegistry>();
     }
 
     const auto& config = HdArnoldConfig::GetInstance();
@@ -626,7 +626,7 @@ HdArnoldRenderDelegate::HdArnoldRenderDelegate(bool isBatch, const TfToken &cont
         _renderSession = AiRenderSession(_universe, _renderSessionType);
     }
 
-    _renderParam.reset(new HdArnoldRenderParam(this));
+    _renderParam = std::make_unique<HdArnoldRenderParam>(this);
     // To set the default value.
     _fps = _renderParam->GetFPS();
     _options = AiUniverseGetOptions(_universe);
@@ -883,12 +883,11 @@ void HdArnoldRenderDelegate::_SetRenderSetting(const TfToken& _key, const VtValu
             }
         }
     } else if (TfStringStartsWith(key.GetString(), _tokens->colorManagerNamespace)) {
-        std::string cmParam = key.GetString().substr(_tokens->colorManagerNamespace.GetString().length());
+        const char* cmParamCStr = key.GetText() + _tokens->colorManagerNamespace.GetString().size();
         AtNode* colorManager = getOrCreateColorManager(this, _options);
-        AtString cmParamStr(cmParam.c_str());
-        if (AiNodeEntryLookUpParameter(AiNodeGetNodeEntry(colorManager), 
-            AtString(cmParam.c_str())) != nullptr) {
-            _SetNodeParam(colorManager, TfToken(cmParam), value);
+        AtString cmParamStr(cmParamCStr);
+        if (AiNodeEntryLookUpParameter(AiNodeGetNodeEntry(colorManager), cmParamStr) != nullptr) {
+            _SetNodeParam(colorManager, TfToken(cmParamCStr), value);
         }
     } 
     else {
@@ -1494,15 +1493,14 @@ void HdArnoldRenderDelegate::RegisterLightLinking(const TfToken& name, HdLight*
         if (!name.IsEmpty() || !links.empty()) {
             _lightLinkingChanged.store(true, std::memory_order_release);
         }
-        links.emplace(name, std::vector<HdLight*>{light});
+        links.emplace(name, std::unordered_set<HdLight*>{light});
     } else {
-        if (std::find(it->second.begin(), it->second.end(), light) == it->second.end()) {
+        if (it->second.insert(light).second) {
             // We only trigger the change if we are registering a non-empty collection, or there are more than one
             // collections.
             if (!name.IsEmpty() || links.size() > 1) {
                 _lightLinkingChanged.store(true, std::memory_order_release);
             }
-            it->second.push_back(light);
         }
     }
 }
@@ -1518,7 +1516,7 @@ void HdArnoldRenderDelegate::DeregisterLightLinking(const TfToken& name, HdLight
         if (!name.IsEmpty() || links.size() > 1) {
             _lightLinkingChanged.store(true, std::memory_order_release);
         }
-        it->second.erase(std::remove(it->second.begin(), it->second.end(), light), it->second.end());
+        it->second.erase(light);
         if (it->second.empty()) {
             links.erase(name);
         }

libs/render_delegate/render_delegate.h

@@ -720,7 +720,7 @@ class HdArnoldRenderDelegate final : public HdRenderDelegate {
     /// Pointer to the shared Resource Registry.
     static HdResourceRegistrySharedPtr _resourceRegistry;
 
-    using LightLinkingMap = std::unordered_map<TfToken, std::vector<HdLight*>, TfToken::HashFunctor>;
+    using LightLinkingMap = std::unordered_map<TfToken, std::unordered_set<HdLight*>, TfToken::HashFunctor>;
     using NativeRprimTypeMap = std::unordered_map<TfToken, AtString, TfToken::HashFunctor>;
     using NativeRprimParams = std::unordered_map<AtString, NativeRprimParamList, AtStringHash>;
 

libs/render_delegate/render_settings.cpp

@@ -644,7 +644,10 @@ void HdArnoldRenderSettings::_UpdateRenderProducts(HdSceneDelegate* sceneDelegat
         for (const auto& renderVar : product.renderVars) {
             // Create filter (default to box_filter)
             std::string varName = renderVar.varPath.GetString();
-            std::string filterName = varName + "/filter";
+            std::string filterName;
+            filterName.reserve(varName.size() + 7);
+            filterName = varName;
+            filterName += "/filter";
             std::string filterType = "box_filter";
 
             // Check if arnold:filter is specified in the render var settings
@@ -805,14 +808,20 @@ void HdArnoldRenderSettings::_UpdateRenderProducts(HdSceneDelegate* sceneDelegat
                 lpes.push_back(aovName + " " + sourceName);
             } else if (sourceType == UsdRenderTokens->primvar) {
                 // Primvar AOV - requires aov_write and user_data shaders
-                std::string aovShaderName = varName + "_shader";
+                std::string aovShaderName;
+                aovShaderName.reserve(varName.size() + 7);
+                aovShaderName = varName;
+                aovShaderName += "_shader";
                 AtNode* aovShader =
                     renderDelegate->CreateArnoldNode(arnoldTypes.aovWrite, AtString(aovShaderName.c_str()));
 
                 if (aovShader) {
                     AiNodeSetStr(aovShader, str::aov_name, AtString(aovName.c_str()));
 
-                    std::string userDataName = varName + "_user_data";
+                    std::string userDataName;
+                    userDataName.reserve(varName.size() + 10);
+                    userDataName = varName;
+                    userDataName += "_user_data";
                     AtNode* userData =
                         renderDelegate->CreateArnoldNode(arnoldTypes.userData, AtString(userDataName.c_str()));
 

libs/render_delegate/shared_arrays.h

@@ -149,7 +149,9 @@ struct ArrayHolder : public ArrayOperations<ArrayHolder> {
             const auto& val = unboxed.values[i];
             ptrsToSamples.push_back(val.data());
         }
-        const uint32_t nelements = unboxed.values[0].size(); // TODO make sure that values has something
+        if (ptrsToSamples.empty() || unboxed.values[0].empty())
+            return nullptr;
+        const uint32_t nelements = unboxed.values[0].size();
         const uint32_t type = GetArnoldTypeFor(unboxed.values[0]);
         const uint32_t nkeys = ptrsToSamples.size();
         const void** samples = ptrsToSamples.data();

libs/render_delegate/volume.cpp

@@ -297,6 +297,9 @@ void HdArnoldVolume::_CreateVolumes(const SdfPath& id, HdSceneDelegate* sceneDel
 {
     std::unordered_map<std::string, std::vector<VdbFieldData>> openvdb_fields;
     std::unordered_map<std::string, std::vector<VdbFieldData>> houvdb_fields;
+    // Per-path sets to detect duplicate field names in O(1) instead of O(n) linear scan
+    std::unordered_map<std::string, std::unordered_set<TfToken, TfToken::HashFunctor>> openvdb_seen;
+    std::unordered_map<std::string, std::unordered_set<TfToken, TfToken::HashFunctor>> houvdb_seen;
 
     const auto fieldDescriptors = sceneDelegate->GetVolumeFieldDescriptors(id);
     for (const auto& field : fieldDescriptors) {
@@ -330,19 +333,14 @@ void HdArnoldVolume::_CreateVolumes(const SdfPath& id, HdSceneDelegate* sceneDel
             // op: paths denote a live reference to a VDB in the Houdini session
             if (TfStringStartsWith(path, "op:")) {
                 auto& fields = houvdb_fields[path];
-
-                if (std::find_if(fields.begin(), fields.end(), [&](const VdbFieldData& data) {
-                        return data.field == fieldName;
-                    }) == fields.end()) {
+                if (houvdb_seen[path].insert(fieldName).second) {
                     fields.push_back({fieldName, fieldIndex});
                 }
                 continue;
             }
 
             auto& fields = openvdb_fields[path];
-            if (std::find_if(fields.begin(), fields.end(), [&](const VdbFieldData& data) {
-                    return data.field == fieldName;
-                }) == fields.end()) {
+            if (openvdb_seen[path].insert(fieldName).second) {
                 fields.push_back({fieldName, fieldIndex});
             }
         }
@@ -352,7 +350,7 @@ void HdArnoldVolume::_CreateVolumes(const SdfPath& id, HdSceneDelegate* sceneDel
         std::remove_if(
             _volumes.begin(), _volumes.end(),
             [&openvdb_fields](HdArnoldShape* shape) -> bool {
-                if (openvdb_fields.find(std::string(AiNodeGetStr(shape->GetShape(), str::filename).c_str())) ==
+                if (openvdb_fields.find(AiNodeGetStr(shape->GetShape(), str::filename).c_str()) ==
                     openvdb_fields.end()) {
                     delete shape;
                     return true;