Macros | Functions | Variables
cxx11_tensor_image_patch_sycl.cpp File Reference
#include "main.h"
#include <unsupported/Eigen/CXX11/Tensor>

Macros

#define EIGEN_TEST_NO_LONGDOUBLE
 
#define EIGEN_TEST_NO_COMPLEX
 
#define EIGEN_DEFAULT_DENSE_INDEX_TYPE   int64_t
 
#define EIGEN_USE_SYCL
 

Functions

template<typename DataType , typename IndexType >
static void test_simple_image_patch_sycl (const Eigen::SyclDevice &sycl_device)
 
template<typename DataType , typename IndexType >
static void test_patch_padding_valid_sycl (const Eigen::SyclDevice &sycl_device)
 
template<typename DataType , typename IndexType >
static void test_patch_padding_valid_same_value_sycl (const Eigen::SyclDevice &sycl_device)
 
template<typename DataType , typename IndexType >
static void test_patch_padding_same_sycl (const Eigen::SyclDevice &sycl_device)
 
template<typename DataType , typename IndexType >
static void test_patch_no_extra_dim_sycl (const Eigen::SyclDevice &sycl_device)
 
template<typename DataType , typename IndexType >
static void test_imagenet_patches_sycl (const Eigen::SyclDevice &sycl_device)
 
template<typename DataType , typename dev_Selector >
void sycl_tensor_image_patch_test_per_device (dev_Selector s)
 
 EIGEN_DECLARE_TEST (cxx11_tensor_image_patch_sycl)
 

Variables

static const int DataLayout = ColMajor
 

Macro Definition Documentation

◆ EIGEN_DEFAULT_DENSE_INDEX_TYPE

#define EIGEN_DEFAULT_DENSE_INDEX_TYPE   int64_t

◆ EIGEN_TEST_NO_COMPLEX

#define EIGEN_TEST_NO_COMPLEX

◆ EIGEN_TEST_NO_LONGDOUBLE

#define EIGEN_TEST_NO_LONGDOUBLE

◆ EIGEN_USE_SYCL

#define EIGEN_USE_SYCL

Function Documentation

◆ EIGEN_DECLARE_TEST()

EIGEN_DECLARE_TEST ( cxx11_tensor_image_patch_sycl  )
1151  {
1152  for (const auto& device : Eigen::get_sycl_supported_devices()) {
1153  CALL_SUBTEST(sycl_tensor_image_patch_test_per_device<float>(device));
1154  }
1155 }
CALL_SUBTEST
#define CALL_SUBTEST(FUNC)
Definition: main.h:382

References CALL_SUBTEST.

◆ sycl_tensor_image_patch_test_per_device()

template<typename DataType , typename dev_Selector >
void sycl_tensor_image_patch_test_per_device ( dev_Selector  s)
1141  {
1142  QueueInterface queueInterface(s);
1143  auto sycl_device = Eigen::SyclDevice(&queueInterface);
1144  test_simple_image_patch_sycl<DataType, int64_t>(sycl_device);
1145  test_patch_padding_valid_sycl<DataType, int64_t>(sycl_device);
1146  test_patch_padding_valid_same_value_sycl<DataType, int64_t>(sycl_device);
1147  test_patch_padding_same_sycl<DataType, int64_t>(sycl_device);
1148  test_patch_no_extra_dim_sycl<DataType, int64_t>(sycl_device);
1149  test_imagenet_patches_sycl<DataType, int64_t>(sycl_device);
1150 }
s
RealScalar s
Definition: level1_cplx_impl.h:130

References s.

◆ test_imagenet_patches_sycl()

