mirror/eigen
2
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2024-12-21 07:19:46 +08:00
Code Issues Packages Projects Releases Wiki Activity
934b8a1304
eigen/unsupported/test/cxx11_tensor_contract_sycl.cpp

291 lines
12 KiB
C++
Raw Normal View History

Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2016
// Mehdi Goli Codeplay Software Ltd.
// Ralph Potter Codeplay Software Ltd.
// Luke Iwanski Codeplay Software Ltd.
// Contact: <eigen@codeplay.com>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#define EIGEN_TEST_NO_LONGDOUBLE
#define EIGEN_TEST_NO_COMPLEX
Get rid of EIGEN_TEST_FUNC, unit tests must now be declared with EIGEN_DECLARE_TEST(mytest) { /* code */ }. This provide several advantages: - more flexibility in designing unit tests - unit tests can be glued to speed up compilation - unit tests are compiled with same predefined macros, which is a requirement for zapcc
2018-07-17 20:46:15 +08:00
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
#define EIGEN_USE_SYCL
#include <iostream>
#include <chrono>
#include <ctime>
#include "main.h"
#include <unsupported/Eigen/CXX11/Tensor>
using Eigen::array;
using Eigen::SyclDevice;
using Eigen::Tensor;
using Eigen::TensorMap;
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
template<int DataLayout, typename DataType, typename IndexType, typename Device>
void static test_sycl_contraction(const Device& sycl_device, IndexType m_size, IndexType k_size, IndexType n_size)
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
{
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
typedef typename Tensor<DataType, 1, DataLayout, IndexType>::DimensionPair DimPair;
static const DataType error_threshold =1e-4f;
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
// std::cout << "Testing for (" << m_size << "," << k_size << "," << n_size << ")" << std::endl;
// with these dimensions, the output has 300 * 140 elements, which is
// more than 30 * 1024, which is the number of threads in blocks on
// a 15 SM GK110 GPU
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
Tensor<DataType, 2, DataLayout, IndexType> t_left(m_size, k_size);
Tensor<DataType, 2, DataLayout, IndexType> t_right(k_size, n_size);
Tensor<DataType, 2, DataLayout, IndexType> t_result(m_size, n_size);
Tensor<DataType, 2, DataLayout, IndexType> t_result_gpu(m_size, n_size);
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
// Eigen::array<DimPair, 1> dims(DimPair(1, 0));
Eigen::array<DimPair, 1> dims = {{DimPair(1, 0)}};
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
Eigen::array<IndexType, 2> left_dims = {{m_size, k_size}};
Eigen::array<IndexType, 2> right_dims = {{k_size, n_size}};
Eigen::array<IndexType, 2> result_dims = {{m_size, n_size}};
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
t_left.setRandom();
t_right.setRandom();
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
std::size_t t_left_bytes = t_left.size() * sizeof(DataType);
std::size_t t_right_bytes = t_right.size() * sizeof(DataType);
std::size_t t_result_bytes = t_result.size() * sizeof(DataType);
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
DataType * d_t_left = static_cast<DataType*>(sycl_device.allocate(t_left_bytes));
DataType * d_t_right = static_cast<DataType*>(sycl_device.allocate(t_right_bytes));
DataType * d_t_result = static_cast<DataType*>(sycl_device.allocate(t_result_bytes));
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType> > gpu_t_left(d_t_left, left_dims);
Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType> > gpu_t_right(d_t_right, right_dims);
Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType> > gpu_t_result(d_t_result, result_dims);
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
sycl_device.memcpyHostToDevice(d_t_left, t_left.data(),t_left_bytes);
sycl_device.memcpyHostToDevice(d_t_right, t_right.data(),t_right_bytes);
gpu_t_result.device(sycl_device) = gpu_t_left.contract(gpu_t_right, dims);
Adding Tensor ReverseOp; TensorStriding; TensorConversionOp; Modifying Tensor Contractsycl to be located in any place in the expression tree.
2017-01-16 21:58:49 +08:00
sycl_device.memcpyDeviceToHost(t_result_gpu.data(), d_t_result, t_result_bytes);
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
t_result = t_left.contract(t_right, dims);
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
for (IndexType i = 0; i < t_result.size(); i++) {
if (static_cast<DataType>(fabs(t_result(i) - t_result_gpu(i))) < error_threshold) {
Adding Tensor ReverseOp; TensorStriding; TensorConversionOp; Modifying Tensor Contractsycl to be located in any place in the expression tree.
2017-01-16 21:58:49 +08:00
continue;
}
Adding non-deferrenciable pointer track for ComputeCpp backend; Adding TensorConvolutionOp for ComputeCpp; fixing typos. modifying TensorDeviceSycl to use the LegacyPointer class.
2017-01-19 19:30:59 +08:00
if (Eigen::internal::isApprox(t_result(i), t_result_gpu(i), error_threshold)) {
Adding Tensor ReverseOp; TensorStriding; TensorConversionOp; Modifying Tensor Contractsycl to be located in any place in the expression tree.
2017-01-16 21:58:49 +08:00
continue;
}
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
std::cout << "mismatch detected at IndexType " << i << ": " << t_result(i)
Adding Tensor ReverseOp; TensorStriding; TensorConversionOp; Modifying Tensor Contractsycl to be located in any place in the expression tree.
2017-01-16 21:58:49 +08:00
<< " vs " << t_result_gpu(i) << std::endl;
assert(false);
}
sycl_device.deallocate(d_t_left);
sycl_device.deallocate(d_t_right);
sycl_device.deallocate(d_t_result);
}
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
template<int DataLayout, typename DataType, typename IndexType, typename Device>
Adding Tensor ReverseOp; TensorStriding; TensorConversionOp; Modifying Tensor Contractsycl to be located in any place in the expression tree.
2017-01-16 21:58:49 +08:00
void test_TF(const Device& sycl_device)
{
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
typedef typename Tensor<DataType, 1, DataLayout, IndexType>::DimensionPair DimPair;
static const DataType error_threshold =1e-4f;
Eigen::array<IndexType, 2> left_dims = {{2, 3}};
Eigen::array<IndexType, 2> right_dims = {{3, 1}};
Eigen::array<IndexType, 2> res_dims = {{2, 1}};
Adding Tensor ReverseOp; TensorStriding; TensorConversionOp; Modifying Tensor Contractsycl to be located in any place in the expression tree.
2017-01-16 21:58:49 +08:00
Eigen::array<DimPair, 1> dims = {{DimPair(1, 0)}};
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
Tensor<DataType, 2, DataLayout, IndexType> t_left(left_dims);
Tensor<DataType, 2, DataLayout, IndexType> t_right(right_dims);
Tensor<DataType, 2, DataLayout, IndexType> t_result_gpu(res_dims);
Tensor<DataType, 2, DataLayout, IndexType> t_result(res_dims);
Adding Tensor ReverseOp; TensorStriding; TensorConversionOp; Modifying Tensor Contractsycl to be located in any place in the expression tree.
2017-01-16 21:58:49 +08:00
t_left.data()[0] = 1.0f;
t_left.data()[1] = 2.0f;
t_left.data()[2] = 3.0f;
t_left.data()[3] = 4.0f;
t_left.data()[4] = 5.0f;
t_left.data()[5] = 6.0f;
t_right.data()[0] = -1.0f;
t_right.data()[1] = 0.5f;
t_right.data()[2] = 2.0f;
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
std::size_t t_left_bytes = t_left.size() * sizeof(DataType);
std::size_t t_right_bytes = t_right.size() * sizeof(DataType);
std::size_t t_result_bytes = t_result.size()*sizeof(DataType);
Adding Tensor ReverseOp; TensorStriding; TensorConversionOp; Modifying Tensor Contractsycl to be located in any place in the expression tree.
2017-01-16 21:58:49 +08:00
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
DataType * d_t_left = static_cast<DataType*>(sycl_device.allocate(t_left_bytes));
DataType * d_t_right = static_cast<DataType*>(sycl_device.allocate(t_right_bytes));
DataType * d_t_result = static_cast<DataType*>(sycl_device.allocate(t_result_bytes));
Adding Tensor ReverseOp; TensorStriding; TensorConversionOp; Modifying Tensor Contractsycl to be located in any place in the expression tree.
2017-01-16 21:58:49 +08:00
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType> > gpu_t_left(d_t_left, left_dims);
Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType> > gpu_t_right(d_t_right, right_dims);
Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType> > gpu_t_result(d_t_result, res_dims);
Adding Tensor ReverseOp; TensorStriding; TensorConversionOp; Modifying Tensor Contractsycl to be located in any place in the expression tree.
2017-01-16 21:58:49 +08:00
sycl_device.memcpyHostToDevice(d_t_left, t_left.data(),t_left_bytes);
sycl_device.memcpyHostToDevice(d_t_right, t_right.data(),t_right_bytes);
gpu_t_result.device(sycl_device) = gpu_t_left.contract(gpu_t_right, dims);
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
sycl_device.memcpyDeviceToHost(t_result_gpu.data(), d_t_result, t_result_bytes);
Adding Tensor ReverseOp; TensorStriding; TensorConversionOp; Modifying Tensor Contractsycl to be located in any place in the expression tree.
2017-01-16 21:58:49 +08:00
t_result = t_left.contract(t_right, dims);
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
for (IndexType i = 0; i < t_result.size(); i++) {
if (static_cast<DataType>(fabs(t_result(i) - t_result_gpu(i))) < error_threshold) {
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
continue;
}
Adding non-deferrenciable pointer track for ComputeCpp backend; Adding TensorConvolutionOp for ComputeCpp; fixing typos. modifying TensorDeviceSycl to use the LegacyPointer class.
2017-01-19 19:30:59 +08:00
if (Eigen::internal::isApprox(t_result(i), t_result_gpu(i), error_threshold)) {
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
continue;
}
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
std::cout << "mismatch detected at IndexType " << i << ": " << t_result(i)
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
<< " vs " << t_result_gpu(i) << std::endl;
assert(false);
}
sycl_device.deallocate(d_t_left);
sycl_device.deallocate(d_t_right);
sycl_device.deallocate(d_t_result);
Adding Tensor ReverseOp; TensorStriding; TensorConversionOp; Modifying Tensor Contractsycl to be located in any place in the expression tree.
2017-01-16 21:58:49 +08:00
}
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
template<int DataLayout, typename DataType, typename IndexType, typename Device>
void test_scalar(const Device& sycl_device, IndexType m_size, IndexType k_size, IndexType n_size)
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
{
//std::cout << "Testing for (" << m_size << "," << k_size << "," << n_size << ")" << std::endl;
// with these dimensions, the output has 300 * 140 elements, which is
// more than 30 * 1024, which is the number of threads in blocks on
// a 15 SM GK110 GPU
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
typedef typename Tensor<DataType, 1, DataLayout, IndexType>::DimensionPair DimPair;
static const DataType error_threshold =1e-4f;
Tensor<DataType, 2, DataLayout, IndexType> t_left(m_size, k_size);
Tensor<DataType, 2, DataLayout, IndexType> t_right(k_size, n_size);
Tensor<DataType, 0, DataLayout, IndexType> t_result;
Tensor<DataType, 0, DataLayout, IndexType> t_result_gpu;
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
Eigen::array<DimPair, 2> dims = {{DimPair(0, 0), DimPair(1, 1)}};
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
Eigen::array<IndexType, 2> left_dims = {{m_size, k_size}};
Eigen::array<IndexType, 2> right_dims = {{k_size, n_size}};
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
t_left.setRandom();
t_right.setRandom();
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
std::size_t t_left_bytes = t_left.size() * sizeof(DataType);
std::size_t t_right_bytes = t_right.size() * sizeof(DataType);
std::size_t t_result_bytes = sizeof(DataType);
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
DataType * d_t_left = static_cast<DataType*>(sycl_device.allocate(t_left_bytes));
DataType * d_t_right = static_cast<DataType*>(sycl_device.allocate(t_right_bytes));
DataType * d_t_result = static_cast<DataType*>(sycl_device.allocate(t_result_bytes));
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType> > gpu_t_left(d_t_left, left_dims);
Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType> > gpu_t_right(d_t_right, right_dims);
Eigen::TensorMap<Eigen::Tensor<DataType, 0, DataLayout, IndexType> > gpu_t_result(d_t_result);
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
sycl_device.memcpyHostToDevice(d_t_left, t_left.data(),t_left_bytes);
sycl_device.memcpyHostToDevice(d_t_right, t_right.data(),t_right_bytes);
gpu_t_result.device(sycl_device) = gpu_t_left.contract(gpu_t_right, dims);
Adding Tensor ReverseOp; TensorStriding; TensorConversionOp; Modifying Tensor Contractsycl to be located in any place in the expression tree.
2017-01-16 21:58:49 +08:00
sycl_device.memcpyDeviceToHost(t_result_gpu.data(), d_t_result, t_result_bytes);
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
t_result = t_left.contract(t_right, dims);
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
if (static_cast<DataType>(fabs(t_result() - t_result_gpu())) > error_threshold &&
Adding non-deferrenciable pointer track for ComputeCpp backend; Adding TensorConvolutionOp for ComputeCpp; fixing typos. modifying TensorDeviceSycl to use the LegacyPointer class.
2017-01-19 19:30:59 +08:00
!Eigen::internal::isApprox(t_result(), t_result_gpu(), error_threshold)) {
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
std::cout << "mismatch detected: " << t_result()
<< " vs " << t_result_gpu() << std::endl;
assert(false);
}
sycl_device.deallocate(d_t_left);
sycl_device.deallocate(d_t_right);
sycl_device.deallocate(d_t_result);
}
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
template<int DataLayout, typename DataType, typename IndexType, typename Device>
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
void test_sycl_contraction_m(const Device& sycl_device) {
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
for (IndexType k = 32; k < 256; k++) {
test_sycl_contraction<DataLayout, DataType, IndexType>(sycl_device, k, 128, 128);
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
}
}
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
template<int DataLayout, typename DataType, typename IndexType, typename Device>
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
void test_sycl_contraction_k(const Device& sycl_device) {
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
for (IndexType k = 32; k < 256; k++) {
test_sycl_contraction<DataLayout, DataType, IndexType>(sycl_device, 128, k, 128);
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
}
}
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
template<int DataLayout, typename DataType, typename IndexType, typename Device>
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
void test_sycl_contraction_n(const Device& sycl_device) {
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
for (IndexType k = 32; k < 256; k++) {
test_sycl_contraction<DataLayout, DataType, IndexType>(sycl_device, 128, 128, k);
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
}
}
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
template<int DataLayout, typename DataType, typename IndexType, typename Device>
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
void test_sycl_contraction_sizes(const Device& sycl_device) {
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
IndexType m_sizes[] = { 31, 39, 63, 64, 65,
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
127, 129, 255, 257 , 511,
512, 513, 1023, 1024, 1025};
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
IndexType n_sizes[] = { 31, 39, 63, 64, 65,
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
127, 129, 255, 257, 511,
512, 513, 1023, 1024, 1025};
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
IndexType k_sizes[] = { 31, 39, 63, 64, 65,
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
95, 96, 127, 129, 255,
257, 511, 512, 513, 1023,
1024, 1025};
Reducing warnings in Sycl backend.
2017-02-01 23:29:53 +08:00
for (IndexType i = 0; i < 15; i++) {
for (IndexType j = 0; j < 15; j++) {
for (IndexType k = 0; k < 17; k++) {
test_sycl_contraction<DataLayout, DataType,IndexType>(sycl_device, m_sizes[i], n_sizes[j], k_sizes[k]);
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
}
}
}
}
template <typename Dev_selector> void tensorContractionPerDevice(Dev_selector& s){
QueueInterface queueInterface(s);
auto sycl_device=Eigen::SyclDevice(&queueInterface);
Converting ptrdiff_t type to int64_t type in cxx11_tensor_contract_sycl.cpp in order to be the same as other tests.
2017-02-01 23:36:03 +08:00
test_sycl_contraction<ColMajor, float,int64_t>(sycl_device, 32, 32, 32);
test_sycl_contraction<RowMajor,float,int64_t>(sycl_device, 32, 32, 32);
test_scalar<ColMajor,float,int64_t>(sycl_device, 32, 32, 32);
test_scalar<RowMajor,float,int64_t>(sycl_device, 32, 32, 32);
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
std::chrono::time_point<std::chrono::system_clock> start, end;
start = std::chrono::system_clock::now();
Converting ptrdiff_t type to int64_t type in cxx11_tensor_contract_sycl.cpp in order to be the same as other tests.
2017-02-01 23:36:03 +08:00
test_sycl_contraction<ColMajor,float,int64_t>(sycl_device, 128, 128, 128);
test_sycl_contraction<RowMajor,float,int64_t>(sycl_device, 128, 128, 128);
test_scalar<ColMajor,float,int64_t>(sycl_device, 128, 128, 128);
test_scalar<RowMajor,float,int64_t>(sycl_device, 128, 128, 128);
test_sycl_contraction_m<ColMajor, float, int64_t>(sycl_device);
test_sycl_contraction_m<RowMajor, float, int64_t>(sycl_device);
test_sycl_contraction_n<ColMajor, float, int64_t>(sycl_device);
test_sycl_contraction_n<RowMajor, float, int64_t>(sycl_device);
test_sycl_contraction_k<ColMajor, float, int64_t>(sycl_device);
test_sycl_contraction_k<RowMajor, float, int64_t>(sycl_device);
test_sycl_contraction_sizes<ColMajor, float, int64_t>(sycl_device);
test_sycl_contraction_sizes<RowMajor, float, int64_t>(sycl_device);
test_TF<RowMajor, float, int64_t>(sycl_device);
test_TF<ColMajor, float, int64_t>(sycl_device);
Adding Tensor ReverseOp; TensorStriding; TensorConversionOp; Modifying Tensor Contractsycl to be located in any place in the expression tree.
2017-01-16 21:58:49 +08:00
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
end = std::chrono::system_clock::now();
std::chrono::duration<double> elapsed_seconds = end-start;
std::time_t end_time = std::chrono::system_clock::to_time_t(end);
std::cout << "finished computation at " << std::ctime(&end_time)
<< "elapsed time: " << elapsed_seconds.count() << "s\n";
}
Adding Tensor ReverseOp; TensorStriding; TensorConversionOp; Modifying Tensor Contractsycl to be located in any place in the expression tree.
2017-01-16 21:58:49 +08:00
Get rid of EIGEN_TEST_FUNC, unit tests must now be declared with EIGEN_DECLARE_TEST(mytest) { /* code */ }. This provide several advantages: - more flexibility in designing unit tests - unit tests can be glued to speed up compilation - unit tests are compiled with same predefined macros, which is a requirement for zapcc
2018-07-17 20:46:15 +08:00
EIGEN_DECLARE_TEST(cxx11_tensor_contract_sycl) {
Adding tensor contraction operation backend for Sycl; adding test for contractionOp sycl backend; adding temporary solution to prevent memory leak in buffer; cleaning up cxx11_tensor_buildins_sycl.h
2016-12-14 23:30:37 +08:00
for (const auto& device :Eigen::get_sycl_supported_devices()) {
CALL_SUBTEST(tensorContractionPerDevice(device));
}
}
Reference in New Issue Copy Permalink