exec: provide type-erased construction of VdfVector from VtValue

jloy · pixar-oss · commit 88b61f08e091 · 2025-05-08T13:52:04.000-07:00
(Internal change: 2366613)
diff --git a/pxr/exec/exec/CMakeLists.txt b/pxr/exec/exec/CMakeLists.txt
@@ -115,6 +115,20 @@ pxr_register_test(testExecInputResolver
     EXPECTED_RETURN_CODE 0
 )
 
+pxr_build_test(testExecTypeRegistration
+    LIBRARIES
+        gf
+        tf
+        exec
+    CPPFILES
+        testenv/testExecTypeRegistration.cpp
+)
+
+pxr_register_test(testExecTypeRegistration
+    COMMAND "${CMAKE_INSTALL_PREFIX}/tests/testExecTypeRegistration"
+    EXPECTED_RETURN_CODE 0
+)
+
 pxr_build_test(testExecUncompilationTable
     LIBRARIES
         exec
diff --git a/pxr/exec/exec/testenv/testExecTypeRegistration.cpp b/pxr/exec/exec/testenv/testExecTypeRegistration.cpp
@@ -0,0 +1,203 @@
+//
+// Copyright 2025 Pixar
+//
+// Licensed under the terms set forth in the LICENSE.txt file available at
+// https://openusd.org/license.
+//
+#include "pxr/pxr.h"
+
+#include "pxr/exec/exec/typeRegistry.h"
+
+#include "pxr/usd/sdf/timeCode.h"
+#include "pxr/usd/sdf/types.h"
+
+#include "pxr/base/gf/vec3d.h"
+#include "pxr/base/tf/diagnostic.h"
+#include "pxr/base/tf/stringUtils.h"
+#include "pxr/base/vt/types.h"
+
+PXR_NAMESPACE_USING_DIRECTIVE
+
+#define ASSERT_EQ(expr, expected)                                       \
+    [&] {                                                               \
+        auto&& expr_ = expr;                                            \
+        if (expr_ != expected) {                                        \
+            TF_FATAL_ERROR(                                             \
+                "Expected " TF_PP_STRINGIZE(expr) " == '%s'; got '%s'", \
+                TfStringify(expected).c_str(),                          \
+                TfStringify(expr_).c_str());                            \
+        }                                                               \
+     }()
+
+// A type that supports the minimum requirements to be an input value from
+// external clients, a computation result type and a result value returned to
+// external clients.
+struct TestExecTypeRegistrationValue
+{
+    bool operator==(const TestExecTypeRegistrationValue &) const {
+        return true;
+    }
+};
+
+static void
+TestBasicRegistration()
+{
+    auto &reg = ExecTypeRegistry::GetInstance();
+
+    reg.RegisterType(TestExecTypeRegistrationValue{});
+    reg.CheckForRegistration<TestExecTypeRegistrationValue>();
+
+    reg.RegisterType(VtArray<TestExecTypeRegistrationValue>{});
+    reg.CheckForRegistration<VtArray<TestExecTypeRegistrationValue>>();
+}
+
+static void
+TestCreateVector()
+{
+    auto &reg = ExecTypeRegistry::GetInstance();
+
+    // This tests conversion of VtValue to VdfVector with a variety of types.
+    // The are two special categories of types:
+    //
+    //   1. Vt known value types, for which VtValue has optimizations
+    //      related to type checking.
+    //   2. Sdf value types, which comprise the types of attribute and
+    //      metadata in Usd.
+    //
+    // The following test cases include types that cover all combinations of
+    // these categories, including a type that does not belong to either.
+    // Additionally, for VtArray<T> types, test that CreateVector yields a
+    // vectorized VdfVector of T rather than a VdfVector holding a single
+    // VtArray<T>.
+
+    // GfVec3d is both a Vt known value type and an Sdf value type.
+    {
+        static_assert(VtIsKnownValueType<GfVec3d>());
+        static_assert(SdfValueTypeTraits<GfVec3d>::IsValueType);
+        GfVec3d point(1, 2, 3);
+        const VdfVector vec = reg.CreateVector(VtValue(point));
+        TF_AXIOM(vec.Holds<GfVec3d>());
+        const auto accessor = vec.GetReadAccessor<GfVec3d>();
+        ASSERT_EQ(accessor.GetNumValues(), 1);
+        ASSERT_EQ(accessor[0], point);
+    }
+
+    // VtArray<GfVec3d> is both a Vt known value type and an Sdf value type.
+    {
+        static_assert(VtIsKnownValueType<VtArray<GfVec3d>>());
+        static_assert(SdfValueTypeTraits<VtArray<GfVec3d>>::IsValueType);
+        const VtArray<GfVec3d> points = {
+            { 0., 0., 0. },
+            { 1., 0., 0. },
+            { 2., 0., 0. },
+            { 3., 0., 0. },
+            { 4., 0., 0. },
+            { 5., 0., 0. },
+        };
+        const VdfVector vec = reg.CreateVector(VtValue(points));
+        TF_AXIOM(vec.Holds<GfVec3d>());
+        const auto accessor = vec.GetReadAccessor<GfVec3d>();
+        ASSERT_EQ(accessor.GetNumValues(), 6);
+        ASSERT_EQ(accessor[0], points[0]);
+        ASSERT_EQ(accessor[1], points[1]);
+        ASSERT_EQ(accessor[2], points[2]);
+        ASSERT_EQ(accessor[3], points[3]);
+        ASSERT_EQ(accessor[4], points[4]);
+        ASSERT_EQ(accessor[5], points[5]);
+    }
+
+    // short is known to Vt but is not an Sdf value type.
+    {
+        static_assert(VtIsKnownValueType<short>());
+        static_assert(!SdfValueTypeTraits<short>::IsValueType);
+        const short x = 3;
+        const VdfVector vec = reg.CreateVector(VtValue(x));
+        TF_AXIOM(vec.Holds<short>());
+        const auto accessor = vec.GetReadAccessor<short>();
+        ASSERT_EQ(accessor.GetNumValues(), 1);
+        ASSERT_EQ(accessor[0], x);
+    }
+
+    // VtArray<short> is known to Vt but is not an Sdf value type.
+    {
+        static_assert(VtIsKnownValueType<VtArray<short>>());
+        static_assert(!SdfValueTypeTraits<VtArray<short>>::IsValueType);
+        const VtArray<short> arr = { 0, 1 };
+        const VdfVector vec = reg.CreateVector(VtValue(arr));
+        TF_AXIOM(vec.Holds<short>());
+        const auto accessor = vec.GetReadAccessor<short>();
+        ASSERT_EQ(accessor.GetNumValues(), 2);
+        ASSERT_EQ(accessor[0], arr[0]);
+        ASSERT_EQ(accessor[1], arr[1]);
+    }
+
+    // SdfTimeCode is not known to Vt but is an Sdf value type.
+    {
+        static_assert(!VtIsKnownValueType<SdfTimeCode>());
+        static_assert(SdfValueTypeTraits<SdfTimeCode>::IsValueType);
+        const SdfTimeCode t = 1.0;
+        const VdfVector vec = reg.CreateVector(VtValue(t));
+        TF_AXIOM(vec.Holds<SdfTimeCode>());
+        const auto accessor = vec.GetReadAccessor<SdfTimeCode>();
+        ASSERT_EQ(accessor.GetNumValues(), 1);
+        ASSERT_EQ(accessor[0], t);
+    }
+
+    // VtArray<SdfTimeCode> is not known to Vt but is an Sdf value type.
+    {
+        static_assert(!VtIsKnownValueType<VtArray<SdfTimeCode>>());
+        static_assert(SdfValueTypeTraits<VtArray<SdfTimeCode>>::IsValueType);
+        const VtArray<SdfTimeCode> ts = { 0., 1. };
+        const VdfVector vec = reg.CreateVector(VtValue(ts));
+        TF_AXIOM(vec.Holds<SdfTimeCode>());
+        const auto accessor = vec.GetReadAccessor<SdfTimeCode>();
+        ASSERT_EQ(accessor.GetNumValues(), 2);
+        ASSERT_EQ(accessor[0], ts[0]);
+        ASSERT_EQ(accessor[1], ts[1]);
+    }
+
+    // TestExecTypeRegistrationValue is not known to Vt and is not an Sdf
+    // value type.
+    {
+        static_assert(!VtIsKnownValueType<TestExecTypeRegistrationValue>());
+        static_assert(!SdfValueTypeTraits<
+                      TestExecTypeRegistrationValue>::IsValueType);
+        TestExecTypeRegistrationValue val{};
+        const VdfVector vec = reg.CreateVector(VtValue(val));
+        TF_AXIOM(vec.Holds<TestExecTypeRegistrationValue>());
+        const auto accessor = vec.GetReadAccessor<
+            TestExecTypeRegistrationValue>();
+        ASSERT_EQ(accessor.GetNumValues(), 1);
+        // ASSERT_EQ is not used here because it requires that the type have a
+        // TfStringify or ostream operator<< overload and this type should
+        // define only what is necessary for VtValue & VdfVector.
+        TF_AXIOM(accessor[0] == TestExecTypeRegistrationValue{});
+    }
+
+    // VtArray<TestExecTypeRegistrationValue> is not known to Vt and is not an
+    // Sdf value type.
+    {
+        static_assert(!VtIsKnownValueType<
+                      VtArray<TestExecTypeRegistrationValue>>());
+        static_assert(!SdfValueTypeTraits<
+                      VtArray<TestExecTypeRegistrationValue>>::IsValueType);
+        const VtArray<TestExecTypeRegistrationValue> arr = { {}, {} };
+        const VdfVector vec = reg.CreateVector(VtValue(arr));
+        TF_AXIOM(vec.Holds<TestExecTypeRegistrationValue>());
+        const auto accessor = vec.GetReadAccessor<
+            TestExecTypeRegistrationValue>();
+        ASSERT_EQ(accessor.GetNumValues(), 2);
+        TF_AXIOM(accessor[0] == arr[0]);
+        TF_AXIOM(accessor[1] == arr[1]);
+    }
+}
+
+int
+main()
+{
+    TestBasicRegistration();
+    TestCreateVector();
+
+    return 0;
+}
+
diff --git a/pxr/exec/exec/typeRegistry.cpp b/pxr/exec/exec/typeRegistry.cpp
@@ -20,7 +20,11 @@
 #include "pxr/base/tf/preprocessorUtilsLite.h"
 #include "pxr/base/tf/type.h"
 #include "pxr/base/trace/trace.h"
+#include "pxr/base/vt/typeHeaders.h"
 #include "pxr/base/vt/value.h"
+#include "pxr/base/vt/visitValue.h"
+
+#include <type_traits>
 
 PXR_NAMESPACE_OPEN_SCOPE
 
@@ -46,7 +50,7 @@ ExecTypeRegistry::ExecTypeRegistry()
 {
     TRACE_FUNCTION();
 
-    SdfSchema const& schema = SdfSchema::GetInstance();
+    const SdfSchema& schema = SdfSchema::GetInstance();
 
     // Ensure that USD value types are registered before subscribing to our
     // registry function so that plugin type registration cannot override the
@@ -55,12 +59,13 @@ ExecTypeRegistry::ExecTypeRegistry()
 #define _EXEC_REGISTER_VALUE_TYPE(unused, elem)                         \
     {                                                                   \
         using ValueType = SDF_VALUE_CPP_TYPE(elem);                     \
-        TfType const type = TfType::Find<ValueType>();                  \
-        SdfValueTypeName const name = schema.FindType(type);            \
-        VtValue const &def = name.GetDefaultValue();                    \
+        const TfType type = TfType::Find<ValueType>();                  \
+        const SdfValueTypeName name = schema.FindType(type);            \
+        const VtValue &def = name.GetDefaultValue();                    \
         if (TF_VERIFY(def.IsHolding<ValueType>())) {                    \
-            ValueType const &value = def.UncheckedGet<ValueType>();     \
-            _RegisterType(value);                                        \
+            const ValueType &value = def.UncheckedGet<ValueType>();     \
+            _RegisterType(value);                                       \
+            _RegisterType(SDF_VALUE_CPP_ARRAY_TYPE(elem)());            \
         }                                                               \
     }
 
@@ -69,6 +74,7 @@ ExecTypeRegistry::ExecTypeRegistry()
 
     _RegisterType(EfTime());
     _RegisterType(SdfPath());
+    _RegisterType(VtArray<SdfPath>());
 
     TfSingleton<ExecTypeRegistry>::SetInstanceConstructed(*this);
     TfRegistryManager::GetInstance().SubscribeTo<ExecTypeRegistry>();
@@ -77,4 +83,23 @@ ExecTypeRegistry::ExecTypeRegistry()
 
 ExecTypeRegistry::~ExecTypeRegistry() = default;
 
+VdfVector
+ExecTypeRegistry::CreateVector(const VtValue &value) const
+{
+    return VtVisitValue(value, [this](const auto &value) {
+        using T = std::remove_cv_t<std::remove_reference_t<decltype(value)>>;
+        // Visitors must accept a VtValue argument to handle types that aren't
+        // known to VtValue.  This is exactly the purpose of the type dispatch
+        // table.
+        if constexpr (std::is_same_v<VtValue, T>) {
+            return _createVector.Call<VdfVector>(value.GetType(), value);
+        }
+        // Handle Vt's known value types.  We don't need to explicitly
+        // enumerate them here as VtVisitValue will do so.
+        else {
+            return _CreateVector<T>::Create(value);
+        }
+    });
+}
+
 PXR_NAMESPACE_CLOSE_SCOPE
diff --git a/pxr/exec/exec/typeRegistry.h b/pxr/exec/exec/typeRegistry.h
@@ -13,13 +13,16 @@
 
 #include "pxr/exec/exec/api.h"
 #include "pxr/exec/vdf/executionTypeRegistry.h"
+#include "pxr/exec/vdf/typeDispatchTable.h"
 #include "pxr/exec/vdf/vector.h"
 
 #include "pxr/base/tf/singleton.h"
 #include "pxr/base/tf/type.h"
+#include "pxr/base/vt/traits.h"
+#include "pxr/base/vt/types.h"
+#include "pxr/base/vt/value.h"
 
-#include <tbb/concurrent_unordered_map.h>
-
+#include <algorithm>
 #include <memory>
 
 PXR_NAMESPACE_OPEN_SCOPE
@@ -81,6 +84,10 @@ class ExecTypeRegistry
         return VdfExecutionTypeRegistry::CheckForRegistration<ValueType>();
     }
 
+    /// Construct a VdfVector whose value is copied from \p value.
+    EXEC_API
+    VdfVector CreateVector(const VtValue &value) const;
+
 private:
     // Only TfSingleton can create instances.
     friend class TfSingleton<ExecTypeRegistry>;
@@ -94,15 +101,59 @@ class ExecTypeRegistry
     template <typename ValueType>
     void _RegisterType(ValueType const &fallback);
 
+    template <typename T>
+    struct _CreateVector {
+        // Interface for VdfTypeDispatchTable.
+        static VdfVector Call(const VtValue &value) {
+            return Create(value.UncheckedGet<T>());
+        }
+        // Typed implementation of CreateVector.
+        //
+        // This is separate from Call so that it can be shared with the
+        // Vt known type optimization in CreateVector.
+        static VdfVector Create(const T &value);
+    };
+
 private:
     std::unique_ptr<Exec_RegistrationBarrier> _registrationBarrier;
+
+    VdfTypeDispatchTable<_CreateVector> _createVector;
 };
 
 template <typename ValueType>
 void
 ExecTypeRegistry::_RegisterType(ValueType const &fallback)
 {
     VdfExecutionTypeRegistry::Define(fallback);
+
+    // CreateVector has internal handling for value types known to Vt so we do
+    // not need to register them here.
+    if constexpr (!VtIsKnownValueType<ValueType>()) {
+        _createVector.RegisterType<ValueType>();
+    }
+}
+
+template <typename T>
+VdfVector
+ExecTypeRegistry::_CreateVector<T>::Create(const T &value)
+{
+    if constexpr (!VtIsArray<T>::value) {
+        VdfVector v = VdfTypedVector<T>();
+        v.Set(value);
+        return v;
+    }
+    else {
+        using ElementType = typename T::value_type;
+
+        const size_t size = value.size();
+
+        Vdf_BoxedContainer<ElementType> execValue(size);
+        std::copy_n(value.cdata(), size, execValue.data());
+
+        VdfVector v = VdfTypedVector<ElementType>();
+        v.Set(std::move(execValue));
+        return v;
+    }
 }
 
 PXR_NAMESPACE_CLOSE_SCOPE