template<typename DataType , typename IndexType >
static void test_imagenet_patches_sycl ( const Eigen::SyclDevice &  sycl_device)
static
821  {
822  // Test the code on typical configurations used by the 'imagenet' benchmarks at
823  // https://github.com/soumith/convnet-benchmarks
824  // ColMajor
825  IndexType sizeDim1 = 3;
826  IndexType sizeDim2 = 128;
827  IndexType sizeDim3 = 128;
828  IndexType sizeDim4 = 16;
829  array<IndexType, 4> tensorColMajorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
830  Tensor<DataType, 4, DataLayout, IndexType> l_in_col_major(tensorColMajorRange);
831  l_in_col_major.setRandom();
832 
833  DataType* gpu_data_l_in_col_major =
834  static_cast<DataType*>(sycl_device.allocate(l_in_col_major.size() * sizeof(DataType)));
835  TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_l_in_col_major(gpu_data_l_in_col_major, tensorColMajorRange);
836 
837  sycl_device.memcpyHostToDevice(gpu_data_l_in_col_major, l_in_col_major.data(),
838  (l_in_col_major.size()) * sizeof(DataType));
839 
840  array<IndexType, 5> patchTensorRange = {{sizeDim1, 11, 11, sizeDim2 * sizeDim3, sizeDim4}};
841  Tensor<DataType, 5, DataLayout, IndexType> l_out_col_major(patchTensorRange);
842  size_t patchTensorBuffSize = l_out_col_major.size() * sizeof(DataType);
843  DataType* gpu_data_l_out_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
844  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_l_out_col_major(gpu_data_l_out_col_major, patchTensorRange);
845  gpu_l_out_col_major.device(sycl_device) = gpu_l_in_col_major.extract_image_patches(11, 11);
846  sycl_device.memcpyDeviceToHost(l_out_col_major.data(), gpu_data_l_out_col_major, patchTensorBuffSize);
847 
848  VERIFY_IS_EQUAL(l_out_col_major.dimension(0), sizeDim1);
849  VERIFY_IS_EQUAL(l_out_col_major.dimension(1), 11);
850  VERIFY_IS_EQUAL(l_out_col_major.dimension(2), 11);
851  VERIFY_IS_EQUAL(l_out_col_major.dimension(3), sizeDim2 * sizeDim3);
852  VERIFY_IS_EQUAL(l_out_col_major.dimension(4), sizeDim4);
853 
854  // RowMajor
855  patchTensorRange = {{sizeDim4, sizeDim2 * sizeDim3, 11, 11, sizeDim1}};
856  Tensor<DataType, 5, RowMajor, IndexType> l_out_row_major(patchTensorRange);
857  patchTensorBuffSize = l_out_row_major.size() * sizeof(DataType);
858  DataType* gpu_data_l_out_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
859  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_l_out_row_major(gpu_data_l_out_row_major, patchTensorRange);
860  gpu_l_out_row_major.device(sycl_device) = gpu_l_in_col_major.swap_layout().extract_image_patches(11, 11);
861  sycl_device.memcpyDeviceToHost(l_out_row_major.data(), gpu_data_l_out_row_major, patchTensorBuffSize);
862 
863  VERIFY_IS_EQUAL(l_out_row_major.dimension(0), sizeDim4);
864  VERIFY_IS_EQUAL(l_out_row_major.dimension(1), sizeDim2 * sizeDim3);
865  VERIFY_IS_EQUAL(l_out_row_major.dimension(2), 11);
866  VERIFY_IS_EQUAL(l_out_row_major.dimension(3), 11);
867  VERIFY_IS_EQUAL(l_out_row_major.dimension(4), sizeDim1);
868 
869  for (IndexType b = 0; b < 16; ++b) {
870  for (IndexType i = 0; i < 128; ++i) {
871  for (IndexType j = 0; j < 128; ++j) {
872  IndexType patchId = i + 128 * j;
873  for (IndexType c = 0; c < 11; ++c) {
874  for (IndexType r = 0; r < 11; ++r) {
875  for (IndexType d = 0; d < 3; ++d) {
876  DataType expected = 0.0f;
877  if (r - 5 + i >= 0 && c - 5 + j >= 0 && r - 5 + i < 128 && c - 5 + j < 128) {
878  expected = l_in_col_major(d, r - 5 + i, c - 5 + j, b);
879  }
880  // ColMajor
881  if (l_out_col_major(d, r, c, patchId, b) != expected) {
882  std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
883  << " d=" << d << " b=" << b << std::endl;
884  }
885  VERIFY_IS_EQUAL(l_out_col_major(d, r, c, patchId, b), expected);
886  // RowMajor
887  if (l_out_row_major(b, patchId, c, r, d) != expected) {
888  std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
889  << " d=" << d << " b=" << b << std::endl;
890  }
891  VERIFY_IS_EQUAL(l_out_row_major(b, patchId, c, r, d), expected);
892  }
893  }
894  }
895  }
896  }
897  }
898 
899  // ColMajor
900  sycl_device.deallocate(gpu_data_l_in_col_major);
901  sycl_device.deallocate(gpu_data_l_out_col_major);
902  sizeDim1 = 16;
903  sizeDim2 = 64;
904  sizeDim3 = 64;
905  sizeDim4 = 32;
906  tensorColMajorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
907  l_in_col_major.resize(tensorColMajorRange);
908  l_in_col_major.setRandom();
909  gpu_data_l_in_col_major = static_cast<DataType*>(sycl_device.allocate(l_in_col_major.size() * sizeof(DataType)));
910  TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_l_in_col_major_resize1(gpu_data_l_in_col_major,
911  tensorColMajorRange);
912 
913  patchTensorRange = {{sizeDim1, 9, 9, sizeDim2 * sizeDim3, sizeDim4}};
914  l_out_col_major.resize(patchTensorRange);
915  patchTensorBuffSize = l_out_col_major.size() * sizeof(DataType);
916  gpu_data_l_out_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
917  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_l_out_col_major_resize1(gpu_data_l_out_col_major,
918  patchTensorRange);
919  sycl_device.memcpyHostToDevice(gpu_data_l_in_col_major, l_in_col_major.data(),
920  (l_in_col_major.size()) * sizeof(DataType));
921  gpu_l_out_col_major_resize1.device(sycl_device) = gpu_l_in_col_major_resize1.extract_image_patches(9, 9);
922  sycl_device.memcpyDeviceToHost(l_out_col_major.data(), gpu_data_l_out_col_major, patchTensorBuffSize);
923  VERIFY_IS_EQUAL(l_out_col_major.dimension(0), 16);
924  VERIFY_IS_EQUAL(l_out_col_major.dimension(1), 9);
925  VERIFY_IS_EQUAL(l_out_col_major.dimension(2), 9);
926  VERIFY_IS_EQUAL(l_out_col_major.dimension(3), 64 * 64);
927  VERIFY_IS_EQUAL(l_out_col_major.dimension(4), 32);
928 
929  // RowMajor
930  sycl_device.deallocate(gpu_data_l_out_row_major);
931  patchTensorRange = {{sizeDim4, sizeDim2 * sizeDim3, 9, 9, sizeDim1}};
932  l_out_row_major.resize(patchTensorRange);
933  patchTensorBuffSize = l_out_row_major.size() * sizeof(DataType);
934  gpu_data_l_out_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
935  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_l_out_row_major_resize1(gpu_data_l_out_row_major,
936  patchTensorRange);
937  gpu_l_out_row_major_resize1.device(sycl_device) =
938  gpu_l_in_col_major_resize1.swap_layout().extract_image_patches(9, 9);
939  sycl_device.memcpyDeviceToHost(l_out_row_major.data(), gpu_data_l_out_row_major, patchTensorBuffSize);
940 
941  VERIFY_IS_EQUAL(l_out_row_major.dimension(0), 32);
942  VERIFY_IS_EQUAL(l_out_row_major.dimension(1), 64 * 64);
943  VERIFY_IS_EQUAL(l_out_row_major.dimension(2), 9);
944  VERIFY_IS_EQUAL(l_out_row_major.dimension(3), 9);
945  VERIFY_IS_EQUAL(l_out_row_major.dimension(4), 16);
946 
947  for (IndexType b = 0; b < 32; ++b) {
948  for (IndexType i = 0; i < 64; ++i) {
949  for (IndexType j = 0; j < 64; ++j) {
950  IndexType patchId = i + 64 * j;
951  for (IndexType c = 0; c < 9; ++c) {
952  for (IndexType r = 0; r < 9; ++r) {
953  for (IndexType d = 0; d < 16; ++d) {
954  DataType expected = 0.0f;
955  if (r - 4 + i >= 0 && c - 4 + j >= 0 && r - 4 + i < 64 && c - 4 + j < 64) {
956  expected = l_in_col_major(d, r - 4 + i, c - 4 + j, b);
957  }
958  // ColMajor
959  if (l_out_col_major(d, r, c, patchId, b) != expected) {
960  std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
961  << " d=" << d << " b=" << b << std::endl;
962  }
963  VERIFY_IS_EQUAL(l_out_col_major(d, r, c, patchId, b), expected);
964  // RowMajor
965  if (l_out_row_major(b, patchId, c, r, d) != expected) {
966  std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
967  << " d=" << d << " b=" << b << std::endl;
968  }
969  VERIFY_IS_EQUAL(l_out_row_major(b, patchId, c, r, d), expected);
970  }
971  }
972  }
973  }
974  }
975  }
976 
977  // ColMajor
978 
979  sycl_device.deallocate(gpu_data_l_in_col_major);
980  sycl_device.deallocate(gpu_data_l_out_col_major);
981  sizeDim1 = 32;
982  sizeDim2 = 16;
983  sizeDim3 = 16;
984  sizeDim4 = 32;
985  tensorColMajorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
986  l_in_col_major.resize(tensorColMajorRange);
987  l_in_col_major.setRandom();
988  gpu_data_l_in_col_major = static_cast<DataType*>(sycl_device.allocate(l_in_col_major.size() * sizeof(DataType)));
989  TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_l_in_col_major_resize2(gpu_data_l_in_col_major,
990  tensorColMajorRange);
991 
992  patchTensorRange = {{sizeDim1, 7, 7, sizeDim2 * sizeDim3, sizeDim4}};
993  l_out_col_major.resize(patchTensorRange);
994  patchTensorBuffSize = l_out_col_major.size() * sizeof(DataType);
995  gpu_data_l_out_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
996  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_l_out_col_major_resize2(gpu_data_l_out_col_major,
997  patchTensorRange);
998  sycl_device.memcpyHostToDevice(gpu_data_l_in_col_major, l_in_col_major.data(),
999  (l_in_col_major.size()) * sizeof(DataType));
1000  gpu_l_out_col_major_resize2.device(sycl_device) = gpu_l_in_col_major_resize2.extract_image_patches(7, 7);
1001  sycl_device.memcpyDeviceToHost(l_out_col_major.data(), gpu_data_l_out_col_major, patchTensorBuffSize);
1002 
1003  VERIFY_IS_EQUAL(l_out_col_major.dimension(0), 32);
1004  VERIFY_IS_EQUAL(l_out_col_major.dimension(1), 7);
1005  VERIFY_IS_EQUAL(l_out_col_major.dimension(2), 7);
1006  VERIFY_IS_EQUAL(l_out_col_major.dimension(3), 16 * 16);
1007  VERIFY_IS_EQUAL(l_out_col_major.dimension(4), 32);
1008 
1009  // RowMajor
1010  sycl_device.deallocate(gpu_data_l_out_row_major);
1011  patchTensorRange = {{sizeDim4, sizeDim2 * sizeDim3, 7, 7, sizeDim1}};
1012  l_out_row_major.resize(patchTensorRange);
1013  patchTensorBuffSize = l_out_row_major.size() * sizeof(DataType);
1014  gpu_data_l_out_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
1015  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_l_out_row_major_resize2(gpu_data_l_out_row_major,
1016  patchTensorRange);
1017  gpu_l_out_row_major_resize2.device(sycl_device) =
1018  gpu_l_in_col_major_resize2.swap_layout().extract_image_patches(7, 7);
1019  sycl_device.memcpyDeviceToHost(l_out_row_major.data(), gpu_data_l_out_row_major, patchTensorBuffSize);
1020 
1021  VERIFY_IS_EQUAL(l_out_row_major.dimension(0), 32);
1022  VERIFY_IS_EQUAL(l_out_row_major.dimension(1), 16 * 16);
1023  VERIFY_IS_EQUAL(l_out_row_major.dimension(2), 7);
1024  VERIFY_IS_EQUAL(l_out_row_major.dimension(3), 7);
1025  VERIFY_IS_EQUAL(l_out_row_major.dimension(4), 32);
1026 
1027  for (IndexType b = 0; b < 32; ++b) {
1028  for (IndexType i = 0; i < 16; ++i) {
1029  for (IndexType j = 0; j < 16; ++j) {
1030  IndexType patchId = i + 16 * j;
1031  for (IndexType c = 0; c < 7; ++c) {
1032  for (IndexType r = 0; r < 7; ++r) {
1033  for (IndexType d = 0; d < 32; ++d) {
1034  DataType expected = 0.0f;
1035  if (r - 3 + i >= 0 && c - 3 + j >= 0 && r - 3 + i < 16 && c - 3 + j < 16) {
1036  expected = l_in_col_major(d, r - 3 + i, c - 3 + j, b);
1037  }
1038  // ColMajor
1039  if (l_out_col_major(d, r, c, patchId, b) != expected) {
1040  std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
1041  << " d=" << d << " b=" << b << std::endl;
1042  }
1043  VERIFY_IS_EQUAL(l_out_col_major(d, r, c, patchId, b), expected);
1044  // RowMajor
1045  if (l_out_row_major(b, patchId, c, r, d) != expected) {
1046  std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
1047  << " d=" << d << " b=" << b << std::endl;
1048  }
1049  VERIFY_IS_EQUAL(l_out_row_major(b, patchId, c, r, d), expected);
1050  }
1051  }
1052  }
1053  }
1054  }
1055  }
1056 
1057  // ColMajor
1058  sycl_device.deallocate(gpu_data_l_in_col_major);
1059  sycl_device.deallocate(gpu_data_l_out_col_major);
1060  sizeDim1 = 64;
1061  sizeDim2 = 13;
1062  sizeDim3 = 13;
1063  sizeDim4 = 32;
1064  tensorColMajorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
1065  l_in_col_major.resize(tensorColMajorRange);
1066  l_in_col_major.setRandom();
1067  gpu_data_l_in_col_major = static_cast<DataType*>(sycl_device.allocate(l_in_col_major.size() * sizeof(DataType)));
1068  TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_l_in_col_major_resize3(gpu_data_l_in_col_major,
1069  tensorColMajorRange);
1070 
1071  patchTensorRange = {{sizeDim1, 3, 3, sizeDim2 * sizeDim3, sizeDim4}};
1072  l_out_col_major.resize(patchTensorRange);
1073  patchTensorBuffSize = l_out_col_major.size() * sizeof(DataType);
1074  gpu_data_l_out_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
1075  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_l_out_col_major_resize3(gpu_data_l_out_col_major,
1076  patchTensorRange);
1077  sycl_device.memcpyHostToDevice(gpu_data_l_in_col_major, l_in_col_major.data(),
1078  (l_in_col_major.size()) * sizeof(DataType));
1079  gpu_l_out_col_major_resize3.device(sycl_device) = gpu_l_in_col_major_resize3.extract_image_patches(3, 3);
1080  sycl_device.memcpyDeviceToHost(l_out_col_major.data(), gpu_data_l_out_col_major, patchTensorBuffSize);
1081 
1082  VERIFY_IS_EQUAL(l_out_col_major.dimension(0), 64);
1083  VERIFY_IS_EQUAL(l_out_col_major.dimension(1), 3);
1084  VERIFY_IS_EQUAL(l_out_col_major.dimension(2), 3);
1085  VERIFY_IS_EQUAL(l_out_col_major.dimension(3), 13 * 13);
1086  VERIFY_IS_EQUAL(l_out_col_major.dimension(4), 32);
1087 
1088  // RowMajor
1089  sycl_device.deallocate(gpu_data_l_out_row_major);
1090  patchTensorRange = {{sizeDim4, sizeDim2 * sizeDim3, 3, 3, sizeDim1}};
1091  l_out_row_major.resize(patchTensorRange);
1092  patchTensorBuffSize = l_out_row_major.size() * sizeof(DataType);
1093  gpu_data_l_out_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
1094  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_l_out_row_major_resize3(gpu_data_l_out_row_major,
1095  patchTensorRange);
1096  gpu_l_out_row_major_resize3.device(sycl_device) =
1097  gpu_l_in_col_major_resize3.swap_layout().extract_image_patches(3, 3);
1098  sycl_device.memcpyDeviceToHost(l_out_row_major.data(), gpu_data_l_out_row_major, patchTensorBuffSize);
1099 
1100  VERIFY_IS_EQUAL(l_out_row_major.dimension(0), 32);
1101  VERIFY_IS_EQUAL(l_out_row_major.dimension(1), 13 * 13);
1102  VERIFY_IS_EQUAL(l_out_row_major.dimension(2), 3);
1103  VERIFY_IS_EQUAL(l_out_row_major.dimension(3), 3);
1104  VERIFY_IS_EQUAL(l_out_row_major.dimension(4), 64);
1105 
1106  for (IndexType b = 0; b < 32; ++b) {
1107  for (IndexType i = 0; i < 13; ++i) {
1108  for (IndexType j = 0; j < 13; ++j) {
1109  IndexType patchId = i + 13 * j;
1110  for (IndexType c = 0; c < 3; ++c) {
1111  for (IndexType r = 0; r < 3; ++r) {
1112  for (IndexType d = 0; d < 64; ++d) {
1113  DataType expected = 0.0f;
1114  if (r - 1 + i >= 0 && c - 1 + j >= 0 && r - 1 + i < 13 && c - 1 + j < 13) {
1115  expected = l_in_col_major(d, r - 1 + i, c - 1 + j, b);
1116  }
1117  // ColMajor
1118  if (l_out_col_major(d, r, c, patchId, b) != expected) {
1119  std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
1120  << " d=" << d << " b=" << b << std::endl;
1121  }
1122  VERIFY_IS_EQUAL(l_out_col_major(d, r, c, patchId, b), expected);
1123  // RowMajor
1124  if (l_out_row_major(b, patchId, c, r, d) != expected) {
1125  std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
1126  << " d=" << d << " b=" << b << std::endl;
1127  }
1128  VERIFY_IS_EQUAL(l_out_row_major(b, patchId, c, r, d), expected);
1129  }
1130  }
1131  }
1132  }
1133  }
1134  }
1135  sycl_device.deallocate(gpu_data_l_in_col_major);
1136  sycl_device.deallocate(gpu_data_l_out_col_major);
1137  sycl_device.deallocate(gpu_data_l_out_row_major);
1138 }
i
int i
Definition: BiCGSTAB_step_by_step.cpp:9
b
Scalar * b
Definition: benchVecAdd.cpp:17
Eigen::TensorMap
A tensor expression mapping an existing array of data.
Definition: TensorMap.h:33
Eigen::Tensor
The tensor class.
Definition: Tensor.h:68
VERIFY_IS_EQUAL
#define VERIFY_IS_EQUAL(a, b)
Definition: main.h:367
Eigen::array
std::array< T, N > array
Definition: EmulateArray.h:231
UniformPSDSelfTest.r
r
Definition: UniformPSDSelfTest.py:20
calibrate.c
int c
Definition: calibrate.py:100
j
std::ptrdiff_t j
Definition: tut_arithmetic_redux_minmax.cpp:2

