1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
5 //
6 // This Source Code Form is subject to the terms of the Mozilla
7 // Public License v. 2.0. If a copy of the MPL was not distributed
8 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
9 
10 
11 #define EIGEN_TEST_NO_LONGDOUBLE
12 #define EIGEN_TEST_FUNC cxx11_tensor_cuda
13 #define EIGEN_USE_GPU
14 
15 #if defined __CUDACC_VER__ && __CUDACC_VER__ >= 70500
16 #include <cuda_fp16.h>
17 #endif
18 #include "main.h"
19 #include <unsupported/Eigen/CXX11/Tensor>
20 
21 using Eigen::Tensor;
22 
23 template <int Layout>
test_cuda_simple_argmax()24 void test_cuda_simple_argmax()
25 {
26   Tensor<double, 3, Layout> in(Eigen::array<DenseIndex, 3>(72,53,97));
27   Tensor<DenseIndex, 1, Layout> out_max(Eigen::array<DenseIndex, 1>(1));
28   Tensor<DenseIndex, 1, Layout> out_min(Eigen::array<DenseIndex, 1>(1));
29   in.setRandom();
30   in *= in.constant(100.0);
31   in(0, 0, 0) = -1000.0;
32   in(71, 52, 96) = 1000.0;
33 
34   std::size_t in_bytes = in.size() * sizeof(double);
35   std::size_t out_bytes = out_max.size() * sizeof(DenseIndex);
36 
37   double* d_in;
38   DenseIndex* d_out_max;
39   DenseIndex* d_out_min;
40   cudaMalloc((void**)(&d_in), in_bytes);
41   cudaMalloc((void**)(&d_out_max), out_bytes);
42   cudaMalloc((void**)(&d_out_min), out_bytes);
43 
44   cudaMemcpy(d_in, in.data(), in_bytes, cudaMemcpyHostToDevice);
45 
46   Eigen::CudaStreamDevice stream;
47   Eigen::GpuDevice gpu_device(&stream);
48 
49   Eigen::TensorMap<Eigen::Tensor<double, 3, Layout>, Aligned > gpu_in(d_in, Eigen::array<DenseIndex, 3>(72,53,97));
50   Eigen::TensorMap<Eigen::Tensor<DenseIndex, 1, Layout>, Aligned > gpu_out_max(d_out_max, Eigen::array<DenseIndex, 1>(1));
51   Eigen::TensorMap<Eigen::Tensor<DenseIndex, 1, Layout>, Aligned > gpu_out_min(d_out_min, Eigen::array<DenseIndex, 1>(1));
52 
53   gpu_out_max.device(gpu_device) = gpu_in.argmax();
54   gpu_out_min.device(gpu_device) = gpu_in.argmin();
55 
56   assert(cudaMemcpyAsync(out_max.data(), d_out_max, out_bytes, cudaMemcpyDeviceToHost, gpu_device.stream()) == cudaSuccess);
57   assert(cudaMemcpyAsync(out_min.data(), d_out_min, out_bytes, cudaMemcpyDeviceToHost, gpu_device.stream()) == cudaSuccess);
58   assert(cudaStreamSynchronize(gpu_device.stream()) == cudaSuccess);
59 
60   VERIFY_IS_EQUAL(out_max(Eigen::array<DenseIndex, 1>(0)), 72*53*97 - 1);
61   VERIFY_IS_EQUAL(out_min(Eigen::array<DenseIndex, 1>(0)), 0);
62 
63   cudaFree(d_in);
64   cudaFree(d_out_max);
65   cudaFree(d_out_min);
66 }
67 
68 template <int DataLayout>
test_cuda_argmax_dim()69 void test_cuda_argmax_dim()
70 {
71   Tensor<float, 4, DataLayout> tensor(2,3,5,7);
72   std::vector<int> dims;
73   dims.push_back(2); dims.push_back(3); dims.push_back(5); dims.push_back(7);
74 
75   for (int dim = 0; dim < 4; ++dim) {
76     tensor.setRandom();
77     tensor = (tensor + tensor.constant(0.5)).log();
78 
79     array<DenseIndex, 3> out_shape;
80     for (int d = 0; d < 3; ++d) out_shape[d] = (d < dim) ? dims[d] : dims[d+1];
81 
82     Tensor<DenseIndex, 3, DataLayout> tensor_arg(out_shape);
83 
84     array<DenseIndex, 4> ix;
85     for (int i = 0; i < 2; ++i) {
86       for (int j = 0; j < 3; ++j) {
87         for (int k = 0; k < 5; ++k) {
88           for (int l = 0; l < 7; ++l) {
89             ix[0] = i; ix[1] = j; ix[2] = k; ix[3] = l;
90             if (ix[dim] != 0) continue;
91             // suppose dim == 1, then for all i, k, l, set tensor(i, 0, k, l) = 10.0
92             tensor(ix) = 10.0;
93           }
94         }
95       }
96     }
97 
98     std::size_t in_bytes = tensor.size() * sizeof(float);
99     std::size_t out_bytes = tensor_arg.size() * sizeof(DenseIndex);
100 
101     float* d_in;
102     DenseIndex* d_out;
103     cudaMalloc((void**)(&d_in), in_bytes);
104     cudaMalloc((void**)(&d_out), out_bytes);
105 
106     cudaMemcpy(d_in, tensor.data(), in_bytes, cudaMemcpyHostToDevice);
107 
108     Eigen::CudaStreamDevice stream;
109     Eigen::GpuDevice gpu_device(&stream);
110 
111     Eigen::TensorMap<Eigen::Tensor<float, 4, DataLayout>, Aligned > gpu_in(d_in, Eigen::array<DenseIndex, 4>(2, 3, 5, 7));
112     Eigen::TensorMap<Eigen::Tensor<DenseIndex, 3, DataLayout>, Aligned > gpu_out(d_out, out_shape);
113 
114     gpu_out.device(gpu_device) = gpu_in.argmax(dim);
115 
116     assert(cudaMemcpyAsync(tensor_arg.data(), d_out, out_bytes, cudaMemcpyDeviceToHost, gpu_device.stream()) == cudaSuccess);
117     assert(cudaStreamSynchronize(gpu_device.stream()) == cudaSuccess);
118 
119     VERIFY_IS_EQUAL(tensor_arg.size(),
120                     size_t(2*3*5*7 / tensor.dimension(dim)));
121 
122     for (DenseIndex n = 0; n < tensor_arg.size(); ++n) {
123       // Expect max to be in the first index of the reduced dimension
124       VERIFY_IS_EQUAL(tensor_arg.data()[n], 0);
125     }
126 
127     for (int i = 0; i < 2; ++i) {
128       for (int j = 0; j < 3; ++j) {
129         for (int k = 0; k < 5; ++k) {
130           for (int l = 0; l < 7; ++l) {
131             ix[0] = i; ix[1] = j; ix[2] = k; ix[3] = l;
132             if (ix[dim] != tensor.dimension(dim) - 1) continue;
133             // suppose dim == 1, then for all i, k, l, set tensor(i, 2, k, l) = 20.0
134             tensor(ix) = 20.0;
135           }
136         }
137       }
138     }
139 
140     cudaMemcpy(d_in, tensor.data(), in_bytes, cudaMemcpyHostToDevice);
141 
142     gpu_out.device(gpu_device) = gpu_in.argmax(dim);
143 
144     assert(cudaMemcpyAsync(tensor_arg.data(), d_out, out_bytes, cudaMemcpyDeviceToHost, gpu_device.stream()) == cudaSuccess);
145     assert(cudaStreamSynchronize(gpu_device.stream()) == cudaSuccess);
146 
147     for (DenseIndex n = 0; n < tensor_arg.size(); ++n) {
148       // Expect max to be in the last index of the reduced dimension
149       VERIFY_IS_EQUAL(tensor_arg.data()[n], tensor.dimension(dim) - 1);
150     }
151 
152     cudaFree(d_in);
153     cudaFree(d_out);
154   }
155 }
156 
157 template <int DataLayout>
test_cuda_argmin_dim()158 void test_cuda_argmin_dim()
159 {
160   Tensor<float, 4, DataLayout> tensor(2,3,5,7);
161   std::vector<int> dims;
162   dims.push_back(2); dims.push_back(3); dims.push_back(5); dims.push_back(7);
163 
164   for (int dim = 0; dim < 4; ++dim) {
165     tensor.setRandom();
166     tensor = (tensor + tensor.constant(0.5)).log();
167 
168     array<DenseIndex, 3> out_shape;
169     for (int d = 0; d < 3; ++d) out_shape[d] = (d < dim) ? dims[d] : dims[d+1];
170 
171     Tensor<DenseIndex, 3, DataLayout> tensor_arg(out_shape);
172 
173     array<DenseIndex, 4> ix;
174     for (int i = 0; i < 2; ++i) {
175       for (int j = 0; j < 3; ++j) {
176         for (int k = 0; k < 5; ++k) {
177           for (int l = 0; l < 7; ++l) {
178             ix[0] = i; ix[1] = j; ix[2] = k; ix[3] = l;
179             if (ix[dim] != 0) continue;
180             // suppose dim == 1, then for all i, k, l, set tensor(i, 0, k, l) = 10.0
181             tensor(ix) = -10.0;
182           }
183         }
184       }
185     }
186 
187     std::size_t in_bytes = tensor.size() * sizeof(float);
188     std::size_t out_bytes = tensor_arg.size() * sizeof(DenseIndex);
189 
190     float* d_in;
191     DenseIndex* d_out;
192     cudaMalloc((void**)(&d_in), in_bytes);
193     cudaMalloc((void**)(&d_out), out_bytes);
194 
195     cudaMemcpy(d_in, tensor.data(), in_bytes, cudaMemcpyHostToDevice);
196 
197     Eigen::CudaStreamDevice stream;
198     Eigen::GpuDevice gpu_device(&stream);
199 
200     Eigen::TensorMap<Eigen::Tensor<float, 4, DataLayout>, Aligned > gpu_in(d_in, Eigen::array<DenseIndex, 4>(2, 3, 5, 7));
201     Eigen::TensorMap<Eigen::Tensor<DenseIndex, 3, DataLayout>, Aligned > gpu_out(d_out, out_shape);
202 
203     gpu_out.device(gpu_device) = gpu_in.argmin(dim);
204 
205     assert(cudaMemcpyAsync(tensor_arg.data(), d_out, out_bytes, cudaMemcpyDeviceToHost, gpu_device.stream()) == cudaSuccess);
206     assert(cudaStreamSynchronize(gpu_device.stream()) == cudaSuccess);
207 
208     VERIFY_IS_EQUAL(tensor_arg.size(),
209                     2*3*5*7 / tensor.dimension(dim));
210 
211     for (DenseIndex n = 0; n < tensor_arg.size(); ++n) {
212       // Expect min to be in the first index of the reduced dimension
213       VERIFY_IS_EQUAL(tensor_arg.data()[n], 0);
214     }
215 
216     for (int i = 0; i < 2; ++i) {
217       for (int j = 0; j < 3; ++j) {
218         for (int k = 0; k < 5; ++k) {
219           for (int l = 0; l < 7; ++l) {
220             ix[0] = i; ix[1] = j; ix[2] = k; ix[3] = l;
221             if (ix[dim] != tensor.dimension(dim) - 1) continue;
222             // suppose dim == 1, then for all i, k, l, set tensor(i, 2, k, l) = 20.0
223             tensor(ix) = -20.0;
224           }
225         }
226       }
227     }
228 
229     cudaMemcpy(d_in, tensor.data(), in_bytes, cudaMemcpyHostToDevice);
230 
231     gpu_out.device(gpu_device) = gpu_in.argmin(dim);
232 
233     assert(cudaMemcpyAsync(tensor_arg.data(), d_out, out_bytes, cudaMemcpyDeviceToHost, gpu_device.stream()) == cudaSuccess);
234     assert(cudaStreamSynchronize(gpu_device.stream()) == cudaSuccess);
235 
236     for (DenseIndex n = 0; n < tensor_arg.size(); ++n) {
237       // Expect max to be in the last index of the reduced dimension
238       VERIFY_IS_EQUAL(tensor_arg.data()[n], tensor.dimension(dim) - 1);
239     }
240 
241     cudaFree(d_in);
242     cudaFree(d_out);
243   }
244 }
245 
test_cxx11_tensor_cuda()246 void test_cxx11_tensor_cuda()
247 {
248   CALL_SUBTEST_1(test_cuda_simple_argmax<RowMajor>());
249   CALL_SUBTEST_1(test_cuda_simple_argmax<ColMajor>());
250   CALL_SUBTEST_2(test_cuda_argmax_dim<RowMajor>());
251   CALL_SUBTEST_2(test_cuda_argmax_dim<ColMajor>());
252   CALL_SUBTEST_3(test_cuda_argmin_dim<RowMajor>());
253   CALL_SUBTEST_3(test_cuda_argmin_dim<ColMajor>());
254 }
255