diff --git a/IO/CatalystConduit/CMakeLists.txt b/IO/CatalystConduit/CMakeLists.txt index f5e8c3dba5cc4d4276273826be827700ca0a6a13..bb88412d81faab090470dc69c47583666939f394 100644 --- a/IO/CatalystConduit/CMakeLists.txt +++ b/IO/CatalystConduit/CMakeLists.txt @@ -1,12 +1,20 @@ set(classes - vtkConduitArrayUtilities vtkConduitSource vtkConduitToDataObject vtkDataObjectToConduit + vtkConduitArrayUtilities ) + +if (VTK_MODULE_ENABLE_VTK_AcceleratorsVTKmDataModel) + set(classes_cuda vtkConduitArrayUtilities vtkConduitArrayUtilitiesDevice) +endif() + vtk_module_add_module(VTK::IOCatalystConduit - CLASSES ${classes}) + CLASSES ${classes} + PRIVATE_CLASSES vtkConduitArrayUtilitiesDevice + SOURCES vtkConduitArrayUtilitiesInternals.cxx + PRIVATE_HEADERS vtkConduitArrayUtilitiesInternals.h) if (VTK_KOKKOS_BACKEND STREQUAL "HIP") set(VTK_KOKKOS_BACKEND_HIP 1) @@ -34,7 +42,7 @@ if (TARGET vtkm::cuda) # individual warning types. string(APPEND CMAKE_CUDA_FLAGS " -Xnvlink -w") - set_source_files_properties(vtkConduitArrayUtilities PROPERTIES LANGUAGE CUDA) + set_source_files_properties(${classes_cuda} PROPERTIES LANGUAGE CUDA) vtk_module_set_properties(VTK::IOCatalystConduit CUDA_SEPARABLE_COMPILATION ON) diff --git a/IO/CatalystConduit/vtkConduitArrayUtilities.cxx b/IO/CatalystConduit/vtkConduitArrayUtilities.cxx index ce722cff0f2d0d36b71fa89ca7df5e770febf16d..5f779d5917dcc3cd0247c5d33c4d4aa83c2ce0f7 100644 --- a/IO/CatalystConduit/vtkConduitArrayUtilities.cxx +++ b/IO/CatalystConduit/vtkConduitArrayUtilities.cxx @@ -1,6 +1,7 @@ // SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen // SPDX-License-Identifier: BSD-3-Clause #include "vtkConduitArrayUtilities.h" +#include "vtkConduitArrayUtilitiesInternals.h" #include "vtkArrayDispatch.h" #include "vtkCellArray.h" @@ -22,12 +23,7 @@ #include "vtkTypeUInt8Array.h" #if VTK_MODULE_ENABLE_VTK_AcceleratorsVTKmDataModel -#include "vtkm/CellShape.h" -#include "vtkm/cont/ArrayHandle.h" -#include "vtkm/cont/ArrayHandleCast.h" -#include "vtkm/cont/CellSetSingleType.h" -#include "vtkmDataArray.h" -#include "vtkmlib/CellSetConverters.h" +#include "vtkConduitArrayUtilitiesDevice.h" #if defined(VTK_USE_CUDA) #include <cuda_runtime_api.h> #endif // VTK_USE_CUDA @@ -182,113 +178,6 @@ static vtkSmartPointer<vtkDataArray> ChangeComponentsSOA(vtkDataArray* array, in return array; } -//---------------------------------------------------------------------------- -conduit_cpp::DataType::Id GetTypeId(conduit_cpp::DataType::Id type, bool force_signed) -{ - if (!force_signed) - { - return type; - } - switch (type) - { - case conduit_cpp::DataType::Id::uint8: - return conduit_cpp::DataType::Id::int8; - - case conduit_cpp::DataType::Id::uint16: - return conduit_cpp::DataType::Id::int16; - - case conduit_cpp::DataType::Id::uint32: - return conduit_cpp::DataType::Id::int32; - - case conduit_cpp::DataType::Id::uint64: - return conduit_cpp::DataType::Id::int64; - - default: - return type; - } -} - -#if VTK_MODULE_ENABLE_VTK_AcceleratorsVTKmDataModel -using vtkmConnectivityArrays = vtkTypeList::Unique<vtkTypeList::Create<vtkmDataArray<vtkm::Int8>, - vtkmDataArray<vtkm::Int16>, vtkmDataArray<vtkm::Int32>, vtkmDataArray<vtkm::Int64>>>::Result; - -void AddOneIndexToOffset(vtkm::cont::ArrayHandle<vtkm::Id>& offset, size_t connectivitySize) -{ - size_t lastValue = offset.GetNumberOfValues(); - offset.Allocate(lastValue + 1, vtkm::CopyFlag::On); - auto portal = offset.WritePortal(); - portal.Set(lastValue, connectivitySize); -} - -template <typename OutputValueT, typename ArrayT> -vtkm::cont::ArrayHandle<OutputValueT> ToArrayHandle(ArrayT* input) -{ - // input is a vtkmDataArray<inputValueType> - auto inputUnknownHandle = input->GetVtkmUnknownArrayHandle(); - vtkm::cont::ArrayHandle<OutputValueT> output; - vtkm::cont::ArrayCopyShallowIfPossible(inputUnknownHandle, output); - return output; -} - -//---------------------------------------------------------------------------- -struct FromDeviceConduitToMonoShapedCellArray -{ - vtkIdType NumberOfPoints; - vtkIdType NumberOfPointsPerCell; - int VTKCellType; - vtkCellArray* CellArray; - - FromDeviceConduitToMonoShapedCellArray(vtkIdType numberOfPoints, vtkIdType numberOfPointsPerCell, - int vtkCellType, vtkCellArray* cellArray) - : NumberOfPoints(numberOfPoints) - , NumberOfPointsPerCell(numberOfPointsPerCell) - , VTKCellType(vtkCellType) - , CellArray(cellArray) - { - } - - template <typename ArrayT> - void operator()(ArrayT* input) - { - // input is a vtkmDataArray<inputValueType> - vtkm::cont::CellSetSingleType<> cellSet; - // VTK cell types and VTKm cell shapes have the same numbers - cellSet.Fill(this->NumberOfPoints, this->VTKCellType, this->NumberOfPointsPerCell, - internals::ToArrayHandle<vtkm::Id>(input)); - fromvtkm::Convert(cellSet, this->CellArray); - } -}; - -//---------------------------------------------------------------------------- -struct FromDeviceConduitToMixedCellArray -{ -public: - FromDeviceConduitToMixedCellArray(vtkIdType numberOfPoints, vtkCellArray* cellArray) - : NumberOfPoints(numberOfPoints) - , CellArray(cellArray) - { - } - - template <typename ArrayT1, typename ArrayT2, typename ArrayT3> - void operator()(ArrayT1* offsets, ArrayT2* shapes, ArrayT3* connectivity) - { - // conduit offsets array does not include the last index = - // connectivity.size() as CellSetExplicit - vtkm::cont::CellSetExplicit<> cellSet; - auto vtkmOffsets = ToArrayHandle<vtkm::Id>(offsets); - auto vtkmConnectivity = ToArrayHandle<vtkm::Id>(connectivity); - AddOneIndexToOffset(vtkmOffsets, vtkmConnectivity.GetNumberOfValues()); - cellSet.Fill( - this->NumberOfPoints, ToArrayHandle<vtkm::UInt8>(shapes), vtkmConnectivity, vtkmOffsets); - - fromvtkm::Convert(cellSet, this->CellArray); - } - -private: - vtkIdType NumberOfPoints; - vtkCellArray* CellArray; -}; - //---------------------------------------------------------------------------- struct FromHostConduitToMixedCellArray { @@ -317,8 +206,6 @@ private: vtkCellArray* CellArray; }; -#endif // VTK_MODULE_ENABLE_VTK_AcceleratorsVTKmDataModel - VTK_ABI_NAMESPACE_END } // internals @@ -447,14 +334,10 @@ vtkSmartPointer<vtkDataArray> vtkConduitArrayUtilities::MCArrayToVTKArrayImpl( bool isDevicePointer = vtkConduitArrayUtilities::IsDevicePointer(ptr, id); #if VTK_MODULE_ENABLE_VTK_AcceleratorsVTKmDataModel auto deviceAdapterId = vtkm::cont::make_DeviceAdapterId(id); - if (isDevicePointer) + if (isDevicePointer && !vtkConduitArrayUtilitiesDevice::CanRunOn(deviceAdapterId)) { - vtkm::cont::RuntimeDeviceTracker& runtimeTracker = vtkm::cont::GetRuntimeDeviceTracker(); - if (!runtimeTracker.CanRunOn(deviceAdapterId)) - { - vtkLogF(ERROR, "Device %d is not available at runtime", id); - return nullptr; - } + vtkLogF(ERROR, "Device %d is not available at runtime", id); + return nullptr; } #endif @@ -463,7 +346,7 @@ vtkSmartPointer<vtkDataArray> vtkConduitArrayUtilities::MCArrayToVTKArrayImpl( if (isDevicePointer) { #if VTK_MODULE_ENABLE_VTK_AcceleratorsVTKmDataModel - return vtkConduitArrayUtilities::MCArrayToVTKmAOSArray( + return vtkConduitArrayUtilitiesDevice::MCArrayToVTKmAOSArray( conduit_cpp::c_node(&mcarray), force_signed, deviceAdapterId); #else // IsDeviceMemory returns false in this case @@ -482,7 +365,7 @@ vtkSmartPointer<vtkDataArray> vtkConduitArrayUtilities::MCArrayToVTKArrayImpl( if (isDevicePointer) { #if VTK_MODULE_ENABLE_VTK_AcceleratorsVTKmDataModel - return vtkConduitArrayUtilities::MCArrayToVTKmSOAArray( + return vtkConduitArrayUtilitiesDevice::MCArrayToVTKmSOAArray( conduit_cpp::c_node(&mcarray), force_signed, deviceAdapterId); #else // IsDeviceMemory returns false in this case @@ -501,7 +384,7 @@ vtkSmartPointer<vtkDataArray> vtkConduitArrayUtilities::MCArrayToVTKArrayImpl( if (isDevicePointer) { #if VTK_MODULE_ENABLE_VTK_AcceleratorsVTKmDataModel - return vtkConduitArrayUtilities::MCArrayToVTKmSOAArray( + return vtkConduitArrayUtilitiesDevice::MCArrayToVTKmSOAArray( conduit_cpp::c_node(&mcarray), force_signed, deviceAdapterId); #else // IsDeviceMemory returns false in this case @@ -675,13 +558,10 @@ vtkSmartPointer<vtkCellArray> vtkConduitArrayUtilities::MCArrayToVTKCellArray( { return nullptr; } -#if VTK_MODULE_ENABLE_VTK_AcceleratorsVTKmDataModel - // check if cell arrays are in device memory - using Dispatcher = vtkArrayDispatch::DispatchByArray<internals::vtkmConnectivityArrays>; vtkNew<vtkCellArray> cellArray; - internals::FromDeviceConduitToMonoShapedCellArray worker{ numberOfPoints, cellSize, cellType, - cellArray }; - if (!Dispatcher::Execute(connectivity, worker)) +#if VTK_MODULE_ENABLE_VTK_AcceleratorsVTKmDataModel + if (!vtkConduitArrayUtilitiesDevice::IfVTKmConvertVTK( + numberOfPoints, cellType, cellSize, connectivity, cellArray)) #endif // VTK_MODULE_ENABLE_VTK_AcceleratorsVTKmDataModel { // cell arrays are in host memory @@ -717,13 +597,9 @@ vtkSmartPointer<vtkCellArray> vtkConduitArrayUtilities::O2MRelationToVTKCellArra conduit_cpp::c_node(&node_shapes), /*force_signed*/ true); vtkNew<vtkCellArray> cellArray; #if VTK_MODULE_ENABLE_VTK_AcceleratorsVTKmDataModel - // offsets and connectivity are in device memory - using VtkmDispatcher = - vtkArrayDispatch::Dispatch3ByArrayWithSameValueType<internals::vtkmConnectivityArrays, - internals::vtkmConnectivityArrays, internals::vtkmConnectivityArrays>; - internals::FromDeviceConduitToMixedCellArray deviceWorker{ numberOfPoints, cellArray }; - if (!VtkmDispatcher::Execute(offsets, shapes, elements, deviceWorker)) -#endif // VTK_MODULE_ENABLE_VTK_AcceleratorsVTKmDataModel + if (!vtkConduitArrayUtilitiesDevice::IfVTKmConvertVTK( + numberOfPoints, offsets, shapes, elements, cellArray)) +#endif { // offsets and connectivity are in host memory using ConduitDispatcher = @@ -781,194 +657,6 @@ bool vtkConduitArrayUtilities::IsDevicePointer(const void* ptr, int8_t& id) return false; } -#if VTK_MODULE_ENABLE_VTK_AcceleratorsVTKmDataModel -#define vtkmAOSDataArrayConstructSingleComponent(dtype, nvals, raw_ptr, deviceAdapterId) \ - do \ - { \ - return make_vtkmDataArray(vtkm::cont::ArrayHandle<dtype>( \ - std::vector<vtkm::cont::internal::Buffer>{ vtkm::cont::internal::MakeBuffer( \ - deviceAdapterId, reinterpret_cast<dtype*>(raw_ptr), reinterpret_cast<dtype*>(raw_ptr), \ - vtkm::internal::NumberOfValuesToNumberOfBytes<dtype>(nvals), [](void*) {}, \ - vtkm::cont::internal::InvalidRealloc) })); \ - } while (0) - -#define vtkmAOSDataArrayConstructMultiComponent(dtype, ntups, ncomp, raw_ptr, deviceAdapterId) \ - do \ - { \ - return make_vtkmDataArray(vtkm::cont::ArrayHandle<vtkm::Vec<dtype, ncomp>>( \ - std::vector<vtkm::cont::internal::Buffer>{ vtkm::cont::internal::MakeBuffer( \ - deviceAdapterId, reinterpret_cast<dtype*>(raw_ptr), reinterpret_cast<dtype*>(raw_ptr), \ - vtkm::internal::NumberOfValuesToNumberOfBytes<dtype>(ntups * ncomp), [](void*) {}, \ - vtkm::cont::internal::InvalidRealloc) })); \ - } while (0) - -#define vtkmAOSDataArrayNumComponentsBody(dtype, ntups, ncomp, raw_ptr, deviceAdapterId) \ - switch (num_components) \ - { \ - case 1: \ - vtkmAOSDataArrayConstructSingleComponent(dtype, num_tuples, raw_ptr, deviceAdapterId); \ - case 2: \ - vtkmAOSDataArrayConstructMultiComponent(dtype, num_tuples, 2, raw_ptr, deviceAdapterId); \ - case 3: \ - vtkmAOSDataArrayConstructMultiComponent(dtype, num_tuples, 3, raw_ptr, deviceAdapterId); \ - case 4: \ - vtkmAOSDataArrayConstructMultiComponent(dtype, num_tuples, 4, raw_ptr, deviceAdapterId); \ - case 5: \ - vtkmAOSDataArrayConstructMultiComponent(dtype, num_tuples, 5, raw_ptr, deviceAdapterId); \ - case 6: \ - default: \ - vtkmAOSDataArrayConstructMultiComponent(dtype, num_tuples, 6, raw_ptr, deviceAdapterId); \ - } - -#define vtkmAOSDataArrayCase(conduitTypeId, dtype, ntups, ncomp, raw_ptr, deviceAdapterId) \ - case conduitTypeId: \ - { \ - vtkmAOSDataArrayNumComponentsBody(dtype, ntups, ncomp, raw_ptr, deviceAdapterId); \ - } \ - break - -//---------------------------------------------------------------------------- -vtkSmartPointer<vtkDataArray> vtkConduitArrayUtilities::MCArrayToVTKmAOSArray( - const conduit_node* c_mcarray, bool force_signed, - const vtkm::cont::DeviceAdapterId& deviceAdapterId) -{ - const conduit_cpp::Node mcarray = conduit_cpp::cpp_node(const_cast<conduit_node*>(c_mcarray)); - const auto& child0 = mcarray.child(0); - const conduit_cpp::DataType dtype0 = child0.dtype(); - - const int num_components = static_cast<int>(mcarray.number_of_children()); - const vtkIdType num_tuples = static_cast<vtkIdType>(dtype0.number_of_elements()); - void* raw_ptr = const_cast<void*>(child0.element_ptr(0)); - - using conduit_dtype = conduit_cpp::DataType::Id; - - switch (internals::GetTypeId(dtype0.id(), force_signed)) - { - vtkmAOSDataArrayCase( - conduit_dtype::int8, vtkm::Int8, num_tuples, num_components, raw_ptr, deviceAdapterId); - vtkmAOSDataArrayCase( - conduit_dtype::int16, vtkm::Int16, num_tuples, num_components, raw_ptr, deviceAdapterId); - vtkmAOSDataArrayCase( - conduit_dtype::int32, vtkm::Int32, num_tuples, num_components, raw_ptr, deviceAdapterId); - vtkmAOSDataArrayCase( - conduit_dtype::int64, vtkm::Int64, num_tuples, num_components, raw_ptr, deviceAdapterId); - vtkmAOSDataArrayCase( - conduit_dtype::uint8, vtkm::UInt8, num_tuples, num_components, raw_ptr, deviceAdapterId); - vtkmAOSDataArrayCase( - conduit_dtype::uint16, vtkm::UInt16, num_tuples, num_components, raw_ptr, deviceAdapterId); - vtkmAOSDataArrayCase( - conduit_dtype::uint32, vtkm::UInt32, num_tuples, num_components, raw_ptr, deviceAdapterId); - vtkmAOSDataArrayCase( - conduit_dtype::uint64, vtkm::UInt64, num_tuples, num_components, raw_ptr, deviceAdapterId); - vtkmAOSDataArrayCase( - conduit_dtype::float32, vtkm::Float32, num_tuples, num_components, raw_ptr, deviceAdapterId); - vtkmAOSDataArrayCase( - conduit_dtype::float64, vtkm::Float64, num_tuples, num_components, raw_ptr, deviceAdapterId); - default: - vtkLogF(ERROR, "unsupported data type '%s' ", dtype0.name().c_str()); - return {}; - } - return {}; -} - -#define vtkmSOADataArrayConstructSingleComponent(dtype, nvals, deviceAdapterId) \ - do \ - { \ - std::vector<vtkm::cont::internal::Buffer> buffers; \ - buffers.reserve(num_components); \ - for (int cc = 0; cc < num_components; ++cc) \ - { \ - buffers.push_back(vtkm::cont::internal::MakeBuffer( \ - deviceAdapterId, \ - reinterpret_cast<dtype*>(const_cast<void*>(mcarray.child(cc).element_ptr(0))), \ - reinterpret_cast<dtype*>(const_cast<void*>(mcarray.child(cc).element_ptr(0))), \ - vtkm::internal::NumberOfValuesToNumberOfBytes<dtype>(nvals), [](void*) {}, \ - vtkm::cont::internal::InvalidRealloc)); \ - } \ - return make_vtkmDataArray(vtkm::cont::ArrayHandle<dtype>(buffers)); \ - } while (0) - -#define vtkmSOADataArrayConstructMultiComponent(dtype, ntups, ncomp, deviceAdapterId) \ - do \ - { \ - std::vector<vtkm::cont::internal::Buffer> buffers; \ - buffers.reserve(num_components); \ - for (int cc = 0; cc < num_components; ++cc) \ - { \ - buffers.push_back(vtkm::cont::internal::MakeBuffer( \ - deviceAdapterId, \ - reinterpret_cast<dtype*>(const_cast<void*>(mcarray.child(cc).element_ptr(0))), \ - reinterpret_cast<dtype*>(const_cast<void*>(mcarray.child(cc).element_ptr(0))), \ - vtkm::internal::NumberOfValuesToNumberOfBytes<dtype>(num_tuples), [](void*) {}, \ - vtkm::cont::internal::InvalidRealloc)); \ - } \ - return make_vtkmDataArray(vtkm::cont::ArrayHandleSOA<vtkm::Vec<dtype, ncomp>>(buffers)); \ - } while (0) - -#define vtkmSOADataArrayCase(conduitTypeId, dtype, ntups, ncomp, deviceAdapterId) \ - case conduitTypeId: \ - { \ - switch (num_components) \ - { \ - case 1: \ - vtkmSOADataArrayConstructSingleComponent(dtype, num_tuples, deviceAdapterId); \ - case 2: \ - vtkmSOADataArrayConstructMultiComponent(dtype, num_tuples, 2, deviceAdapterId); \ - case 3: \ - vtkmSOADataArrayConstructMultiComponent(dtype, num_tuples, 3, deviceAdapterId); \ - case 4: \ - vtkmSOADataArrayConstructMultiComponent(dtype, num_tuples, 4, deviceAdapterId); \ - case 5: \ - vtkmSOADataArrayConstructMultiComponent(dtype, num_tuples, 5, deviceAdapterId); \ - case 6: \ - default: \ - vtkmSOADataArrayConstructMultiComponent(dtype, num_tuples, 6, deviceAdapterId); \ - } \ - } \ - break - -//---------------------------------------------------------------------------- -vtkSmartPointer<vtkDataArray> vtkConduitArrayUtilities::MCArrayToVTKmSOAArray( - const conduit_node* c_mcarray, bool force_signed, - const vtkm::cont::DeviceAdapterId& deviceAdapterId) -{ - const conduit_cpp::Node mcarray = conduit_cpp::cpp_node(const_cast<conduit_node*>(c_mcarray)); - const conduit_cpp::DataType dtype0 = mcarray.child(0).dtype(); - const int num_components = static_cast<int>(mcarray.number_of_children()); - const vtkIdType num_tuples = static_cast<vtkIdType>(dtype0.number_of_elements()); - - using conduit_dtype = conduit_cpp::DataType::Id; - - switch (internals::GetTypeId(dtype0.id(), force_signed)) - { - vtkmSOADataArrayCase( - conduit_dtype::int8, vtkm::Int8, num_tuples, num_components, deviceAdapterId); - vtkmSOADataArrayCase( - conduit_dtype::int16, vtkm::Int16, num_tuples, num_components, deviceAdapterId); - vtkmSOADataArrayCase( - conduit_dtype::int32, vtkm::Int32, num_tuples, num_components, deviceAdapterId); - vtkmSOADataArrayCase( - conduit_dtype::int64, vtkm::Int64, num_tuples, num_components, deviceAdapterId); - vtkmSOADataArrayCase( - conduit_dtype::uint8, vtkm::UInt8, num_tuples, num_components, deviceAdapterId); - vtkmSOADataArrayCase( - conduit_dtype::uint16, vtkm::UInt16, num_tuples, num_components, deviceAdapterId); - vtkmSOADataArrayCase( - conduit_dtype::uint32, vtkm::UInt32, num_tuples, num_components, deviceAdapterId); - vtkmSOADataArrayCase( - conduit_dtype::uint64, vtkm::UInt64, num_tuples, num_components, deviceAdapterId); - vtkmSOADataArrayCase( - conduit_dtype::float32, vtkm::Float32, num_tuples, num_components, deviceAdapterId); - vtkmSOADataArrayCase( - conduit_dtype::float64, vtkm::Float64, num_tuples, num_components, deviceAdapterId); - default: - vtkLogF(ERROR, "unsupported data type '%s' ", dtype0.name().c_str()); - return {}; - } - return {}; -} -#endif // VTK_MODULE_ENABLE_VTK_AcceleratorsVTKmDataModel - //---------------------------------------------------------------------------- void vtkConduitArrayUtilities::PrintSelf(ostream& os, vtkIndent indent) { diff --git a/IO/CatalystConduit/vtkConduitArrayUtilities.h b/IO/CatalystConduit/vtkConduitArrayUtilities.h index bc445b367cef08f857aab06761432336a896c3d0..c3a4ca061c4ef2c1d465e785c3ca18287756ed81 100644 --- a/IO/CatalystConduit/vtkConduitArrayUtilities.h +++ b/IO/CatalystConduit/vtkConduitArrayUtilities.h @@ -24,10 +24,6 @@ #include <string> // for std::string -#if VTK_MODULE_ENABLE_VTK_AcceleratorsVTKmDataModel -#include "vtkm/cont/DeviceAdapterTag.h" // for vtkm::cont::DeviceAdapterId -#endif - VTK_ABI_NAMESPACE_BEGIN class vtkCellArray; class vtkDataArray; @@ -92,13 +88,6 @@ protected: static vtkSmartPointer<vtkDataArray> MCArrayToVTKSOAArray( const conduit_node* mcarray, bool force_signed); -#if VTK_MODULE_ENABLE_VTK_AcceleratorsVTKmDataModel - static vtkSmartPointer<vtkDataArray> MCArrayToVTKmAOSArray(const conduit_node* mcarray, - bool force_signed, const vtkm::cont::DeviceAdapterId& deviceAdapterId); - static vtkSmartPointer<vtkDataArray> MCArrayToVTKmSOAArray(const conduit_node* mcarray, - bool force_signed, const vtkm::cont::DeviceAdapterId& deviceAdapterId); -#endif - private: vtkConduitArrayUtilities(const vtkConduitArrayUtilities&) = delete; void operator=(const vtkConduitArrayUtilities&) = delete; diff --git a/IO/CatalystConduit/vtkConduitArrayUtilitiesDevice.cxx b/IO/CatalystConduit/vtkConduitArrayUtilitiesDevice.cxx new file mode 100644 index 0000000000000000000000000000000000000000..0298e7e361fa77960693ac725ec980eb1d0722e8 --- /dev/null +++ b/IO/CatalystConduit/vtkConduitArrayUtilitiesDevice.cxx @@ -0,0 +1,354 @@ +// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen +// SPDX-License-Identifier: BSD-3-Clause +#include "vtkConduitArrayUtilitiesDevice.h" +#include "vtkConduitArrayUtilitiesInternals.h" + +#include "vtkArrayDispatch.h" +#include "vtkCellArray.h" +#include "vtkDataSetAttributes.h" +#include "vtkDeviceMemoryType.h" +#include "vtkLogger.h" +#include "vtkObjectFactory.h" +#include "vtkSOADataArrayTemplate.h" +#include "vtkSetGet.h" +#include "vtkTypeFloat32Array.h" +#include "vtkTypeFloat64Array.h" +#include "vtkTypeInt16Array.h" +#include "vtkTypeInt32Array.h" +#include "vtkTypeInt64Array.h" +#include "vtkTypeInt8Array.h" +#include "vtkTypeUInt16Array.h" +#include "vtkTypeUInt32Array.h" +#include "vtkTypeUInt64Array.h" +#include "vtkTypeUInt8Array.h" + +#include "vtkm/CellShape.h" +#include "vtkm/cont/ArrayHandle.h" +#include "vtkm/cont/ArrayHandleCast.h" +#include "vtkm/cont/CellSetSingleType.h" +#include "vtkmDataArray.h" +#include "vtkmlib/CellSetConverters.h" +#if defined(VTK_USE_CUDA) +#include <cuda_runtime_api.h> +#endif // VTK_USE_CUDA + +#include <catalyst_conduit.hpp> +#include <catalyst_conduit_blueprint.hpp> + +#include <type_traits> +#include <typeinfo> +#include <vector> + +namespace internals +{ +VTK_ABI_NAMESPACE_BEGIN + +using vtkmConnectivityArrays = vtkTypeList::Unique<vtkTypeList::Create<vtkmDataArray<vtkm::Int8>, + vtkmDataArray<vtkm::Int16>, vtkmDataArray<vtkm::Int32>, vtkmDataArray<vtkm::Int64>>>::Result; + +void AddOneIndexToOffset(vtkm::cont::ArrayHandle<vtkm::Id>& offset, size_t connectivitySize) +{ + size_t lastValue = offset.GetNumberOfValues(); + offset.Allocate(lastValue + 1, vtkm::CopyFlag::On); + auto portal = offset.WritePortal(); + portal.Set(lastValue, connectivitySize); +} + +template <typename OutputValueT, typename ArrayT> +vtkm::cont::ArrayHandle<OutputValueT> ToArrayHandle(ArrayT* input) +{ + // input is a vtkmDataArray<inputValueType> + auto inputUnknownHandle = input->GetVtkmUnknownArrayHandle(); + vtkm::cont::ArrayHandle<OutputValueT> output; + vtkm::cont::ArrayCopyShallowIfPossible(inputUnknownHandle, output); + return output; +} + +//---------------------------------------------------------------------------- +struct FromDeviceConduitToMonoShapedCellArray +{ + vtkIdType NumberOfPoints; + vtkIdType NumberOfPointsPerCell; + int VTKCellType; + vtkCellArray* CellArray; + + FromDeviceConduitToMonoShapedCellArray(vtkIdType numberOfPoints, vtkIdType numberOfPointsPerCell, + int vtkCellType, vtkCellArray* cellArray) + : NumberOfPoints(numberOfPoints) + , NumberOfPointsPerCell(numberOfPointsPerCell) + , VTKCellType(vtkCellType) + , CellArray(cellArray) + { + } + + template <typename ArrayT> + void operator()(ArrayT* input) + { + // input is a vtkmDataArray<inputValueType> + vtkm::cont::CellSetSingleType<> cellSet; + // VTK cell types and VTKm cell shapes have the same numbers + cellSet.Fill(this->NumberOfPoints, this->VTKCellType, this->NumberOfPointsPerCell, + internals::ToArrayHandle<vtkm::Id>(input)); + fromvtkm::Convert(cellSet, this->CellArray); + } +}; + +//---------------------------------------------------------------------------- +struct FromDeviceConduitToMixedCellArray +{ +public: + FromDeviceConduitToMixedCellArray(vtkIdType numberOfPoints, vtkCellArray* cellArray) + : NumberOfPoints(numberOfPoints) + , CellArray(cellArray) + { + } + + template <typename ArrayT1, typename ArrayT2, typename ArrayT3> + void operator()(ArrayT1* offsets, ArrayT2* shapes, ArrayT3* connectivity) + { + // conduit offsets array does not include the last index = + // connectivity.size() as CellSetExplicit + vtkm::cont::CellSetExplicit<> cellSet; + auto vtkmOffsets = ToArrayHandle<vtkm::Id>(offsets); + auto vtkmConnectivity = ToArrayHandle<vtkm::Id>(connectivity); + AddOneIndexToOffset(vtkmOffsets, vtkmConnectivity.GetNumberOfValues()); + cellSet.Fill( + this->NumberOfPoints, ToArrayHandle<vtkm::UInt8>(shapes), vtkmConnectivity, vtkmOffsets); + + fromvtkm::Convert(cellSet, this->CellArray); + } + +private: + vtkIdType NumberOfPoints; + vtkCellArray* CellArray; +}; + +VTK_ABI_NAMESPACE_END +} // internals + +VTK_ABI_NAMESPACE_BEGIN + +vtkStandardNewMacro(vtkConduitArrayUtilitiesDevice); +//---------------------------------------------------------------------------- +vtkConduitArrayUtilitiesDevice::vtkConduitArrayUtilitiesDevice() = default; + +//---------------------------------------------------------------------------- +vtkConduitArrayUtilitiesDevice::~vtkConduitArrayUtilitiesDevice() = default; + +#define vtkmAOSDataArrayConstructSingleComponent(dtype, nvals, raw_ptr, deviceAdapterId) \ + do \ + { \ + return make_vtkmDataArray(vtkm::cont::ArrayHandle<dtype>( \ + std::vector<vtkm::cont::internal::Buffer>{ vtkm::cont::internal::MakeBuffer( \ + deviceAdapterId, reinterpret_cast<dtype*>(raw_ptr), reinterpret_cast<dtype*>(raw_ptr), \ + vtkm::internal::NumberOfValuesToNumberOfBytes<dtype>(nvals), [](void*) {}, \ + vtkm::cont::internal::InvalidRealloc) })); \ + } while (0) + +#define vtkmAOSDataArrayConstructMultiComponent(dtype, ntups, ncomp, raw_ptr, deviceAdapterId) \ + do \ + { \ + return make_vtkmDataArray(vtkm::cont::ArrayHandle<vtkm::Vec<dtype, ncomp>>( \ + std::vector<vtkm::cont::internal::Buffer>{ vtkm::cont::internal::MakeBuffer( \ + deviceAdapterId, reinterpret_cast<dtype*>(raw_ptr), reinterpret_cast<dtype*>(raw_ptr), \ + vtkm::internal::NumberOfValuesToNumberOfBytes<dtype>(ntups * ncomp), [](void*) {}, \ + vtkm::cont::internal::InvalidRealloc) })); \ + } while (0) + +#define vtkmAOSDataArrayNumComponentsBody(dtype, ntups, ncomp, raw_ptr, deviceAdapterId) \ + switch (num_components) \ + { \ + case 1: \ + vtkmAOSDataArrayConstructSingleComponent(dtype, num_tuples, raw_ptr, deviceAdapterId); \ + case 2: \ + vtkmAOSDataArrayConstructMultiComponent(dtype, num_tuples, 2, raw_ptr, deviceAdapterId); \ + case 3: \ + vtkmAOSDataArrayConstructMultiComponent(dtype, num_tuples, 3, raw_ptr, deviceAdapterId); \ + case 4: \ + vtkmAOSDataArrayConstructMultiComponent(dtype, num_tuples, 4, raw_ptr, deviceAdapterId); \ + case 5: \ + vtkmAOSDataArrayConstructMultiComponent(dtype, num_tuples, 5, raw_ptr, deviceAdapterId); \ + case 6: \ + default: \ + vtkmAOSDataArrayConstructMultiComponent(dtype, num_tuples, 6, raw_ptr, deviceAdapterId); \ + } + +#define vtkmAOSDataArrayCase(conduitTypeId, dtype, ntups, ncomp, raw_ptr, deviceAdapterId) \ + case conduitTypeId: \ + { \ + vtkmAOSDataArrayNumComponentsBody(dtype, ntups, ncomp, raw_ptr, deviceAdapterId); \ + } \ + break + +//---------------------------------------------------------------------------- +vtkSmartPointer<vtkDataArray> vtkConduitArrayUtilitiesDevice::MCArrayToVTKmAOSArray( + const conduit_node* c_mcarray, bool force_signed, + const vtkm::cont::DeviceAdapterId& deviceAdapterId) +{ + const conduit_cpp::Node mcarray = conduit_cpp::cpp_node(const_cast<conduit_node*>(c_mcarray)); + const auto& child0 = mcarray.child(0); + const conduit_cpp::DataType dtype0 = child0.dtype(); + + const int num_components = static_cast<int>(mcarray.number_of_children()); + const vtkIdType num_tuples = static_cast<vtkIdType>(dtype0.number_of_elements()); + void* raw_ptr = const_cast<void*>(child0.element_ptr(0)); + + using conduit_dtype = conduit_cpp::DataType::Id; + + switch (internals::GetTypeId(dtype0.id(), force_signed)) + { + vtkmAOSDataArrayCase( + conduit_dtype::int8, vtkm::Int8, num_tuples, num_components, raw_ptr, deviceAdapterId); + vtkmAOSDataArrayCase( + conduit_dtype::int16, vtkm::Int16, num_tuples, num_components, raw_ptr, deviceAdapterId); + vtkmAOSDataArrayCase( + conduit_dtype::int32, vtkm::Int32, num_tuples, num_components, raw_ptr, deviceAdapterId); + vtkmAOSDataArrayCase( + conduit_dtype::int64, vtkm::Int64, num_tuples, num_components, raw_ptr, deviceAdapterId); + vtkmAOSDataArrayCase( + conduit_dtype::uint8, vtkm::UInt8, num_tuples, num_components, raw_ptr, deviceAdapterId); + vtkmAOSDataArrayCase( + conduit_dtype::uint16, vtkm::UInt16, num_tuples, num_components, raw_ptr, deviceAdapterId); + vtkmAOSDataArrayCase( + conduit_dtype::uint32, vtkm::UInt32, num_tuples, num_components, raw_ptr, deviceAdapterId); + vtkmAOSDataArrayCase( + conduit_dtype::uint64, vtkm::UInt64, num_tuples, num_components, raw_ptr, deviceAdapterId); + vtkmAOSDataArrayCase( + conduit_dtype::float32, vtkm::Float32, num_tuples, num_components, raw_ptr, deviceAdapterId); + vtkmAOSDataArrayCase( + conduit_dtype::float64, vtkm::Float64, num_tuples, num_components, raw_ptr, deviceAdapterId); + default: + vtkLogF(ERROR, "unsupported data type '%s' ", dtype0.name().c_str()); + return {}; + } + return {}; +} + +#define vtkmSOADataArrayConstructSingleComponent(dtype, nvals, deviceAdapterId) \ + do \ + { \ + std::vector<vtkm::cont::internal::Buffer> buffers; \ + buffers.reserve(num_components); \ + for (int cc = 0; cc < num_components; ++cc) \ + { \ + buffers.push_back(vtkm::cont::internal::MakeBuffer( \ + deviceAdapterId, \ + reinterpret_cast<dtype*>(const_cast<void*>(mcarray.child(cc).element_ptr(0))), \ + reinterpret_cast<dtype*>(const_cast<void*>(mcarray.child(cc).element_ptr(0))), \ + vtkm::internal::NumberOfValuesToNumberOfBytes<dtype>(nvals), [](void*) {}, \ + vtkm::cont::internal::InvalidRealloc)); \ + } \ + return make_vtkmDataArray(vtkm::cont::ArrayHandle<dtype>(buffers)); \ + } while (0) + +#define vtkmSOADataArrayConstructMultiComponent(dtype, ntups, ncomp, deviceAdapterId) \ + do \ + { \ + std::vector<vtkm::cont::internal::Buffer> buffers; \ + buffers.reserve(num_components); \ + for (int cc = 0; cc < num_components; ++cc) \ + { \ + buffers.push_back(vtkm::cont::internal::MakeBuffer( \ + deviceAdapterId, \ + reinterpret_cast<dtype*>(const_cast<void*>(mcarray.child(cc).element_ptr(0))), \ + reinterpret_cast<dtype*>(const_cast<void*>(mcarray.child(cc).element_ptr(0))), \ + vtkm::internal::NumberOfValuesToNumberOfBytes<dtype>(num_tuples), [](void*) {}, \ + vtkm::cont::internal::InvalidRealloc)); \ + } \ + return make_vtkmDataArray(vtkm::cont::ArrayHandleSOA<vtkm::Vec<dtype, ncomp>>(buffers)); \ + } while (0) + +#define vtkmSOADataArrayCase(conduitTypeId, dtype, ntups, ncomp, deviceAdapterId) \ + case conduitTypeId: \ + { \ + switch (num_components) \ + { \ + case 1: \ + vtkmSOADataArrayConstructSingleComponent(dtype, num_tuples, deviceAdapterId); \ + case 2: \ + vtkmSOADataArrayConstructMultiComponent(dtype, num_tuples, 2, deviceAdapterId); \ + case 3: \ + vtkmSOADataArrayConstructMultiComponent(dtype, num_tuples, 3, deviceAdapterId); \ + case 4: \ + vtkmSOADataArrayConstructMultiComponent(dtype, num_tuples, 4, deviceAdapterId); \ + case 5: \ + vtkmSOADataArrayConstructMultiComponent(dtype, num_tuples, 5, deviceAdapterId); \ + case 6: \ + default: \ + vtkmSOADataArrayConstructMultiComponent(dtype, num_tuples, 6, deviceAdapterId); \ + } \ + } \ + break + +//---------------------------------------------------------------------------- +vtkSmartPointer<vtkDataArray> vtkConduitArrayUtilitiesDevice::MCArrayToVTKmSOAArray( + const conduit_node* c_mcarray, bool force_signed, + const vtkm::cont::DeviceAdapterId& deviceAdapterId) +{ + const conduit_cpp::Node mcarray = conduit_cpp::cpp_node(const_cast<conduit_node*>(c_mcarray)); + const conduit_cpp::DataType dtype0 = mcarray.child(0).dtype(); + const int num_components = static_cast<int>(mcarray.number_of_children()); + const vtkIdType num_tuples = static_cast<vtkIdType>(dtype0.number_of_elements()); + + using conduit_dtype = conduit_cpp::DataType::Id; + + switch (internals::GetTypeId(dtype0.id(), force_signed)) + { + vtkmSOADataArrayCase( + conduit_dtype::int8, vtkm::Int8, num_tuples, num_components, deviceAdapterId); + vtkmSOADataArrayCase( + conduit_dtype::int16, vtkm::Int16, num_tuples, num_components, deviceAdapterId); + vtkmSOADataArrayCase( + conduit_dtype::int32, vtkm::Int32, num_tuples, num_components, deviceAdapterId); + vtkmSOADataArrayCase( + conduit_dtype::int64, vtkm::Int64, num_tuples, num_components, deviceAdapterId); + vtkmSOADataArrayCase( + conduit_dtype::uint8, vtkm::UInt8, num_tuples, num_components, deviceAdapterId); + vtkmSOADataArrayCase( + conduit_dtype::uint16, vtkm::UInt16, num_tuples, num_components, deviceAdapterId); + vtkmSOADataArrayCase( + conduit_dtype::uint32, vtkm::UInt32, num_tuples, num_components, deviceAdapterId); + vtkmSOADataArrayCase( + conduit_dtype::uint64, vtkm::UInt64, num_tuples, num_components, deviceAdapterId); + vtkmSOADataArrayCase( + conduit_dtype::float32, vtkm::Float32, num_tuples, num_components, deviceAdapterId); + vtkmSOADataArrayCase( + conduit_dtype::float64, vtkm::Float64, num_tuples, num_components, deviceAdapterId); + default: + vtkLogF(ERROR, "unsupported data type '%s' ", dtype0.name().c_str()); + return {}; + } + return {}; +} + +bool vtkConduitArrayUtilitiesDevice::IfVTKmConvertVTK(vtkIdType numberOfPoints, int cellType, + vtkIdType cellSize, vtkDataArray* connectivity, vtkCellArray* cellArray) +{ + using Dispatcher = vtkArrayDispatch::DispatchByArray<internals::vtkmConnectivityArrays>; + internals::FromDeviceConduitToMonoShapedCellArray worker{ numberOfPoints, cellSize, cellType, + cellArray }; + return Dispatcher::Execute(connectivity, worker); +} + +bool vtkConduitArrayUtilitiesDevice::IfVTKmConvertVTK(vtkIdType numberOfPoints, + vtkDataArray* offsets, vtkDataArray* shapes, vtkDataArray* elements, vtkCellArray* cellArray) +{ + using VtkmDispatcher = + vtkArrayDispatch::Dispatch3ByArrayWithSameValueType<internals::vtkmConnectivityArrays, + internals::vtkmConnectivityArrays, internals::vtkmConnectivityArrays>; + internals::FromDeviceConduitToMixedCellArray deviceWorker{ numberOfPoints, cellArray }; + return VtkmDispatcher::Execute(offsets, shapes, elements, deviceWorker); +} + +bool vtkConduitArrayUtilitiesDevice::CanRunOn(const vtkm::cont::DeviceAdapterId& deviceAdapterId) +{ + vtkm::cont::RuntimeDeviceTracker& runtimeTracker = vtkm::cont::GetRuntimeDeviceTracker(); + return runtimeTracker.CanRunOn(deviceAdapterId); +} + +//---------------------------------------------------------------------------- +void vtkConduitArrayUtilitiesDevice::PrintSelf(ostream& os, vtkIndent indent) +{ + this->Superclass::PrintSelf(os, indent); +} +VTK_ABI_NAMESPACE_END diff --git a/IO/CatalystConduit/vtkConduitArrayUtilitiesDevice.h b/IO/CatalystConduit/vtkConduitArrayUtilitiesDevice.h new file mode 100644 index 0000000000000000000000000000000000000000..14f2697c26ed8f59b5a6556224ae533d61b2cd3d --- /dev/null +++ b/IO/CatalystConduit/vtkConduitArrayUtilitiesDevice.h @@ -0,0 +1,59 @@ +// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen +// SPDX-License-Identifier: BSD-3-Clause +/** + * @class vtkConduitArrayUtilitiesDevice + * @brief helper to convert Conduit arrays to VTK arrays. + * @ingroup Insitu + * + * vtkConduitArrayUtilitiesDevice is intended to convert Conduit nodes satisfying the + * `mcarray` protocol to VTK arrays. It uses zero-copy, as much as possible. + * Currently implementation fails if zero-copy is not possible. In future, that + * may be changed to do a deep-copy (with appropriate warnings) if necessary. + * + * This is primarily designed for use by vtkConduitSource. + */ + +#ifndef vtkConduitArrayUtilitiesDevice_h +#define vtkConduitArrayUtilitiesDevice_h + +#include "vtkIOCatalystConduitModule.h" // for exports +#include "vtkObject.h" +#include "vtkSmartPointer.h" // for vtkSmartPointer + +#include "conduit.h" // for conduit_node + +#include "vtkm/cont/DeviceAdapterTag.h" // for vtkm::cont::DeviceAdapterId +#include <string> // for std::string + +VTK_ABI_NAMESPACE_BEGIN +class vtkCellArray; +class vtkDataArray; + +class VTKIOCATALYSTCONDUIT_EXPORT vtkConduitArrayUtilitiesDevice : public vtkObject +{ +public: + static vtkConduitArrayUtilitiesDevice* New(); + vtkTypeMacro(vtkConduitArrayUtilitiesDevice, vtkObject); + void PrintSelf(ostream& os, vtkIndent indent) override; + + static vtkSmartPointer<vtkDataArray> MCArrayToVTKmAOSArray(const conduit_node* mcarray, + bool force_signed, const vtkm::cont::DeviceAdapterId& deviceAdapterId); + static vtkSmartPointer<vtkDataArray> MCArrayToVTKmSOAArray(const conduit_node* mcarray, + bool force_signed, const vtkm::cont::DeviceAdapterId& deviceAdapterId); + static bool IfVTKmConvertVTK(vtkIdType numberOfPoints, int cellType, vtkIdType cellSize, + vtkDataArray* connectivity, vtkCellArray* cellArray); + static bool IfVTKmConvertVTK(vtkIdType numberOfPoints, vtkDataArray* offsets, + vtkDataArray* shapes, vtkDataArray* elements, vtkCellArray* cellArray); + static bool CanRunOn(const vtkm::cont::DeviceAdapterId& deviceAdapterId); + +protected: + vtkConduitArrayUtilitiesDevice(); + ~vtkConduitArrayUtilitiesDevice() override; + +private: + vtkConduitArrayUtilitiesDevice(const vtkConduitArrayUtilitiesDevice&) = delete; + void operator=(const vtkConduitArrayUtilitiesDevice&) = delete; +}; +VTK_ABI_NAMESPACE_END + +#endif diff --git a/IO/CatalystConduit/vtkConduitArrayUtilitiesInternals.cxx b/IO/CatalystConduit/vtkConduitArrayUtilitiesInternals.cxx new file mode 100644 index 0000000000000000000000000000000000000000..84f9b430e19436ce02192c5fb57002a3381e2269 --- /dev/null +++ b/IO/CatalystConduit/vtkConduitArrayUtilitiesInternals.cxx @@ -0,0 +1,72 @@ +// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen +// SPDX-License-Identifier: BSD-3-Clause +#include "vtkConduitArrayUtilitiesDevice.h" + +#include "vtkArrayDispatch.h" +#include "vtkCellArray.h" +#include "vtkDataSetAttributes.h" +#include "vtkDeviceMemoryType.h" +#include "vtkLogger.h" +#include "vtkObjectFactory.h" +#include "vtkSOADataArrayTemplate.h" +#include "vtkSetGet.h" +#include "vtkTypeFloat32Array.h" +#include "vtkTypeFloat64Array.h" +#include "vtkTypeInt16Array.h" +#include "vtkTypeInt32Array.h" +#include "vtkTypeInt64Array.h" +#include "vtkTypeInt8Array.h" +#include "vtkTypeUInt16Array.h" +#include "vtkTypeUInt32Array.h" +#include "vtkTypeUInt64Array.h" +#include "vtkTypeUInt8Array.h" + +#include "vtkm/CellShape.h" +#include "vtkm/cont/ArrayHandle.h" +#include "vtkm/cont/ArrayHandleCast.h" +#include "vtkm/cont/CellSetSingleType.h" +#include "vtkmDataArray.h" +#include "vtkmlib/CellSetConverters.h" +#if defined(VTK_USE_CUDA) +#include <cuda_runtime_api.h> +#endif // VTK_USE_CUDA + +#include <catalyst_conduit.hpp> +#include <catalyst_conduit_blueprint.hpp> + +#include <type_traits> +#include <typeinfo> +#include <vector> + +namespace internals +{ +VTK_ABI_NAMESPACE_BEGIN + +//---------------------------------------------------------------------------- +conduit_cpp::DataType::Id GetTypeId(conduit_cpp::DataType::Id type, bool force_signed) +{ + if (!force_signed) + { + return type; + } + switch (type) + { + case conduit_cpp::DataType::Id::uint8: + return conduit_cpp::DataType::Id::int8; + + case conduit_cpp::DataType::Id::uint16: + return conduit_cpp::DataType::Id::int16; + + case conduit_cpp::DataType::Id::uint32: + return conduit_cpp::DataType::Id::int32; + + case conduit_cpp::DataType::Id::uint64: + return conduit_cpp::DataType::Id::int64; + + default: + return type; + } +} + +VTK_ABI_NAMESPACE_END +} // internals diff --git a/IO/CatalystConduit/vtkConduitArrayUtilitiesInternals.h b/IO/CatalystConduit/vtkConduitArrayUtilitiesInternals.h new file mode 100644 index 0000000000000000000000000000000000000000..c276efcd65e9a66800cd6b077f7633646739f3c9 --- /dev/null +++ b/IO/CatalystConduit/vtkConduitArrayUtilitiesInternals.h @@ -0,0 +1,28 @@ +// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen +// SPDX-License-Identifier: BSD-3-Clause +/** + * @class vtkConduitArrayUtilitiesInternals + * @brief helper to convert Conduit arrays to VTK arrays. + * @ingroup Insitu + * + * vtkConduitArrayUtilitiesInternals is intended to convert Conduit nodes satisfying the + * `mcarray` protocol to VTK arrays. It uses zero-copy, as much as possible. + * Currently implementation fails if zero-copy is not possible. In future, that + * may be changed to do a deep-copy (with appropriate warnings) if necessary. + * + * This is primarily designed for use by vtkConduitSource. + */ + +#ifndef vtkConduitArrayUtilitiesInternals_h +#define vtkConduitArrayUtilitiesInternals_h + +#include <catalyst_conduit.hpp> // for conduit_cpp::DataType::Id + +namespace internals +{ +VTK_ABI_NAMESPACE_BEGIN +conduit_cpp::DataType::Id GetTypeId(conduit_cpp::DataType::Id type, bool force_signed); +VTK_ABI_NAMESPACE_END +}; + +#endif