References b, calibrate::c, Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType_ >::data(), Eigen::TensorBase< Derived, AccessLevel >::device(), Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType_ >::dimension(), i, j, UniformPSDSelfTest::r, Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType_ >::resize(), Eigen::TensorBase< Derived, AccessLevel >::setRandom(), Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType_ >::size(), Eigen::TensorBase< Derived, AccessLevel >::swap_layout(), and VERIFY_IS_EQUAL.

◆ test_patch_no_extra_dim_sycl()

template<typename DataType , typename IndexType >
static void test_patch_no_extra_dim_sycl ( const Eigen::SyclDevice &  sycl_device)
static
599  {
600  IndexType sizeDim1 = 2;
601  IndexType sizeDim2 = 3;
602  IndexType sizeDim3 = 5;
603 
604  // ColMajor
605  array<IndexType, 3> tensorColMajorRange = {{sizeDim1, sizeDim2, sizeDim3}};
606  array<IndexType, 3> tensorRowMajorRange = {{sizeDim3, sizeDim2, sizeDim1}};
607  Tensor<DataType, 3, DataLayout, IndexType> tensor_col_major(tensorColMajorRange);
608  tensor_col_major.setRandom();
609  Tensor<DataType, 3, RowMajor, IndexType> tensor_row_major(tensorRowMajorRange);
610 
611  DataType* gpu_data_col_major =
612  static_cast<DataType*>(sycl_device.allocate(tensor_col_major.size() * sizeof(DataType)));
613  DataType* gpu_data_row_major =
614  static_cast<DataType*>(sycl_device.allocate(tensor_row_major.size() * sizeof(DataType)));
615  TensorMap<Tensor<DataType, 3, ColMajor, IndexType>> gpu_col_major(gpu_data_col_major, tensorColMajorRange);
616  TensorMap<Tensor<DataType, 3, RowMajor, IndexType>> gpu_row_major(gpu_data_row_major, tensorRowMajorRange);
617 
618  sycl_device.memcpyHostToDevice(gpu_data_col_major, tensor_col_major.data(),
619  (tensor_col_major.size()) * sizeof(DataType));
620  gpu_row_major.device(sycl_device) = gpu_col_major.swap_layout();
621  sycl_device.memcpyDeviceToHost(tensor_row_major.data(), gpu_data_row_major,
622  (tensor_row_major.size()) * sizeof(DataType));
623 
624  VERIFY_IS_EQUAL(tensor_col_major.dimension(0), tensor_row_major.dimension(2));
625  VERIFY_IS_EQUAL(tensor_col_major.dimension(1), tensor_row_major.dimension(1));
626  VERIFY_IS_EQUAL(tensor_col_major.dimension(2), tensor_row_major.dimension(0));
627 
628  // Single pixel patch: ColMajor
629  array<IndexType, 4> patchColMajorTensorRange = {{sizeDim1, 1, 1, sizeDim2 * sizeDim3}};
630  Tensor<DataType, 4, DataLayout, IndexType> single_patch_col_major(patchColMajorTensorRange);
631  size_t patchTensorBuffSize = single_patch_col_major.size() * sizeof(DataType);
632  DataType* gpu_data_single_patch_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
633  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_single_patch_col_major(gpu_data_single_patch_col_major,
634  patchColMajorTensorRange);
635  gpu_single_patch_col_major.device(sycl_device) = gpu_col_major.extract_image_patches(1, 1);
636  sycl_device.memcpyDeviceToHost(single_patch_col_major.data(), gpu_data_single_patch_col_major, patchTensorBuffSize);
637 
638  VERIFY_IS_EQUAL(single_patch_col_major.dimension(0), sizeDim1);
639  VERIFY_IS_EQUAL(single_patch_col_major.dimension(1), 1);
640  VERIFY_IS_EQUAL(single_patch_col_major.dimension(2), 1);
641  VERIFY_IS_EQUAL(single_patch_col_major.dimension(3), sizeDim2 * sizeDim3);
642 
643  // Single pixel patch: RowMajor
644  array<IndexType, 4> patchRowMajorTensorRange = {{sizeDim2 * sizeDim3, 1, 1, sizeDim1}};
645  Tensor<DataType, 4, RowMajor, IndexType> single_patch_row_major(patchRowMajorTensorRange);
646  patchTensorBuffSize = single_patch_row_major.size() * sizeof(DataType);
647  DataType* gpu_data_single_patch_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
648  TensorMap<Tensor<DataType, 4, RowMajor, IndexType>> gpu_single_patch_row_major(gpu_data_single_patch_row_major,
649  patchRowMajorTensorRange);
650  gpu_single_patch_row_major.device(sycl_device) = gpu_row_major.extract_image_patches(1, 1);
651  sycl_device.memcpyDeviceToHost(single_patch_row_major.data(), gpu_data_single_patch_row_major, patchTensorBuffSize);
652 
653  VERIFY_IS_EQUAL(single_patch_row_major.dimension(0), sizeDim2 * sizeDim3);
654  VERIFY_IS_EQUAL(single_patch_row_major.dimension(1), 1);
655  VERIFY_IS_EQUAL(single_patch_row_major.dimension(2), 1);
656  VERIFY_IS_EQUAL(single_patch_row_major.dimension(3), sizeDim1);
657 
658  for (IndexType i = 0; i < tensor_col_major.size(); ++i) {
659  // ColMajor
660  if (tensor_col_major.data()[i] != single_patch_col_major.data()[i]) {
661  std::cout << "Mismatch detected at index " << i << " : " << tensor_col_major.data()[i] << " vs "
662  << single_patch_col_major.data()[i] << std::endl;
663  }
664  VERIFY_IS_EQUAL(single_patch_col_major.data()[i], tensor_col_major.data()[i]);
665  // RowMajor
666  if (tensor_row_major.data()[i] != single_patch_row_major.data()[i]) {
667  std::cout << "Mismatch detected at index " << i << " : " << tensor_col_major.data()[i] << " vs "
668  << single_patch_row_major.data()[i] << std::endl;
669  }
670  VERIFY_IS_EQUAL(single_patch_row_major.data()[i], tensor_row_major.data()[i]);
671  VERIFY_IS_EQUAL(tensor_col_major.data()[i], tensor_row_major.data()[i]);
672  VERIFY_IS_EQUAL(single_patch_col_major.data()[i], single_patch_row_major.data()[i]);
673  }
674 
675  // Entire image patch: ColMajor
676  patchColMajorTensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim2 * sizeDim3}};
677  Tensor<DataType, 4, DataLayout, IndexType> entire_image_patch_col_major(patchColMajorTensorRange);
678  patchTensorBuffSize = entire_image_patch_col_major.size() * sizeof(DataType);
679  DataType* gpu_data_entire_image_patch_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
680  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_entire_image_patch_col_major(
681  gpu_data_entire_image_patch_col_major, patchColMajorTensorRange);
682  gpu_entire_image_patch_col_major.device(sycl_device) = gpu_col_major.extract_image_patches(3, 5);
683  sycl_device.memcpyDeviceToHost(entire_image_patch_col_major.data(), gpu_data_entire_image_patch_col_major,
684  patchTensorBuffSize);
685 
686  VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(0), 2);
687  VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(1), 3);
688  VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(2), 5);
689  VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(3), 3 * 5);
690 
691  // Entire image patch: RowMajor
692  patchRowMajorTensorRange = {{sizeDim2 * sizeDim3, sizeDim3, sizeDim2, sizeDim1}};
693  Tensor<DataType, 4, RowMajor, IndexType> entire_image_patch_row_major(patchRowMajorTensorRange);
694  patchTensorBuffSize = entire_image_patch_row_major.size() * sizeof(DataType);
695  DataType* gpu_data_entire_image_patch_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
696  TensorMap<Tensor<DataType, 4, RowMajor, IndexType>> gpu_entire_image_patch_row_major(
697  gpu_data_entire_image_patch_row_major, patchRowMajorTensorRange);
698  gpu_entire_image_patch_row_major.device(sycl_device) = gpu_row_major.extract_image_patches(3, 5);
699  sycl_device.memcpyDeviceToHost(entire_image_patch_row_major.data(), gpu_data_entire_image_patch_row_major,
700  patchTensorBuffSize);
701  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(0), 3 * 5);
702  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(1), 5);
703  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(2), 3);
704  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(3), 2);
705 
706  for (IndexType i = 0; i < 3; ++i) {
707  for (IndexType j = 0; j < 5; ++j) {
708  IndexType patchId = i + 3 * j;
709  for (IndexType r = 0; r < 3; ++r) {
710  for (IndexType c = 0; c < 5; ++c) {
711  for (IndexType d = 0; d < 2; ++d) {
712  DataType expected_col_major = 0.0f;
713  DataType expected_row_major = 0.0f;
714  if (r - 1 + i >= 0 && c - 2 + j >= 0 && r - 1 + i < 3 && c - 2 + j < 5) {
715  expected_col_major = tensor_col_major(d, r - 1 + i, c - 2 + j);
716  expected_row_major = tensor_row_major(c - 2 + j, r - 1 + i, d);
717  }
718  // ColMajor
719  if (entire_image_patch_col_major(d, r, c, patchId) != expected_col_major) {
720  std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c << " d=" << d
721  << std::endl;
722  }
723  VERIFY_IS_EQUAL(entire_image_patch_col_major(d, r, c, patchId), expected_col_major);
724  // RowMajor
725  if (entire_image_patch_row_major(patchId, c, r, d) != expected_row_major) {
726  std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c << " d=" << d
727  << std::endl;
728  }
729  VERIFY_IS_EQUAL(entire_image_patch_row_major(patchId, c, r, d), expected_row_major);
730  // Check that ColMajor and RowMajor agree.
731  VERIFY_IS_EQUAL(expected_col_major, expected_row_major);
732  }
733  }
734  }
735  }
736  }
737 
738  // 2D patch: ColMajor
739  patchColMajorTensorRange = {{sizeDim1, 2, 2, sizeDim2 * sizeDim3}};
740  Tensor<DataType, 4, DataLayout, IndexType> twod_patch_col_major(patchColMajorTensorRange);
741  patchTensorBuffSize = twod_patch_col_major.size() * sizeof(DataType);
742  DataType* gpu_data_twod_patch_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
743  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_twod_patch_col_major(gpu_data_twod_patch_col_major,
744  patchColMajorTensorRange);
745  gpu_twod_patch_col_major.device(sycl_device) = gpu_col_major.extract_image_patches(2, 2);
746  sycl_device.memcpyDeviceToHost(twod_patch_col_major.data(), gpu_data_twod_patch_col_major, patchTensorBuffSize);
747 
748  VERIFY_IS_EQUAL(twod_patch_col_major.dimension(0), 2);
749  VERIFY_IS_EQUAL(twod_patch_col_major.dimension(1), 2);
750  VERIFY_IS_EQUAL(twod_patch_col_major.dimension(2), 2);
751  VERIFY_IS_EQUAL(twod_patch_col_major.dimension(3), 3 * 5);
752 
753  // 2D patch: RowMajor
754  patchRowMajorTensorRange = {{sizeDim2 * sizeDim3, 2, 2, sizeDim1}};
755  Tensor<DataType, 4, RowMajor, IndexType> twod_patch_row_major(patchRowMajorTensorRange);
756  patchTensorBuffSize = twod_patch_row_major.size() * sizeof(DataType);
757  DataType* gpu_data_twod_patch_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
758  TensorMap<Tensor<DataType, 4, RowMajor, IndexType>> gpu_twod_patch_row_major(gpu_data_twod_patch_row_major,
759  patchRowMajorTensorRange);
760  gpu_twod_patch_row_major.device(sycl_device) = gpu_row_major.extract_image_patches(2, 2);
761  sycl_device.memcpyDeviceToHost(twod_patch_row_major.data(), gpu_data_twod_patch_row_major, patchTensorBuffSize);
762  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(0), 3 * 5);
763  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(1), 2);
764  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(2), 2);
765  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(3), 2);
766 
767  // Based on the calculation described in TensorTraits.h, padding happens to be 0.
768  IndexType row_padding = 0;
769  IndexType col_padding = 0;
770  IndexType stride = 1;
771 
772  for (IndexType i = 0; i < 3; ++i) {
773  for (IndexType j = 0; j < 5; ++j) {
774  IndexType patchId = i + 3 * j;
775  for (IndexType r = 0; r < 2; ++r) {
776  for (IndexType c = 0; c < 2; ++c) {
777  for (IndexType d = 0; d < 2; ++d) {
778  DataType expected_col_major = 0.0f;
779  DataType expected_row_major = 0.0f;
780  IndexType row_offset = r * stride + i - row_padding;
781  IndexType col_offset = c * stride + j - col_padding;
782  // ColMajor
783  if (row_offset >= 0 && col_offset >= 0 && row_offset < tensor_col_major.dimension(1) &&
784  col_offset < tensor_col_major.dimension(2)) {
785  expected_col_major = tensor_col_major(d, row_offset, col_offset);
786  }
787  if (twod_patch_col_major(d, r, c, patchId) != expected_col_major) {
788  std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c << " d=" << d
789  << std::endl;
790  }
791  VERIFY_IS_EQUAL(twod_patch_col_major(d, r, c, patchId), expected_col_major);
792  // RowMajor
793  if (row_offset >= 0 && col_offset >= 0 && row_offset < tensor_row_major.dimension(1) &&
794  col_offset < tensor_row_major.dimension(0)) {
795  expected_row_major = tensor_row_major(col_offset, row_offset, d);
796  }
797  if (twod_patch_row_major(patchId, c, r, d) != expected_row_major) {
798  std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c << " d=" << d
799  << std::endl;
800  }
801  VERIFY_IS_EQUAL(twod_patch_row_major(patchId, c, r, d), expected_row_major);
802  // Check that ColMajor and RowMajor agree.
803  VERIFY_IS_EQUAL(expected_col_major, expected_row_major);
804  }
805  }
806  }
807  }
808  }
809 
810  sycl_device.deallocate(gpu_data_col_major);
811  sycl_device.deallocate(gpu_data_row_major);
812  sycl_device.deallocate(gpu_data_single_patch_col_major);
813  sycl_device.deallocate(gpu_data_single_patch_row_major);
814  sycl_device.deallocate(gpu_data_entire_image_patch_col_major);
815  sycl_device.deallocate(gpu_data_entire_image_patch_row_major);
816  sycl_device.deallocate(gpu_data_twod_patch_col_major);
817  sycl_device.deallocate(gpu_data_twod_patch_row_major);
818 }

