[tmva][sofie] Fix big endian

tmva/sofie_parsers/src/RModelParser_ONNX.cxx

@@ -4,6 +4,7 @@
 
 #include <stdexcept>
 #include <string>
+#include <cstring>
 #include <memory>
 #include <cassert>
 #include <iostream>
@@ -155,6 +156,45 @@ struct ExtractDataFromTP<int64_t> {
    }
 };
 
+#ifndef R__BYTESWAP
+namespace {
+
+// Copy nbytes from source to dest, byte-swapping each N-byte element. The
+// temporary avoids misaligned loads from the protobuf string buffer and makes
+// in-place swapping (dest == source) valid.
+template <std::size_t N>
+void CopyBswap(void *dest, const void *source, std::size_t nbytes)
+{
+   using value_type = typename RByteSwap<N>::value_type;
+   auto dst = static_cast<unsigned char *>(dest);
+   auto src = static_cast<const unsigned char *>(source);
+   for (std::size_t k = 0; k < nbytes; k += N) {
+      value_type v;
+      std::memcpy(&v, src + k, N);
+      v = RByteSwap<N>::bswap(v);
+      std::memcpy(dst + k, &v, N);
+   }
+}
+
+// Copy a buffer of little-endian tensor elements to host (big-endian) byte order
+void CopyLEToHost(void *dest, const void *source, std::size_t nbytes, ETensorType tensor_type)
+{
+   switch (GetTypeSize(tensor_type)) {
+   case 1:
+      if (dest != source)
+         std::memcpy(dest, source, nbytes);
+      break;
+   case 2: CopyBswap<2>(dest, source, nbytes); break;
+   case 4: CopyBswap<4>(dest, source, nbytes); break;
+   case 8: CopyBswap<8>(dest, source, nbytes); break;
+   default:
+      throw std::runtime_error("Data type " + ConvertTypeToString(tensor_type) + " in tensor is not supported!\n");
+   }
+}
+
+} // anonymous namespace
+#endif
+
 std::shared_ptr<void> RModelParser_ONNX::GetInitializedTensorData(onnx::TensorProto *tensorproto, size_t tensor_size, ETensorType tensor_type)
 {
 
@@ -172,13 +212,10 @@ std::shared_ptr<void> RModelParser_ONNX::GetInitializedTensorData(onnx::TensorPr
          std::memcpy(data.get(), tensorproto->raw_data().c_str(), tensor_size);
 #else
          // big-endian architectures - need to swap bytes
-         for (std::size_t k = 0; k < tensor_size; ++k)
-            (reinterpret_cast<typename RByteSwap<sizeof(uint8_t)>::value_type *>(data.get()))[k] =
-               RByteSwap<sizeof(T)>::bswap((reinterpret_cast<const typename RByteSwap<sizeof(uint8_t)>::value_type *>(
-                  tensorproto->raw_data().c_str()))[k]);
+         CopyLEToHost(data.get(), tensorproto->raw_data().c_str(), tensor_size, tensor_type);
 #endif
       } else {
-         // case tensor data are stored as specific types and now in raw_data
+         // case tensor data are stored as specific types and not in raw_data
          switch (tensor_type) {
             case ETensorType::FLOAT: {
                ExtractDataFromTP<float>::Copy(tensorproto, data.get(), tensor_size/ 4);
@@ -200,7 +237,7 @@ std::shared_ptr<void> RModelParser_ONNX::GetInitializedTensorData(onnx::TensorPr
                throw std::runtime_error("TMVA::SOFIE - ExtractData from TP in BOOL not supported");
                break;
             }
-             case ETensorType::UINT8: {
+            case ETensorType::UINT8: {
                throw std::runtime_error("TMVA::SOFIE - ExtractData from TP in UINT8 not supported");
                break;
             }
@@ -238,6 +275,10 @@ std::shared_ptr<void> RModelParser_ONNX::GetInitializedTensorData(onnx::TensorPr
 
       fDataFile.seekg(offset);
       fDataFile.read(reinterpret_cast<char *>(data.get()), buffer_size);
+#ifndef R__BYTESWAP
+      // external data is stored little-endian like raw_data - swap in place
+      CopyLEToHost(data.get(), data.get(), buffer_size, tensor_type);
+#endif
    }
 
    return data;