References calibrate::c, Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType_ >::data(), Eigen::TensorBase< Derived, AccessLevel >::device(), Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType_ >::dimension(), i, j, UniformPSDSelfTest::r, Eigen::TensorBase< Derived, AccessLevel >::setRandom(), Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType_ >::size(), Eigen::TensorBase< Derived, AccessLevel >::swap_layout(), and VERIFY_IS_EQUAL.

◆ test_patch_padding_same_sycl()

template<typename DataType , typename IndexType >
static void test_patch_padding_same_sycl ( const Eigen::SyclDevice &  sycl_device)
static
486  {
487  IndexType input_depth = 3;
488  IndexType input_rows = 4;
489  IndexType input_cols = 2;
490  IndexType input_batches = 1;
491  IndexType ksize = 2; // Corresponds to the Rows and Cols for tensor.extract_image_patches<>.
492  IndexType stride = 2; // Only same stride is supported.
493 
494  // ColMajor
495  array<IndexType, 4> tensorColMajorRange = {{input_depth, input_rows, input_cols, input_batches}};
496  array<IndexType, 4> tensorRowMajorRange = {{input_batches, input_cols, input_rows, input_depth}};
497  Tensor<DataType, 4, DataLayout, IndexType> tensor_col_major(tensorColMajorRange);
498  Tensor<DataType, 4, RowMajor, IndexType> tensor_row_major(tensorRowMajorRange);
499 
500  DataType* gpu_data_col_major =
501  static_cast<DataType*>(sycl_device.allocate(tensor_col_major.size() * sizeof(DataType)));
502  DataType* gpu_data_row_major =
503  static_cast<DataType*>(sycl_device.allocate(tensor_row_major.size() * sizeof(DataType)));
504  TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_col_major(gpu_data_col_major, tensorColMajorRange);
505  TensorMap<Tensor<DataType, 4, RowMajor, IndexType>> gpu_row_major(gpu_data_row_major, tensorRowMajorRange);
506 
507  sycl_device.memcpyHostToDevice(gpu_data_col_major, tensor_col_major.data(),
508  (tensor_col_major.size()) * sizeof(DataType));
509  gpu_row_major.device(sycl_device) = gpu_col_major.swap_layout();
510  sycl_device.memcpyDeviceToHost(tensor_row_major.data(), gpu_data_row_major,
511  (tensor_col_major.size()) * sizeof(DataType));
512 
513  VERIFY_IS_EQUAL(tensor_col_major.dimension(0), tensor_row_major.dimension(3));
514  VERIFY_IS_EQUAL(tensor_col_major.dimension(1), tensor_row_major.dimension(2));
515  VERIFY_IS_EQUAL(tensor_col_major.dimension(2), tensor_row_major.dimension(1));
516  VERIFY_IS_EQUAL(tensor_col_major.dimension(3), tensor_row_major.dimension(0));
517 
518  // Initializes tensor with incrementing numbers.
519  for (IndexType i = 0; i < tensor_col_major.size(); ++i) {
520  tensor_col_major.data()[i] = i + 1;
521  }
522 
523  array<IndexType, 5> patchColMajorTensorRange = {{input_depth, ksize, ksize, 2, input_batches}};
524  Tensor<DataType, 5, DataLayout, IndexType> result_col_major(patchColMajorTensorRange);
525  size_t patchTensorBuffSize = result_col_major.size() * sizeof(DataType);
526  DataType* gpu_data_result_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
527  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_result_col_major(gpu_data_result_col_major,
528  patchColMajorTensorRange);
529  gpu_result_col_major.device(sycl_device) =
530  gpu_col_major.extract_image_patches(ksize, ksize, stride, stride, PADDING_SAME);
531  sycl_device.memcpyDeviceToHost(result_col_major.data(), gpu_data_result_col_major, patchTensorBuffSize);
532 
533  VERIFY_IS_EQUAL(result_col_major.dimension(0), input_depth); // depth
534  VERIFY_IS_EQUAL(result_col_major.dimension(1), ksize); // kernel rows
535  VERIFY_IS_EQUAL(result_col_major.dimension(2), ksize); // kernel cols
536  VERIFY_IS_EQUAL(result_col_major.dimension(3), 2); // number of patches
537  VERIFY_IS_EQUAL(result_col_major.dimension(4), input_batches); // number of batches
538 
539  // RowMajor
540 
541  array<IndexType, 5> patchRowMajorTensorRange = {{input_batches, 2, ksize, ksize, input_depth}};
542  Tensor<DataType, 5, RowMajor, IndexType> result_row_major(patchRowMajorTensorRange);
543  patchTensorBuffSize = result_row_major.size() * sizeof(DataType);
544  DataType* gpu_data_result_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
545  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_result_row_major(gpu_data_result_row_major,
546  patchRowMajorTensorRange);
547  gpu_result_row_major.device(sycl_device) =
548  gpu_row_major.extract_image_patches(ksize, ksize, stride, stride, PADDING_SAME);
549  sycl_device.memcpyDeviceToHost(result_row_major.data(), gpu_data_result_row_major, patchTensorBuffSize);
550 
551  VERIFY_IS_EQUAL(result_col_major.dimension(0), result_row_major.dimension(4));
552  VERIFY_IS_EQUAL(result_col_major.dimension(1), result_row_major.dimension(3));
553  VERIFY_IS_EQUAL(result_col_major.dimension(2), result_row_major.dimension(2));
554  VERIFY_IS_EQUAL(result_col_major.dimension(3), result_row_major.dimension(1));
555  VERIFY_IS_EQUAL(result_col_major.dimension(4), result_row_major.dimension(0));
556 
557  // Based on the calculation described in TensorTraits.h, padding happens to be 0.
558  IndexType row_padding = 0;
559  IndexType col_padding = 0;
560 
561  for (IndexType i = 0; (i + stride + ksize - 1) <= input_rows; i += stride) { // input rows
562  for (IndexType j = 0; (j + stride + ksize - 1) <= input_cols; j += stride) { // input cols
563  IndexType patchId = i + input_rows * j;
564  for (IndexType r = 0; r < ksize; ++r) { // patch rows
565  for (IndexType c = 0; c < ksize; ++c) { // patch cols
566  for (IndexType d = 0; d < input_depth; ++d) { // depth
567  for (IndexType b = 0; b < input_batches; ++b) { // batch
568  DataType expected_col_major = 0.0f;
569  DataType expected_row_major = 0.0f;
570  IndexType row_offset = r * stride + i - row_padding;
571  IndexType col_offset = c * stride + j - col_padding;
572  if (row_offset >= 0 && col_offset >= 0 && row_offset < input_rows && col_offset < input_cols) {
573  expected_col_major = tensor_col_major(d, row_offset, col_offset, b);
574  expected_row_major = tensor_row_major(b, col_offset, row_offset, d);
575  }
576  // ColMajor
577  if (result_col_major(d, r, c, patchId, b) != expected_col_major) {
578  std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
579  << " d=" << d << " b=" << b << std::endl;
580  }
581  VERIFY_IS_EQUAL(result_col_major(d, r, c, patchId, b), expected_col_major);
582  // RowMajor
583  if (result_row_major(b, patchId, c, r, d) != expected_row_major) {
584  std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
585  << " d=" << d << " b=" << b << std::endl;
586  }
587  VERIFY_IS_EQUAL(result_row_major(b, patchId, c, r, d), expected_row_major);
588  // Check that ColMajor and RowMajor agree.
589  VERIFY_IS_EQUAL(expected_col_major, expected_row_major);
590  }
591  }
592  }
593  }
594  }
595  }
596 }
Eigen::PADDING_SAME
@ PADDING_SAME
Definition: TensorTraits.h:227

References b, calibrate::c, Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType_ >::data(), Eigen::TensorBase< Derived, AccessLevel >::device(), Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType_ >::dimension(), i, j, Eigen::PADDING_SAME, UniformPSDSelfTest::r, Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType_ >::size(), Eigen::TensorBase< Derived, AccessLevel >::swap_layout(), and VERIFY_IS_EQUAL.

◆ test_patch_padding_valid_same_value_sycl()

template<typename DataType , typename IndexType >
static void test_patch_padding_valid_same_value_sycl ( const Eigen::SyclDevice &  sycl_device)
static
379  {
380  IndexType input_depth = 1;
381  IndexType input_rows = 5;
382  IndexType input_cols = 5;
383  IndexType input_batches = 2;
384  IndexType ksize = 3; // Corresponds to the Rows and Cols for tensor.extract_image_patches<>.
385  IndexType stride = 2; // Only same stride is supported.
386  // ColMajor
387 
388  array<IndexType, 4> tensorColMajorRange = {{input_depth, input_rows, input_cols, input_batches}};
389  array<IndexType, 4> tensorRowMajorRange = {{input_batches, input_cols, input_rows, input_depth}};
390  Tensor<DataType, 4, DataLayout, IndexType> tensor_col_major(tensorColMajorRange);
391  Tensor<DataType, 4, RowMajor, IndexType> tensor_row_major(tensorRowMajorRange);
392 
393  DataType* gpu_data_col_major =
394  static_cast<DataType*>(sycl_device.allocate(tensor_col_major.size() * sizeof(DataType)));
395  DataType* gpu_data_row_major =
396  static_cast<DataType*>(sycl_device.allocate(tensor_row_major.size() * sizeof(DataType)));
397  TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_col_major(gpu_data_col_major, tensorColMajorRange);
398  TensorMap<Tensor<DataType, 4, RowMajor, IndexType>> gpu_row_major(gpu_data_row_major, tensorRowMajorRange);
399  gpu_col_major.device(sycl_device) = gpu_col_major.constant(11.0f);
400  gpu_row_major.device(sycl_device) = gpu_col_major.swap_layout();
401  sycl_device.memcpyDeviceToHost(tensor_col_major.data(), gpu_data_col_major,
402  (tensor_col_major.size()) * sizeof(DataType));
403  sycl_device.memcpyDeviceToHost(tensor_row_major.data(), gpu_data_row_major,
404  (tensor_row_major.size()) * sizeof(DataType));
405  VERIFY_IS_EQUAL(tensor_col_major.dimension(0), tensor_row_major.dimension(3));
406  VERIFY_IS_EQUAL(tensor_col_major.dimension(1), tensor_row_major.dimension(2));
407  VERIFY_IS_EQUAL(tensor_col_major.dimension(2), tensor_row_major.dimension(1));
408  VERIFY_IS_EQUAL(tensor_col_major.dimension(3), tensor_row_major.dimension(0));
409 
410  array<IndexType, 5> patchColMajorTensorRange = {{input_depth, ksize, ksize, 4, input_batches}};
411  Tensor<DataType, 5, DataLayout, IndexType> result_col_major(patchColMajorTensorRange);
412  size_t patchTensorBuffSize = result_col_major.size() * sizeof(DataType);
413  DataType* gpu_data_result_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
414  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_result_col_major(gpu_data_result_col_major,
415  patchColMajorTensorRange);
416  gpu_result_col_major.device(sycl_device) =
417  gpu_col_major.extract_image_patches(ksize, ksize, stride, stride, 1, 1, PADDING_VALID);
418  sycl_device.memcpyDeviceToHost(result_col_major.data(), gpu_data_result_col_major, patchTensorBuffSize);
419 
420  VERIFY_IS_EQUAL(result_col_major.dimension(0), input_depth); // depth
421  VERIFY_IS_EQUAL(result_col_major.dimension(1), ksize); // kernel rows
422  VERIFY_IS_EQUAL(result_col_major.dimension(2), ksize); // kernel cols
423  VERIFY_IS_EQUAL(result_col_major.dimension(3), 4); // number of patches
424  VERIFY_IS_EQUAL(result_col_major.dimension(4), input_batches); // number of batches
425 
426  // RowMajor
427  array<IndexType, 5> patchRowMajorTensorRange = {{input_batches, 4, ksize, ksize, input_depth}};
428  Tensor<DataType, 5, RowMajor, IndexType> result_row_major(patchRowMajorTensorRange);
429  patchTensorBuffSize = result_row_major.size() * sizeof(DataType);
430  DataType* gpu_data_result_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
431  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_result_row_major(gpu_data_result_row_major,
432  patchRowMajorTensorRange);
433  gpu_result_row_major.device(sycl_device) =
434  gpu_row_major.extract_image_patches(ksize, ksize, stride, stride, 1, 1, PADDING_VALID);
435  sycl_device.memcpyDeviceToHost(result_row_major.data(), gpu_data_result_row_major, patchTensorBuffSize);
436 
437  VERIFY_IS_EQUAL(result_col_major.dimension(0), result_row_major.dimension(4));
438  VERIFY_IS_EQUAL(result_col_major.dimension(1), result_row_major.dimension(3));
439  VERIFY_IS_EQUAL(result_col_major.dimension(2), result_row_major.dimension(2));
440  VERIFY_IS_EQUAL(result_col_major.dimension(3), result_row_major.dimension(1));
441  VERIFY_IS_EQUAL(result_col_major.dimension(4), result_row_major.dimension(0));
442 
443  // No padding is carried out.
444  IndexType row_padding = 0;
445  IndexType col_padding = 0;
446 
447  for (IndexType i = 0; (i + stride + ksize - 1) <= input_rows; i += stride) { // input rows
448  for (IndexType j = 0; (j + stride + ksize - 1) <= input_cols; j += stride) { // input cols
449  IndexType patchId = i + input_rows * j;
450  for (IndexType r = 0; r < ksize; ++r) { // patch rows
451  for (IndexType c = 0; c < ksize; ++c) { // patch cols
452  for (IndexType d = 0; d < input_depth; ++d) { // depth
453  for (IndexType b = 0; b < input_batches; ++b) { // batch
454  DataType expected_col_major = 0.0f;
455  DataType expected_row_major = 0.0f;
456  IndexType row_offset = r + i - row_padding;
457  IndexType col_offset = c + j - col_padding;
458  if (row_offset >= 0 && col_offset >= 0 && row_offset < input_rows && col_offset < input_cols) {
459  expected_col_major = tensor_col_major(d, row_offset, col_offset, b);
460  expected_row_major = tensor_row_major(b, col_offset, row_offset, d);
461  }
462  // ColMajor
463  if (result_col_major(d, r, c, patchId, b) != expected_col_major) {
464  std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
465  << " d=" << d << " b=" << b << std::endl;
466  }
467  VERIFY_IS_EQUAL(result_col_major(d, r, c, patchId, b), expected_col_major);
468  // RowMajor
469  if (result_row_major(b, patchId, c, r, d) != expected_row_major) {
470  std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
471  << " d=" << d << " b=" << b << std::endl;
472  }
473  VERIFY_IS_EQUAL(result_row_major(b, patchId, c, r, d), expected_row_major);
474  // Check that ColMajor and RowMajor agree.
475  VERIFY_IS_EQUAL(expected_col_major, expected_row_major);
476  }
477  }
478  }
479  }
480  }
481  }
482 }
Eigen::PADDING_VALID
@ PADDING_VALID
Definition: TensorTraits.h:227

References b, calibrate::c, Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType_ >::data(), Eigen::TensorBase< Derived, AccessLevel >::device(), Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType_ >::dimension(), i, j, Eigen::PADDING_VALID, UniformPSDSelfTest::r, Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType_ >::size(), Eigen::TensorBase< Derived, AccessLevel >::swap_layout(), and VERIFY_IS_EQUAL.

◆ test_patch_padding_valid_sycl()

template<typename DataType , typename IndexType >
static void test_patch_padding_valid_sycl ( const Eigen::SyclDevice &  sycl_device)
static
263  {
264  IndexType input_depth = 3;
265  IndexType input_rows = 3;
266  IndexType input_cols = 3;
267  IndexType input_batches = 1;
268  IndexType ksize = 2; // Corresponds to the Rows and Cols for tensor.extract_image_patches<>.
269  IndexType stride = 2; // Only same stride is supported.
270 
271  array<IndexType, 4> tensorColMajorRange = {{input_depth, input_rows, input_cols, input_batches}};
272  array<IndexType, 4> tensorRowMajorRange = {{input_batches, input_cols, input_rows, input_depth}};
273  Tensor<DataType, 4, DataLayout, IndexType> tensor_col_major(tensorColMajorRange);
274  Tensor<DataType, 4, RowMajor, IndexType> tensor_row_major(tensorRowMajorRange);
275 
276  DataType* gpu_data_col_major =
277  static_cast<DataType*>(sycl_device.allocate(tensor_col_major.size() * sizeof(DataType)));
278  DataType* gpu_data_row_major =
279  static_cast<DataType*>(sycl_device.allocate(tensor_row_major.size() * sizeof(DataType)));
280  TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_col_major(gpu_data_col_major, tensorColMajorRange);
281  TensorMap<Tensor<DataType, 4, RowMajor, IndexType>> gpu_row_major(gpu_data_row_major, tensorRowMajorRange);
282 
283  sycl_device.memcpyHostToDevice(gpu_data_col_major, tensor_col_major.data(),
284  (tensor_col_major.size()) * sizeof(DataType));
285  gpu_row_major.device(sycl_device) = gpu_col_major.swap_layout();
286  sycl_device.memcpyDeviceToHost(tensor_row_major.data(), gpu_data_row_major,
287  (tensor_col_major.size()) * sizeof(DataType));
288 
289  VERIFY_IS_EQUAL(tensor_col_major.dimension(0), tensor_row_major.dimension(3));
290  VERIFY_IS_EQUAL(tensor_col_major.dimension(1), tensor_row_major.dimension(2));
291  VERIFY_IS_EQUAL(tensor_col_major.dimension(2), tensor_row_major.dimension(1));
292  VERIFY_IS_EQUAL(tensor_col_major.dimension(3), tensor_row_major.dimension(0));
293 
294  // Initializes tensor with incrementing numbers.
295  for (IndexType i = 0; i < tensor_col_major.size(); ++i) {
296  tensor_col_major.data()[i] = i + 1;
297  }
298  // ColMajor
299  array<IndexType, 5> patchColMajorTensorRange = {{input_depth, ksize, ksize, 1, input_batches}};
300  Tensor<DataType, 5, DataLayout, IndexType> result_col_major(patchColMajorTensorRange);
301  size_t patchTensorBuffSize = result_col_major.size() * sizeof(DataType);
302  DataType* gpu_data_result_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
303  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_result_col_major(gpu_data_result_col_major,
304  patchColMajorTensorRange);
305  gpu_result_col_major.device(sycl_device) =
306  gpu_col_major.extract_image_patches(ksize, ksize, stride, stride, 1, 1, PADDING_VALID);
307  sycl_device.memcpyDeviceToHost(result_col_major.data(), gpu_data_result_col_major, patchTensorBuffSize);
308 
309  VERIFY_IS_EQUAL(result_col_major.dimension(0), input_depth); // depth
310  VERIFY_IS_EQUAL(result_col_major.dimension(1), ksize); // kernel rows
311  VERIFY_IS_EQUAL(result_col_major.dimension(2), ksize); // kernel cols
312  VERIFY_IS_EQUAL(result_col_major.dimension(3), 1); // number of patches
313  VERIFY_IS_EQUAL(result_col_major.dimension(4), input_batches); // number of batches
314 
315  // RowMajor
316  array<IndexType, 5> patchRowMajorTensorRange = {{input_batches, 1, ksize, ksize, input_depth}};
317  Tensor<DataType, 5, RowMajor, IndexType> result_row_major(patchRowMajorTensorRange);
318  patchTensorBuffSize = result_row_major.size() * sizeof(DataType);
319  DataType* gpu_data_result_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
320  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_result_row_major(gpu_data_result_row_major,
321  patchRowMajorTensorRange);
322  gpu_result_row_major.device(sycl_device) =
323  gpu_row_major.extract_image_patches(ksize, ksize, stride, stride, 1, 1, PADDING_VALID);
324  sycl_device.memcpyDeviceToHost(result_row_major.data(), gpu_data_result_row_major, patchTensorBuffSize);
325 
326  VERIFY_IS_EQUAL(result_col_major.dimension(0), result_row_major.dimension(4));
327  VERIFY_IS_EQUAL(result_col_major.dimension(1), result_row_major.dimension(3));
328  VERIFY_IS_EQUAL(result_col_major.dimension(2), result_row_major.dimension(2));
329  VERIFY_IS_EQUAL(result_col_major.dimension(3), result_row_major.dimension(1));
330  VERIFY_IS_EQUAL(result_col_major.dimension(4), result_row_major.dimension(0));
331 
332  // No padding is carried out.
333  IndexType row_padding = 0;
334  IndexType col_padding = 0;
335 
336  for (IndexType i = 0; (i + stride + ksize - 1) < input_rows; i += stride) { // input rows
337  for (IndexType j = 0; (j + stride + ksize - 1) < input_cols; j += stride) { // input cols
338  IndexType patchId = i + input_rows * j;
339  for (IndexType r = 0; r < ksize; ++r) { // patch rows
340  for (IndexType c = 0; c < ksize; ++c) { // patch cols
341  for (IndexType d = 0; d < input_depth; ++d) { // depth
342  for (IndexType b = 0; b < input_batches; ++b) { // batch
343  DataType expected_col_major = 0.0f;
344  DataType expected_row_major = 0.0f;
345  IndexType row_offset = r + i - row_padding;
346  IndexType col_offset = c + j - col_padding;
347  if (row_offset >= 0 && col_offset >= 0 && row_offset < input_rows && col_offset < input_cols) {
348  expected_col_major = tensor_col_major(d, row_offset, col_offset, b);
349  expected_row_major = tensor_row_major(b, col_offset, row_offset, d);
350  }
351  // ColMajor
352  if (result_col_major(d, r, c, patchId, b) != expected_col_major) {
353  std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
354  << " d=" << d << " b=" << b << std::endl;
355  }
356  VERIFY_IS_EQUAL(result_col_major(d, r, c, patchId, b), expected_col_major);
357  // RowMajor
358  if (result_row_major(b, patchId, c, r, d) != expected_row_major) {
359  std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
360  << " d=" << d << " b=" << b << std::endl;
361  }
362  VERIFY_IS_EQUAL(result_row_major(b, patchId, c, r, d), expected_row_major);
363  // Check that ColMajor and RowMajor agree.
364  VERIFY_IS_EQUAL(expected_col_major, expected_row_major);
365  }
366  }
367  }
368  }
369  }
370  }
371  sycl_device.deallocate(gpu_data_col_major);
372  sycl_device.deallocate(gpu_data_row_major);
373  sycl_device.deallocate(gpu_data_result_col_major);
374  sycl_device.deallocate(gpu_data_result_row_major);
375 }

References b, calibrate::c, Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType_ >::data(), Eigen::TensorBase< Derived, AccessLevel >::device(), Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType_ >::dimension(), i, j, Eigen::PADDING_VALID, UniformPSDSelfTest::r, Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType_ >::size(), Eigen::TensorBase< Derived, AccessLevel >::swap_layout(), and VERIFY_IS_EQUAL.

◆ test_simple_image_patch_sycl()

template<typename DataType , typename IndexType >
static void test_simple_image_patch_sycl ( const Eigen::SyclDevice &  sycl_device)
static
27  {
28  IndexType sizeDim1 = 2;
29  IndexType sizeDim2 = 3;
30  IndexType sizeDim3 = 5;
31  IndexType sizeDim4 = 7;
32  array<IndexType, 4> tensorColMajorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
33  array<IndexType, 4> tensorRowMajorRange = {{sizeDim4, sizeDim3, sizeDim2, sizeDim1}};
34  Tensor<DataType, 4, DataLayout, IndexType> tensor_col_major(tensorColMajorRange);
35  Tensor<DataType, 4, RowMajor, IndexType> tensor_row_major(tensorRowMajorRange);
36  tensor_col_major.setRandom();
37 
38  DataType* gpu_data_col_major =
39  static_cast<DataType*>(sycl_device.allocate(tensor_col_major.size() * sizeof(DataType)));
40  DataType* gpu_data_row_major =
41  static_cast<DataType*>(sycl_device.allocate(tensor_row_major.size() * sizeof(DataType)));
42  TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_col_major(gpu_data_col_major, tensorColMajorRange);
43  TensorMap<Tensor<DataType, 4, RowMajor, IndexType>> gpu_row_major(gpu_data_row_major, tensorRowMajorRange);
44 
45  sycl_device.memcpyHostToDevice(gpu_data_col_major, tensor_col_major.data(),
46  (tensor_col_major.size()) * sizeof(DataType));
47  gpu_row_major.device(sycl_device) = gpu_col_major.swap_layout();
48  sycl_device.memcpyDeviceToHost(tensor_row_major.data(), gpu_data_row_major,
49  (tensor_col_major.size()) * sizeof(DataType));
50 
51  VERIFY_IS_EQUAL(tensor_col_major.dimension(0), tensor_row_major.dimension(3));
52  VERIFY_IS_EQUAL(tensor_col_major.dimension(1), tensor_row_major.dimension(2));
53  VERIFY_IS_EQUAL(tensor_col_major.dimension(2), tensor_row_major.dimension(1));
54  VERIFY_IS_EQUAL(tensor_col_major.dimension(3), tensor_row_major.dimension(0));
55 
56  // Single pixel patch: ColMajor
57  array<IndexType, 5> patchColMajorTensorRange = {{sizeDim1, 1, 1, sizeDim2 * sizeDim3, sizeDim4}};
58  Tensor<DataType, 5, DataLayout, IndexType> single_patch_col_major(patchColMajorTensorRange);
59  size_t patchTensorBuffSize = single_patch_col_major.size() * sizeof(DataType);
60  DataType* gpu_data_single_patch_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
61  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_single_patch_col_major(gpu_data_single_patch_col_major,
62  patchColMajorTensorRange);
63  gpu_single_patch_col_major.device(sycl_device) = gpu_col_major.extract_image_patches(1, 1);
64  sycl_device.memcpyDeviceToHost(single_patch_col_major.data(), gpu_data_single_patch_col_major, patchTensorBuffSize);
65 
66  VERIFY_IS_EQUAL(single_patch_col_major.dimension(0), 2);
67  VERIFY_IS_EQUAL(single_patch_col_major.dimension(1), 1);
68  VERIFY_IS_EQUAL(single_patch_col_major.dimension(2), 1);
69  VERIFY_IS_EQUAL(single_patch_col_major.dimension(3), 3 * 5);
70  VERIFY_IS_EQUAL(single_patch_col_major.dimension(4), 7);
71 
72  // Single pixel patch: RowMajor
73  array<IndexType, 5> patchRowMajorTensorRange = {{sizeDim4, sizeDim2 * sizeDim3, 1, 1, sizeDim1}};
74  Tensor<DataType, 5, RowMajor, IndexType> single_patch_row_major(patchRowMajorTensorRange);
75  patchTensorBuffSize = single_patch_row_major.size() * sizeof(DataType);
76  DataType* gpu_data_single_patch_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
77  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_single_patch_row_major(gpu_data_single_patch_row_major,
78  patchRowMajorTensorRange);
79  gpu_single_patch_row_major.device(sycl_device) = gpu_row_major.extract_image_patches(1, 1);
80  sycl_device.memcpyDeviceToHost(single_patch_row_major.data(), gpu_data_single_patch_row_major, patchTensorBuffSize);
81 
82  VERIFY_IS_EQUAL(single_patch_row_major.dimension(0), 7);
83  VERIFY_IS_EQUAL(single_patch_row_major.dimension(1), 3 * 5);
84  VERIFY_IS_EQUAL(single_patch_row_major.dimension(2), 1);
85  VERIFY_IS_EQUAL(single_patch_row_major.dimension(3), 1);
86  VERIFY_IS_EQUAL(single_patch_row_major.dimension(4), 2);
87 
88  for (IndexType i = 0; i < tensor_col_major.size(); ++i) {
89  // ColMajor
90  if (tensor_col_major.data()[i] != single_patch_col_major.data()[i]) {
91  std::cout << "Mismatch detected at index colmajor " << i << " : " << tensor_col_major.data()[i] << " vs "
92  << single_patch_col_major.data()[i] << std::endl;
93  }
94  VERIFY_IS_EQUAL(single_patch_col_major.data()[i], tensor_col_major.data()[i]);
95  // RowMajor
96  if (tensor_row_major.data()[i] != single_patch_row_major.data()[i]) {
97  std::cout << "Mismatch detected at index row major" << i << " : " << tensor_row_major.data()[i] << " vs "
98  << single_patch_row_major.data()[i] << std::endl;
99  }
100  VERIFY_IS_EQUAL(single_patch_row_major.data()[i], tensor_row_major.data()[i]);
101  VERIFY_IS_EQUAL(tensor_col_major.data()[i], tensor_row_major.data()[i]);
102  VERIFY_IS_EQUAL(single_patch_col_major.data()[i], single_patch_row_major.data()[i]);
103  }
104 
105  // Entire image patch: ColMajor
106  patchColMajorTensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim2 * sizeDim3, sizeDim4}};
107  Tensor<DataType, 5, DataLayout, IndexType> entire_image_patch_col_major(patchColMajorTensorRange);
108  patchTensorBuffSize = entire_image_patch_col_major.size() * sizeof(DataType);
109  DataType* gpu_data_entire_image_patch_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
110  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_entire_image_patch_col_major(
111  gpu_data_entire_image_patch_col_major, patchColMajorTensorRange);
112  gpu_entire_image_patch_col_major.device(sycl_device) = gpu_col_major.extract_image_patches(3, 5);
113  sycl_device.memcpyDeviceToHost(entire_image_patch_col_major.data(), gpu_data_entire_image_patch_col_major,
114  patchTensorBuffSize);
115 
116  VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(0), 2);
117  VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(1), 3);
118  VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(2), 5);
119  VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(3), 3 * 5);
120  VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(4), 7);
121 
122  // Entire image patch: RowMajor
123  patchRowMajorTensorRange = {{sizeDim4, sizeDim2 * sizeDim3, sizeDim3, sizeDim2, sizeDim1}};
124  Tensor<DataType, 5, RowMajor, IndexType> entire_image_patch_row_major(patchRowMajorTensorRange);
125  patchTensorBuffSize = entire_image_patch_row_major.size() * sizeof(DataType);
126  DataType* gpu_data_entire_image_patch_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
127  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_entire_image_patch_row_major(
128  gpu_data_entire_image_patch_row_major, patchRowMajorTensorRange);
129  gpu_entire_image_patch_row_major.device(sycl_device) = gpu_row_major.extract_image_patches(3, 5);
130  sycl_device.memcpyDeviceToHost(entire_image_patch_row_major.data(), gpu_data_entire_image_patch_row_major,
131  patchTensorBuffSize);
132 
133  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(0), 7);
134  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(1), 3 * 5);
135  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(2), 5);
136  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(3), 3);
137  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(4), 2);
138 
139  for (IndexType i = 0; i < 3; ++i) {
140  for (IndexType j = 0; j < 5; ++j) {
141  IndexType patchId = i + 3 * j;
142  for (IndexType r = 0; r < 3; ++r) {
143  for (IndexType c = 0; c < 5; ++c) {
144  for (IndexType d = 0; d < 2; ++d) {
145  for (IndexType b = 0; b < 7; ++b) {
146  DataType expected_col_major = 0.0f;
147  DataType expected_row_major = 0.0f;
148  if (r - 1 + i >= 0 && c - 2 + j >= 0 && r - 1 + i < 3 && c - 2 + j < 5) {
149  expected_col_major = tensor_col_major(d, r - 1 + i, c - 2 + j, b);
150  expected_row_major = tensor_row_major(b, c - 2 + j, r - 1 + i, d);
151  }
152  // ColMajor
153  if (entire_image_patch_col_major(d, r, c, patchId, b) != expected_col_major) {
154  std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
155  << " d=" << d << " b=" << b << std::endl;
156  }
157  VERIFY_IS_EQUAL(entire_image_patch_col_major(d, r, c, patchId, b), expected_col_major);
158  // RowMajor
159  if (entire_image_patch_row_major(b, patchId, c, r, d) != expected_row_major) {
160  std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
161  << " d=" << d << " b=" << b << std::endl;
162  }
163  VERIFY_IS_EQUAL(entire_image_patch_row_major(b, patchId, c, r, d), expected_row_major);
164  // Check that ColMajor and RowMajor agree.
165  VERIFY_IS_EQUAL(expected_col_major, expected_row_major);
166  }
167  }
168  }
169  }
170  }
171  }
172 
173  // 2D patch: ColMajor
174  patchColMajorTensorRange = {{sizeDim1, 2, 2, sizeDim2 * sizeDim3, sizeDim4}};
175  Tensor<DataType, 5, DataLayout, IndexType> twod_patch_col_major(patchColMajorTensorRange);
176  patchTensorBuffSize = twod_patch_col_major.size() * sizeof(DataType);
177  DataType* gpu_data_twod_patch_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
178  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_twod_patch_col_major(gpu_data_twod_patch_col_major,
179  patchColMajorTensorRange);
180  gpu_twod_patch_col_major.device(sycl_device) = gpu_col_major.extract_image_patches(2, 2);
181  sycl_device.memcpyDeviceToHost(twod_patch_col_major.data(), gpu_data_twod_patch_col_major, patchTensorBuffSize);
182 
183  VERIFY_IS_EQUAL(twod_patch_col_major.dimension(0), 2);
184  VERIFY_IS_EQUAL(twod_patch_col_major.dimension(1), 2);
185  VERIFY_IS_EQUAL(twod_patch_col_major.dimension(2), 2);
186  VERIFY_IS_EQUAL(twod_patch_col_major.dimension(3), 3 * 5);
187  VERIFY_IS_EQUAL(twod_patch_col_major.dimension(4), 7);
188 
189  // 2D patch: RowMajor
190  patchRowMajorTensorRange = {{sizeDim4, sizeDim2 * sizeDim3, 2, 2, sizeDim1}};
191  Tensor<DataType, 5, RowMajor, IndexType> twod_patch_row_major(patchRowMajorTensorRange);
192  patchTensorBuffSize = twod_patch_row_major.size() * sizeof(DataType);
193  DataType* gpu_data_twod_patch_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
194  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_twod_patch_row_major(gpu_data_twod_patch_row_major,
195  patchRowMajorTensorRange);
196  gpu_twod_patch_row_major.device(sycl_device) = gpu_row_major.extract_image_patches(2, 2);
197  sycl_device.memcpyDeviceToHost(twod_patch_row_major.data(), gpu_data_twod_patch_row_major, patchTensorBuffSize);
198 
199  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(0), 7);
200  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(1), 3 * 5);
201  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(2), 2);
202  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(3), 2);
203  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(4), 2);
204 
205  // Based on the calculation described in TensorTraits.h, padding happens to be 0.
206  IndexType row_padding = 0;
207  IndexType col_padding = 0;
208  IndexType stride = 1;
209 
210  for (IndexType i = 0; i < 3; ++i) {
211  for (IndexType j = 0; j < 5; ++j) {
212  IndexType patchId = i + 3 * j;
213  for (IndexType r = 0; r < 2; ++r) {
214  for (IndexType c = 0; c < 2; ++c) {
215  for (IndexType d = 0; d < 2; ++d) {
216  for (IndexType b = 0; b < 7; ++b) {
217  DataType expected_col_major = 0.0f;
218  DataType expected_row_major = 0.0f;
219  IndexType row_offset = r * stride + i - row_padding;
220  IndexType col_offset = c * stride + j - col_padding;
221  // ColMajor
222  if (row_offset >= 0 && col_offset >= 0 && row_offset < tensor_col_major.dimension(1) &&
223  col_offset < tensor_col_major.dimension(2)) {
224  expected_col_major = tensor_col_major(d, row_offset, col_offset, b);
225  }
226  if (twod_patch_col_major(d, r, c, patchId, b) != expected_col_major) {
227  std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
228  << " d=" << d << " b=" << b << std::endl;
229  }
230  VERIFY_IS_EQUAL(twod_patch_col_major(d, r, c, patchId, b), expected_col_major);
231 
232  // RowMajor
233  if (row_offset >= 0 && col_offset >= 0 && row_offset < tensor_row_major.dimension(2) &&
234  col_offset < tensor_row_major.dimension(1)) {
235  expected_row_major = tensor_row_major(b, col_offset, row_offset, d);
236  }
237  if (twod_patch_row_major(b, patchId, c, r, d) != expected_row_major) {
238  std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
239  << " d=" << d << " b=" << b << std::endl;
240  }
241  VERIFY_IS_EQUAL(twod_patch_row_major(b, patchId, c, r, d), expected_row_major);
242  // Check that ColMajor and RowMajor agree.
243  VERIFY_IS_EQUAL(expected_col_major, expected_row_major);
244  }
245  }
246  }
247  }
248  }
249  }
250 
251  sycl_device.deallocate(gpu_data_col_major);
252  sycl_device.deallocate(gpu_data_row_major);
253  sycl_device.deallocate(gpu_data_single_patch_col_major);
254  sycl_device.deallocate(gpu_data_single_patch_row_major);
255  sycl_device.deallocate(gpu_data_entire_image_patch_col_major);
256  sycl_device.deallocate(gpu_data_entire_image_patch_row_major);
257  sycl_device.deallocate(gpu_data_twod_patch_col_major);
258  sycl_device.deallocate(gpu_data_twod_patch_row_major);
259 }

References b, calibrate::c, Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType_ >::data(), Eigen::TensorBase< Derived, AccessLevel >::device(), Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType_ >::dimension(), i, j, UniformPSDSelfTest::r, Eigen::TensorBase< Derived, AccessLevel >::setRandom(), Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType_ >::size(), Eigen::TensorBase< Derived, AccessLevel >::swap_layout(), and VERIFY_IS_EQUAL.

Variable Documentation

◆ DataLayout

const int DataLayout = ColMajor
static

Referenced by main(), test_1D_fft_ifft_invariant(), test_2D_fft_ifft_invariant(), test_3D_fft_ifft_invariant(), test_argmax_pair_reducer(), test_argmin_pair_reducer(), test_broadcast_sycl_fixed(), test_consistency(), test_fft_2D_golden(), test_fixed_size_broadcasting(), test_full_reductions_custom_sycl(), test_index_pairs_dim(), test_last_reductions_mean_sycl(), test_last_reductions_sum_sycl(), test_padded_expr(), test_reshape_as_lvalue(), test_simple_index_pairs(), test_simple_patch(), test_simple_patch_sycl(), test_simple_reshape(), test_slice_raw_data(), and test_sub_fft_ifft_invariant().