1548 lines
58 KiB
C++
1548 lines
58 KiB
C++
/*******************************************************************************
|
|
* Copyright (c) 2015-2018 Skymind, Inc.
|
|
*
|
|
* This program and the accompanying materials are made available under the
|
|
* terms of the Apache License, Version 2.0 which is available at
|
|
* https://www.apache.org/licenses/LICENSE-2.0.
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
* License for the specific language governing permissions and limitations
|
|
* under the License.
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
******************************************************************************/
|
|
|
|
//
|
|
// Created by GS <sgazeos@gmail.com> on 22.07.2019.
|
|
//
|
|
|
|
#include "testlayers.h"
|
|
#include <NDArray.h>
|
|
#include <ShapeUtils.h>
|
|
#include <reduce3.h>
|
|
#include <ops/declarable/LegacyTransformOp.h>
|
|
#include <ops/declarable/LegacyPairwiseTransformOp.h>
|
|
#include <ops/declarable/LegacyScalarOp.h>
|
|
#include <ops/declarable/LegacyReduceSameOp.h>
|
|
#include <ops/declarable/LegacyReduceFloatOp.h>
|
|
#include <ops/declarable/LegacyIndexReduceOp.h>
|
|
#include <ops/declarable/LegacyBroadcastOp.h>
|
|
#include <helpers/TAD.h>
|
|
#include <helpers/ConstantTadHelper.h>
|
|
#include <type_conversions.h>
|
|
#include <ops/declarable/CustomOperations.h>
|
|
using namespace nd4j;
|
|
using namespace nd4j::ops;
|
|
|
|
class NativeOpsTests : public testing::Test {
|
|
public:
|
|
|
|
};
|
|
|
|
|
|
TEST_F(NativeOpsTests, CreateContextTests_1) {
|
|
// auto x = NDArrayFactory::create<float>('c', {5, 5});
|
|
// x.assign(1.0);
|
|
// auto z = NDArrayFactory::create<float>('c', {5,5});
|
|
// auto exp = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto context = ::createContext();
|
|
ASSERT_TRUE(context == nullptr);
|
|
//delete context;
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, CreateContextTests_2) {
|
|
// auto x = NDArrayFactory::create<float>('c', {5, 5});
|
|
// x.assign(1.0);
|
|
// auto z = NDArrayFactory::create<float>('c', {5,5});
|
|
// auto exp = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto context1 = ::createContext();
|
|
auto context2 = ::createContext();
|
|
ASSERT_TRUE(context1 == context2);
|
|
//delete context1;
|
|
//delete context2;
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, PointerTests_1) {
|
|
auto x = NDArrayFactory::create<float>('c', {5}, {1,2,3,4,5});
|
|
// x.linspace(1.0);
|
|
#ifdef __CUDABLAS__
|
|
printf("Unsupported for cuda now.\n");
|
|
#else
|
|
::tryPointer(nullptr, x.getBuffer(), 4);
|
|
#endif
|
|
|
|
// auto exp = NDArrayFactory::create<float>('c', {5, 5});
|
|
// exp.assign(-1.0);
|
|
//
|
|
// nd4j::ops::LegacyTransformSameOp op(transform::Neg); // Neg
|
|
// auto result = op.execute({&x}, {}, {});
|
|
//
|
|
// ASSERT_EQ(1, result->size());
|
|
//
|
|
// auto z = result->at(0);
|
|
//
|
|
// ASSERT_TRUE(exp.equalsTo(z));
|
|
//
|
|
// delete result;
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, ThresholdTests_1) {
|
|
// auto x = NDArrayFactory::create<float>('c', {5}, {1,2,3,4,5});
|
|
// x.linspace(1.0);
|
|
#ifdef __CUDABLAS__
|
|
printf("Unsupported for cuda now.\n");
|
|
#else
|
|
::setElementThreshold(4);
|
|
ASSERT_TRUE(4 == nd4j::Environment::getInstance()->elementwiseThreshold());
|
|
#endif
|
|
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, ThresholdTests_2) {
|
|
// auto x = NDArrayFactory::create<float>('c', {5}, {1,2,3,4,5});
|
|
// x.linspace(1.0);
|
|
#ifdef __CUDABLAS__
|
|
printf("Unsupported for cuda now.\n");
|
|
#else
|
|
::setTADThreshold(4);
|
|
ASSERT_TRUE(4 == nd4j::Environment::getInstance()->tadThreshold());
|
|
#endif
|
|
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, ExecIndexReduce_1) {
|
|
auto x = NDArrayFactory::create<float>('c', {5}, {1,2,3,4,5});
|
|
auto exp = NDArrayFactory::create<Nd4jLong>(120);
|
|
x.linspace(1.0);
|
|
#ifdef __CUDABLAS__
|
|
printf("Unsupported for cuda now.\n");
|
|
#else
|
|
::execIndexReduceScalar(nullptr,
|
|
indexreduce::IndexMax,
|
|
x.buffer(), x.shapeInfo(),
|
|
nullptr, nullptr,
|
|
nullptr,
|
|
exp.buffer(), exp.shapeInfo(),
|
|
nullptr, nullptr);
|
|
|
|
ASSERT_TRUE(exp.e<Nd4jLong>(0) == 4LL);
|
|
#endif
|
|
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, ExecIndexReduce_2) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto exp = NDArrayFactory::create<Nd4jLong>(120);
|
|
x.linspace(1.0);
|
|
#ifdef __CUDABLAS__
|
|
printf("Unsupported for cuda now.\n");
|
|
#else
|
|
NDArray dimension = NDArrayFactory::create<int>({});
|
|
::execIndexReduce(nullptr,
|
|
indexreduce::IndexMax,
|
|
x.buffer(), x.shapeInfo(),
|
|
nullptr, nullptr,
|
|
nullptr,
|
|
exp.buffer(), exp.shapeInfo(),
|
|
nullptr, nullptr,
|
|
dimension.buffer(), dimension.shapeInfo(),
|
|
nullptr, nullptr);
|
|
|
|
ASSERT_TRUE(exp.e<Nd4jLong>(0) == 24LL);
|
|
#endif
|
|
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, ExecBroadcast_1) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto y = NDArrayFactory::create<float>('c', {5, 1});
|
|
auto exp = NDArrayFactory::create<float>('c', {5, 5});
|
|
x.linspace(1.0);
|
|
y.linspace(2,2);
|
|
#ifdef __CUDABLAS__
|
|
printf("Unsupported for cuda now.\n");
|
|
#else
|
|
auto dimension = NDArrayFactory::create<int>('c', {1}, {1});
|
|
|
|
::execBroadcast(nullptr,
|
|
broadcast::Add,
|
|
x.buffer(), x.shapeInfo(),
|
|
nullptr, nullptr,
|
|
y.buffer(), y.shapeInfo(),
|
|
nullptr, nullptr,
|
|
exp.buffer(), exp.shapeInfo(),
|
|
nullptr, nullptr,
|
|
dimension.buffer(), dimension.shapeInfo(),
|
|
nullptr, nullptr);
|
|
|
|
ASSERT_TRUE(exp.e<float>(0) == 3.);
|
|
#endif
|
|
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, ExecBroadcast_2) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto y = NDArrayFactory::create<float>('c', {5, 1});
|
|
auto exp = NDArrayFactory::create<bool>('c', {5, 5});
|
|
x.linspace(1.0);
|
|
y.linspace(2,2);
|
|
#ifdef __CUDABLAS__
|
|
printf("Unsupported for cuda now.\n");
|
|
#else
|
|
auto dimension = NDArrayFactory::create<int>('c', {1}, {(int)0});
|
|
|
|
::execBroadcastBool(nullptr,
|
|
broadcast::EqualTo,
|
|
x.buffer(), x.shapeInfo(),
|
|
nullptr, nullptr,
|
|
y.buffer(), y.shapeInfo(),
|
|
nullptr, nullptr,
|
|
exp.buffer(), exp.shapeInfo(),
|
|
nullptr, nullptr,
|
|
dimension.buffer(), dimension.shapeInfo(),
|
|
nullptr, nullptr);
|
|
ASSERT_TRUE(exp.e<bool>(1) && !exp.e<bool>(0));
|
|
#endif
|
|
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, ExecPairwise_1) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto y = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto exp = NDArrayFactory::create<float>('c', {5, 5});
|
|
x.linspace(1.0);
|
|
y.assign(2.);
|
|
#ifdef __CUDABLAS__
|
|
printf("Unsupported for cuda now.\n");
|
|
#else
|
|
::execPairwiseTransform(nullptr,
|
|
pairwise::Add,
|
|
x.buffer(), x.shapeInfo(),
|
|
nullptr, nullptr,
|
|
y.buffer(), y.shapeInfo(),
|
|
nullptr, nullptr,
|
|
exp.buffer(), exp.shapeInfo(),
|
|
nullptr, nullptr,
|
|
nullptr);
|
|
ASSERT_TRUE(exp.e<float>(5) == 8.);
|
|
#endif
|
|
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, ExecPairwise_2) {
|
|
auto x = NDArrayFactory::create<bool>('c', {5, 5});
|
|
auto y = NDArrayFactory::create<bool>('c', {5, 5});
|
|
auto exp = NDArrayFactory::create<bool>('c', {5, 5});
|
|
x.assign(true);
|
|
y.assign(false);
|
|
y.t<bool>(5) = true;
|
|
#ifdef __CUDABLAS__
|
|
printf("Unsupported for cuda now.\n");
|
|
#else
|
|
::execPairwiseTransformBool(nullptr,
|
|
pairwise::And,
|
|
x.buffer(), x.shapeInfo(),
|
|
nullptr, nullptr,
|
|
y.buffer(), y.shapeInfo(),
|
|
nullptr, nullptr,
|
|
exp.buffer(), exp.shapeInfo(),
|
|
nullptr, nullptr,
|
|
nullptr);
|
|
ASSERT_TRUE(exp.e<bool>(5) && !exp.e<bool>(4));
|
|
#endif
|
|
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, ReduceTest_1) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto exp = NDArrayFactory::create<float>(120.);
|
|
x.linspace(1.0);
|
|
|
|
#ifdef __CUDABLAS__
|
|
printf("Unsupported for cuda now.\n");
|
|
#else
|
|
auto dimension = NDArrayFactory::create<int>('c', {1}, {1});
|
|
|
|
::execReduceFloat(nullptr,
|
|
reduce::Mean,
|
|
x.buffer(), x.shapeInfo(),
|
|
nullptr, nullptr,
|
|
nullptr,
|
|
exp.buffer(), exp.shapeInfo(),
|
|
nullptr, nullptr);
|
|
// x.printIndexedBuffer("Input");
|
|
// exp.printIndexedBuffer("Reduce Mean");
|
|
ASSERT_TRUE(exp.e<float>(0) == 13.);
|
|
#endif
|
|
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, ReduceTest_2) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto exp = NDArrayFactory::create<float>(120.);
|
|
x.linspace(1.0);
|
|
|
|
#ifdef __CUDABLAS__
|
|
printf("Unsupported for cuda now.\n");
|
|
#else
|
|
|
|
::execReduceSame(nullptr,
|
|
reduce::Sum,
|
|
x.buffer(), x.shapeInfo(),
|
|
nullptr, nullptr,
|
|
nullptr,
|
|
exp.buffer(), exp.shapeInfo(),
|
|
nullptr, nullptr);
|
|
// x.printIndexedBuffer("Input");
|
|
// exp.printIndexedBuffer("Reduce Sum");
|
|
ASSERT_TRUE(exp.e<float>(0) == 325.);
|
|
#endif
|
|
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, ReduceTest_3) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto exp = NDArrayFactory::create<bool>(false);
|
|
x.linspace(1.0);
|
|
|
|
#ifdef __CUDABLAS__
|
|
printf("Unsupported for cuda now.\n");
|
|
#else
|
|
|
|
::execReduceBool(nullptr,
|
|
reduce::All,
|
|
x.buffer(), x.shapeInfo(),
|
|
nullptr, nullptr,
|
|
nullptr,
|
|
exp.buffer(), exp.shapeInfo(),
|
|
nullptr, nullptr);
|
|
// x.printIndexedBuffer("Input");
|
|
// exp.printIndexedBuffer("Reduce All");
|
|
ASSERT_TRUE(exp.e<bool>(0) == true);
|
|
#endif
|
|
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, ReduceTest_4) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto exp = NDArrayFactory::create<Nd4jLong>(120LL);
|
|
x.linspace(1.0);
|
|
|
|
#ifdef __CUDABLAS__
|
|
printf("Unsupported for cuda now.\n");
|
|
#else
|
|
|
|
::execReduceLong(nullptr,
|
|
reduce::CountNonZero,
|
|
x.buffer(), x.shapeInfo(),
|
|
nullptr, nullptr,
|
|
nullptr,
|
|
exp.buffer(), exp.shapeInfo(),
|
|
nullptr, nullptr);
|
|
// x.printIndexedBuffer("Input");
|
|
// exp.printIndexedBuffer("Reduce CountNonZero");
|
|
ASSERT_TRUE(exp.e<Nd4jLong>(0) == 25LL);
|
|
#endif
|
|
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, ReduceTest_5) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto exp = NDArrayFactory::create<Nd4jLong>(120LL);
|
|
x.linspace(1.0);
|
|
|
|
#ifdef __CUDABLAS__
|
|
printf("Unsupported for cuda now.\n");
|
|
#else
|
|
auto dimension = NDArrayFactory::create<int>({0, 1});
|
|
::execReduceLong2(nullptr,
|
|
reduce::CountNonZero,
|
|
x.buffer(), x.shapeInfo(),
|
|
nullptr, nullptr,
|
|
nullptr,
|
|
exp.buffer(), exp.shapeInfo(),
|
|
nullptr, nullptr,
|
|
dimension.buffer(), dimension.shapeInfo(),
|
|
dimension.specialBuffer(), dimension.specialShapeInfo());
|
|
// x.printIndexedBuffer("Input");
|
|
// exp.printIndexedBuffer("Reduce CountNonZero");
|
|
ASSERT_TRUE(exp.e<Nd4jLong>(0) == 25LL);
|
|
#endif
|
|
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, ReduceTest_6) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto z = NDArrayFactory::create<Nd4jLong>({5, 4, 3, 2, 1});
|
|
auto exp = NDArrayFactory::create<Nd4jLong>({1,2,3,4,6});
|
|
x.linspace(1.0);
|
|
|
|
#ifdef __CUDABLAS__
|
|
printf("Unsupported for cuda now.\n");
|
|
#else
|
|
auto dimension = NDArrayFactory::create<int>('c', {1}, {1});
|
|
x.p(5, 0);
|
|
x.p(10, 0); x.p(11, 0);
|
|
x.p(15, 0); x.p(16, 0); x.p(17, 0);
|
|
x.p(20, 0); x.p(21, 0); x.p(22, 0); x.p(23, 0);
|
|
::execReduceLong2(nullptr,
|
|
reduce::CountNonZero,
|
|
x.buffer(), x.shapeInfo(),
|
|
nullptr, nullptr,
|
|
nullptr,
|
|
exp.buffer(), exp.shapeInfo(),
|
|
nullptr, nullptr,
|
|
dimension.buffer(), dimension.shapeInfo(),
|
|
dimension.specialBuffer(), dimension.specialShapeInfo());
|
|
// x.printIndexedBuffer("Input");
|
|
// exp.printIndexedBuffer("Reduce CountNonZero");
|
|
ASSERT_TRUE(exp.equalsTo(z));
|
|
#endif
|
|
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, ReduceTest_7) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto exp = NDArrayFactory::create<float>(120.);
|
|
auto z = NDArrayFactory::create<float>(13.);
|
|
|
|
|
|
auto dimension = NDArrayFactory::create<int>('c', {2}, {0, 1});
|
|
Nd4jPointer extra[6];
|
|
#ifdef __CUDABLAS__
|
|
x.syncToHost();
|
|
extra[1] = x.getContext()->getCudaStream();
|
|
extra[0] = extra[2] = extra[3] = extra[4] = extra[5] = nullptr;
|
|
#endif
|
|
x.linspace(1.0);
|
|
x.syncToDevice();
|
|
dimension.syncToHost();
|
|
::execReduceFloat2(extra,
|
|
reduce::Mean,
|
|
x.buffer(), x.shapeInfo(),
|
|
x.specialBuffer(), x.specialShapeInfo(),
|
|
nullptr,
|
|
exp.buffer(), exp.shapeInfo(),
|
|
exp.specialBuffer(), exp.specialShapeInfo(),
|
|
dimension.buffer(), dimension.shapeInfo(),
|
|
dimension.specialBuffer(), dimension.specialShapeInfo());
|
|
// x.printIndexedBuffer("Input");
|
|
// exp.printIndexedBuffer("Reduce Mean");
|
|
ASSERT_TRUE(exp.equalsTo(z));
|
|
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, ReduceTest_8) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto z = NDArrayFactory::create<float>(120.);
|
|
auto exp = NDArrayFactory::create<float>(325.);
|
|
|
|
|
|
auto dimension = NDArrayFactory::create<int>('c', {2}, {0, 1});
|
|
Nd4jPointer extra[6];
|
|
#ifdef __CUDABLAS__
|
|
extra[1] = x.getContext()->getCudaStream();
|
|
extra[0] = extra[2] = extra[3] = extra[4] = extra[5] = nullptr;
|
|
x.syncToHost();
|
|
#endif
|
|
x.linspace(1.0);
|
|
x.syncToDevice();
|
|
|
|
dimension.syncToHost();
|
|
|
|
::execReduceSame2(extra,
|
|
reduce::Sum,
|
|
x.buffer(), x.shapeInfo(),
|
|
x.specialBuffer(), x.specialShapeInfo(),
|
|
nullptr,
|
|
z.buffer(), z.shapeInfo(),
|
|
z.specialBuffer(), z.specialShapeInfo(),
|
|
dimension.buffer(), dimension.shapeInfo(),
|
|
dimension.specialBuffer(), dimension.specialShapeInfo());
|
|
// x.printIndexedBuffer("Input");
|
|
// exp.printIndexedBuffer("Reduce Sum");
|
|
ASSERT_TRUE(exp.equalsTo(z));
|
|
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, ReduceTest_9) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto exp = NDArrayFactory::create<bool>(false);
|
|
auto z = NDArrayFactory::create<bool>(true);
|
|
|
|
auto dimension = NDArrayFactory::create<int>('c', {2}, {0, 1});
|
|
Nd4jPointer extra[6];
|
|
#ifdef __CUDABLAS__
|
|
extra[1] = x.getContext()->getCudaStream();
|
|
extra[0] = extra[2] = extra[3] = extra[4] = extra[5] = nullptr;
|
|
x.syncToHost();
|
|
#endif
|
|
x.linspace(1.0);
|
|
x.syncToDevice();
|
|
|
|
dimension.syncToHost();
|
|
::execReduceBool2(extra,
|
|
reduce::All,
|
|
x.buffer(), x.shapeInfo(),
|
|
x.specialBuffer(), x.specialShapeInfo(),
|
|
nullptr,
|
|
exp.buffer(), exp.shapeInfo(),
|
|
exp.specialBuffer(), exp.specialShapeInfo(),
|
|
dimension.buffer(), dimension.shapeInfo(),
|
|
dimension.specialBuffer(), dimension.specialShapeInfo());
|
|
// x.printIndexedBuffer("Input");
|
|
// exp.printIndexedBuffer("Reduce All");
|
|
ASSERT_TRUE(exp.equalsTo(z));
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, Reduce3Test_1) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto y = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto exp = NDArrayFactory::create<float>(120.);
|
|
auto z = NDArrayFactory::create<float>(650.);
|
|
|
|
auto dimension = NDArrayFactory::create<int>('c', {2}, {0, 1});
|
|
Nd4jPointer extra[6];
|
|
#ifdef __CUDABLAS__
|
|
extra[1] = x.getContext()->getCudaStream();
|
|
extra[0] = extra[2] = extra[3] = extra[4] = extra[5] = nullptr;
|
|
x.syncToHost();
|
|
printf("Unsupported for CUDA platform yet.\n");
|
|
return;
|
|
#endif
|
|
x.linspace(1.0);
|
|
y.assign(2.);
|
|
x.syncToDevice();
|
|
|
|
::execReduce3(extra,
|
|
reduce3::Dot,
|
|
x.buffer(), x.shapeInfo(),
|
|
x.specialBuffer(), x.specialShapeInfo(),
|
|
nullptr,
|
|
y.buffer(), y.shapeInfo(),
|
|
y.specialBuffer(), y.specialShapeInfo(),
|
|
exp.buffer(), exp.shapeInfo(),
|
|
exp.specialBuffer(), exp.specialShapeInfo());
|
|
// x.printIndexedBuffer("Input");
|
|
// exp.printIndexedBuffer("Reduce3 Dot");
|
|
ASSERT_TRUE(exp.equalsTo(z));
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, Reduce3Test_2) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto y = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto exp = NDArrayFactory::create<float>(120.);
|
|
auto z = NDArrayFactory::create<float>(650.);
|
|
|
|
auto dimension = NDArrayFactory::create<int>('c', {2}, {0, 1});
|
|
Nd4jPointer extra[6];
|
|
#ifdef __CUDABLAS__
|
|
extra[1] = x.getContext()->getCudaStream();
|
|
extra[0] = extra[2] = extra[3] = extra[4] = extra[5] = nullptr;
|
|
x.syncToHost();
|
|
printf("Unsupported for CUDA platform yet.\n");
|
|
return;
|
|
#endif
|
|
x.linspace(1.0);
|
|
y.assign(2.);
|
|
x.syncToDevice();
|
|
|
|
::execReduce3Scalar(extra,
|
|
reduce3::Dot,
|
|
x.buffer(), x.shapeInfo(),
|
|
x.specialBuffer(), x.specialShapeInfo(),
|
|
nullptr,
|
|
y.buffer(), y.shapeInfo(),
|
|
y.specialBuffer(), y.specialShapeInfo(),
|
|
exp.buffer(), exp.shapeInfo(),
|
|
exp.specialBuffer(), exp.specialShapeInfo());
|
|
// x.printIndexedBuffer("Input");
|
|
// exp.printIndexedBuffer("Reduce3 Dot");
|
|
ASSERT_TRUE(exp.equalsTo(z));
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, Reduce3Test_3) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto y = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto exp = NDArrayFactory::create<float>(120.);
|
|
auto z = NDArrayFactory::create<float>(650.);
|
|
|
|
auto dimension = NDArrayFactory::create<int>('c', {2}, {0, 1});
|
|
Nd4jPointer extra[6];
|
|
#ifdef __CUDABLAS__
|
|
extra[1] = x.getContext()->getCudaStream();
|
|
extra[0] = extra[2] = extra[3] = extra[4] = extra[5] = nullptr;
|
|
x.syncToHost();
|
|
printf("Unsupported for CUDA platform yet.\n");
|
|
return;
|
|
#endif
|
|
x.linspace(1.0);
|
|
y.assign(2.);
|
|
x.syncToDevice();
|
|
dimension.syncToHost();
|
|
|
|
::execReduce3Tad(extra,
|
|
reduce3::Dot,
|
|
x.buffer(), x.shapeInfo(),
|
|
x.specialBuffer(), x.specialShapeInfo(),
|
|
nullptr,
|
|
y.buffer(), y.shapeInfo(),
|
|
y.specialBuffer(), y.specialShapeInfo(),
|
|
exp.buffer(), exp.shapeInfo(),
|
|
exp.specialBuffer(), exp.specialShapeInfo(),
|
|
dimension.buffer(), dimension.shapeInfo(),
|
|
dimension.specialBuffer(), dimension.specialShapeInfo(),
|
|
nullptr, nullptr, nullptr, nullptr);
|
|
// x.printIndexedBuffer("Input");
|
|
// exp.printIndexedBuffer("Reduce All");
|
|
ASSERT_TRUE(exp.equalsTo(z));
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, Reduce3Test_4) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto y = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto exp = NDArrayFactory::create<float>(120.);
|
|
auto z = NDArrayFactory::create<float>(650.);
|
|
|
|
auto dimension = NDArrayFactory::create<int>('c', {2}, {0, 1});
|
|
Nd4jPointer extra[6];
|
|
#ifdef __CUDABLAS__
|
|
extra[1] = x.getContext()->getCudaStream();
|
|
extra[0] = extra[2] = extra[3] = extra[4] = extra[5] = nullptr;
|
|
x.syncToHost();
|
|
printf("Unsupported for CUDA platform yet.\n");
|
|
return;
|
|
#endif
|
|
x.linspace(1.0);
|
|
y.assign(2.);
|
|
x.syncToDevice();
|
|
dimension.syncToHost();
|
|
int* dimensions = reinterpret_cast<int*>(dimension.buffer());
|
|
auto tadPackX = nd4j::ConstantTadHelper::getInstance()->tadForDimensions(x.shapeInfo(), dimensions, dimension.lengthOf());
|
|
auto tadPackY = nd4j::ConstantTadHelper::getInstance()->tadForDimensions(y.shapeInfo(), dimensions, dimension.lengthOf());
|
|
|
|
auto hTADShapeInfoX = tadPackX.primaryShapeInfo();
|
|
auto hTADOffsetsX = tadPackX.primaryOffsets();
|
|
auto hTADShapeInfoY = tadPackY.primaryShapeInfo();
|
|
auto hTADOffsetsY = tadPackY.primaryOffsets();
|
|
|
|
::execReduce3All(extra,
|
|
reduce3::Dot,
|
|
x.buffer(), x.shapeInfo(),
|
|
x.specialBuffer(), x.specialShapeInfo(),
|
|
nullptr,
|
|
y.buffer(), y.shapeInfo(),
|
|
y.specialBuffer(), y.specialShapeInfo(),
|
|
exp.buffer(), exp.shapeInfo(),
|
|
exp.specialBuffer(), exp.specialShapeInfo(),
|
|
dimension.buffer(), dimension.shapeInfo(),
|
|
dimension.specialBuffer(), dimension.specialShapeInfo(),
|
|
hTADShapeInfoX, hTADOffsetsX, hTADShapeInfoY, hTADOffsetsY);
|
|
// x.printIndexedBuffer("Input");
|
|
// exp.printIndexedBuffer("Reduce All");
|
|
ASSERT_TRUE(exp.equalsTo(z));
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, ScalarTest_1) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto y = NDArrayFactory::create<float>(10.);
|
|
auto exp = NDArrayFactory::create<float>('c', {5,5});
|
|
auto z = NDArrayFactory::create<float>('c', {5,5});
|
|
|
|
Nd4jPointer extra[6];
|
|
#ifdef __CUDABLAS__
|
|
extra[1] = x.getContext()->getCudaStream();
|
|
extra[0] = extra[2] = extra[3] = extra[4] = extra[5] = nullptr;
|
|
x.syncToHost();
|
|
y.syncToHost();
|
|
printf("Unsupported for CUDA platform yet.\n");
|
|
return;
|
|
#endif
|
|
x.linspace(1.0);
|
|
z.linspace(10., 10.);
|
|
//y.assign(2.);
|
|
x.syncToDevice();
|
|
z.syncToDevice();
|
|
::execScalar(extra,
|
|
scalar::Multiply,
|
|
x.buffer(), x.shapeInfo(),
|
|
x.specialBuffer(), x.specialShapeInfo(),
|
|
exp.buffer(), exp.shapeInfo(),
|
|
exp.specialBuffer(), exp.specialShapeInfo(),
|
|
y.buffer(), y.shapeInfo(),
|
|
y.specialBuffer(), y.specialShapeInfo(), nullptr);
|
|
// x.printIndexedBuffer("Input");
|
|
// exp.printIndexedBuffer("Reduce All");
|
|
ASSERT_TRUE(exp.equalsTo(z));
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, ScalarTest_2) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto y = NDArrayFactory::create<float>(10.);
|
|
auto exp = NDArrayFactory::create<bool>('c', {5,5});
|
|
auto z = NDArrayFactory::create<bool>('c', {5,5});
|
|
|
|
Nd4jPointer extra[6];
|
|
#ifdef __CUDABLAS__
|
|
extra[1] = x.getContext()->getCudaStream();
|
|
extra[0] = extra[2] = extra[3] = extra[4] = extra[5] = nullptr;
|
|
x.syncToHost();
|
|
y.syncToHost();
|
|
printf("Unsupported for CUDA platform yet.\n");
|
|
return;
|
|
#endif
|
|
x.linspace(1.0);
|
|
z.assign(false);
|
|
//y.assign(2.);
|
|
x.syncToDevice();
|
|
z.syncToDevice();
|
|
::execScalarBool(extra,
|
|
scalar::GreaterThan,
|
|
x.buffer(), x.shapeInfo(),
|
|
x.specialBuffer(), x.specialShapeInfo(),
|
|
exp.buffer(), exp.shapeInfo(),
|
|
exp.specialBuffer(), exp.specialShapeInfo(),
|
|
y.buffer(), y.shapeInfo(),
|
|
y.specialBuffer(), y.specialShapeInfo(), nullptr);
|
|
// x.printIndexedBuffer("Input");
|
|
// exp.printIndexedBuffer("Reduce All");
|
|
ASSERT_TRUE(exp.e<bool>(5) == z.e<bool>(5) && exp.e<bool>(15) != z.e<bool>(15));
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, SummaryStatsScalarTest_1) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5}, {0.1, 0.2, 0.3, -0.3, -0.5, 0.5, 0.7, 0.9, 0.8, 0.1, 0.11, 0.12, 0.5, -0.8, -0.9, 0.4, 0.1, 0.2, 0.3, -0.3, -0.5, 0.2, 0.3, -0.3, -0.5});
|
|
auto exp = NDArrayFactory::create<float>(0.9);
|
|
auto z = NDArrayFactory::create<float>(0.21587136);
|
|
|
|
Nd4jPointer extra[6];
|
|
#ifdef __CUDABLAS__
|
|
extra[1] = x.getContext()->getCudaStream();
|
|
extra[0] = extra[2] = extra[3] = extra[4] = extra[5] = nullptr;
|
|
x.syncToHost();
|
|
printf("Unsupported for CUDA platform yet.\n");
|
|
return;
|
|
#endif
|
|
::execSummaryStatsScalar(extra,
|
|
variance::SummaryStatsVariance,
|
|
x.buffer(), x.shapeInfo(),
|
|
x.specialBuffer(), x.specialShapeInfo(),
|
|
nullptr,
|
|
exp.buffer(), exp.shapeInfo(),
|
|
exp.specialBuffer(), exp.specialShapeInfo(), false);
|
|
// x.printIndexedBuffer("Input");
|
|
// exp.printIndexedBuffer("Standard Variance");
|
|
ASSERT_TRUE(exp.equalsTo(z));
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, SummaryStatsScalarTest_2) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5}, {0.1, 0.2, 0.3, -0.3, -0.5, 0.5, 0.7, 0.9, 0.8, 0.1, 0.11, 0.12, 0.5, -0.8, -0.9, 0.4, 0.1, 0.2, 0.3, -0.3, -0.5, 0.2, 0.3, -0.3, -0.5});
|
|
auto exp = NDArrayFactory::create<float>(0.9);
|
|
auto z = NDArrayFactory::create<float>(0.21587136);
|
|
|
|
Nd4jPointer extra[6];
|
|
#ifdef __CUDABLAS__
|
|
extra[1] = x.getContext()->getCudaStream();
|
|
extra[0] = extra[2] = extra[3] = extra[4] = extra[5] = nullptr;
|
|
x.syncToHost();
|
|
printf("Unsupported for CUDA platform yet.\n");
|
|
return;
|
|
#endif
|
|
::execSummaryStats(extra,
|
|
variance::SummaryStatsVariance,
|
|
x.buffer(), x.shapeInfo(),
|
|
x.specialBuffer(), x.specialShapeInfo(),
|
|
nullptr,
|
|
exp.buffer(), exp.shapeInfo(),
|
|
exp.specialBuffer(), exp.specialShapeInfo(), false);
|
|
// x.printIndexedBuffer("Input");
|
|
// exp.printIndexedBuffer("Standard Variance");
|
|
ASSERT_TRUE(exp.equalsTo(z));
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, SummaryStatsScalarTest_3) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5}, {0.1, 0.2, 0.3, -0.3, -0.5, 0.5, 0.7, 0.9, 0.8, 0.1, 0.11, 0.12, 0.5, -0.8, -0.9, 0.4, 0.1, 0.2, 0.3, -0.3, -0.5, 0.2, 0.3, -0.3, -0.5});
|
|
auto exp = NDArrayFactory::create<float>(0.9);
|
|
auto z = NDArrayFactory::create<float>(0.21587136);
|
|
|
|
Nd4jPointer extra[6];
|
|
#ifdef __CUDABLAS__
|
|
extra[1] = x.getContext()->getCudaStream();
|
|
extra[0] = extra[2] = extra[3] = extra[4] = extra[5] = nullptr;
|
|
x.syncToHost();
|
|
printf("Unsupported for CUDA platform yet.\n");
|
|
return;
|
|
#endif
|
|
auto dimensions = NDArrayFactory::create<int>({0, 1});
|
|
::execSummaryStatsTad(extra,
|
|
variance::SummaryStatsVariance,
|
|
x.buffer(), x.shapeInfo(),
|
|
x.specialBuffer(), x.specialShapeInfo(),
|
|
nullptr,
|
|
exp.buffer(), exp.shapeInfo(),
|
|
exp.specialBuffer(), exp.specialShapeInfo(),
|
|
dimensions.buffer(), dimensions.shapeInfo(),
|
|
dimensions.specialBuffer(), dimensions.specialShapeInfo(),
|
|
false,
|
|
nullptr, nullptr);
|
|
// x.printIndexedBuffer("Input");
|
|
// exp.printIndexedBuffer("Standard Variance");
|
|
ASSERT_TRUE(exp.equalsTo(z));
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, TransformTest_1) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5}, {1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576, 625});
|
|
auto exp = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto z = NDArrayFactory::create<float>('c', {5,5});
|
|
|
|
Nd4jPointer extra[6];
|
|
#ifdef __CUDABLAS__
|
|
extra[1] = x.getContext()->getCudaStream();
|
|
extra[0] = extra[2] = extra[3] = extra[4] = extra[5] = nullptr;
|
|
x.syncToHost();
|
|
printf("Unsupported for CUDA platform yet.\n");
|
|
return;
|
|
#endif
|
|
z.linspace(1.);
|
|
::execTransformFloat(extra,
|
|
transform::Sqrt,
|
|
x.buffer(), x.shapeInfo(),
|
|
x.specialBuffer(), x.specialShapeInfo(),
|
|
|
|
exp.buffer(), exp.shapeInfo(),
|
|
exp.specialBuffer(), exp.specialShapeInfo(),
|
|
nullptr);
|
|
// x.printIndexedBuffer("Input");
|
|
// exp.printIndexedBuffer("Sqrt is");
|
|
ASSERT_TRUE(exp.equalsTo(z));
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, TransformTest_2) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5}, {1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576, 625});
|
|
auto exp = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto z = NDArrayFactory::create<float>('c', {5,5});
|
|
|
|
Nd4jPointer extra[6];
|
|
#ifdef __CUDABLAS__
|
|
extra[1] = x.getContext()->getCudaStream();
|
|
extra[0] = extra[2] = extra[3] = extra[4] = extra[5] = nullptr;
|
|
x.syncToHost();
|
|
printf("Unsupported for CUDA platform yet.\n");
|
|
return;
|
|
#endif
|
|
z.linspace(1.);
|
|
::execTransformSame(extra,
|
|
transform::Square,
|
|
z.buffer(), z.shapeInfo(),
|
|
z.specialBuffer(), z.specialShapeInfo(),
|
|
|
|
exp.buffer(), exp.shapeInfo(),
|
|
exp.specialBuffer(), exp.specialShapeInfo(),
|
|
nullptr);
|
|
// x.printIndexedBuffer("Input");
|
|
// exp.printIndexedBuffer("Square is");
|
|
ASSERT_TRUE(exp.equalsTo(x));
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, TransformTest_3) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto exp = NDArrayFactory::create<bool>('c', {5, 5});
|
|
auto z = NDArrayFactory::create<bool>('c', {5,5});
|
|
|
|
Nd4jPointer extra[6];
|
|
#ifdef __CUDABLAS__
|
|
extra[1] = x.getContext()->getCudaStream();
|
|
extra[0] = extra[2] = extra[3] = extra[4] = extra[5] = nullptr;
|
|
x.syncToHost();
|
|
printf("Unsupported for CUDA platform yet.\n");
|
|
return;
|
|
#endif
|
|
x.linspace(1.);
|
|
z.assign(true);
|
|
x.p(24, -25);
|
|
z.p(24, false);
|
|
::execTransformBool(extra,
|
|
transform::IsPositive,
|
|
x.buffer(), x.shapeInfo(),
|
|
x.specialBuffer(), x.specialShapeInfo(),
|
|
|
|
exp.buffer(), exp.shapeInfo(),
|
|
exp.specialBuffer(), exp.specialShapeInfo(),
|
|
nullptr);
|
|
// x.printIndexedBuffer("Input");
|
|
// exp.printIndexedBuffer("IsPositive");
|
|
ASSERT_TRUE(exp.equalsTo(z));
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, TransformTest_4) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5}, {0, 1, 2, 3, 2, 1, 0, 1.57, 1.57, 1.57, 3.141592, 3.141592,
|
|
3.141592, 0, 0, 0, 0, 1, 1, 2, 2, 2, 1, 0, 0});
|
|
auto exp = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto z = NDArrayFactory::create<float>('c', {5,5}, {1., 0.540302, -0.416147, -0.989992, -0.416147, 0.540302, 1.0,
|
|
0.000796, 0.000796, 0.000796, -1, -1, -1, 1., 1., 1.0, 1.0,
|
|
0.540302, 0.540302, -0.416147, -0.416147, -0.416147, 0.540302, 1., 1.});
|
|
|
|
Nd4jPointer extra[6];
|
|
#ifdef __CUDABLAS__
|
|
extra[1] = x.getContext()->getCudaStream();
|
|
extra[0] = extra[2] = extra[3] = extra[4] = extra[5] = nullptr;
|
|
x.syncToHost();
|
|
printf("Unsupported for CUDA platform yet.\n");
|
|
return;
|
|
#endif
|
|
//z.linspace(1.);
|
|
::execTransformStrict(extra,
|
|
transform::Cosine,
|
|
x.buffer(), x.shapeInfo(),
|
|
x.specialBuffer(), x.specialShapeInfo(),
|
|
|
|
exp.buffer(), exp.shapeInfo(),
|
|
exp.specialBuffer(), exp.specialShapeInfo(),
|
|
nullptr);
|
|
// x.printIndexedBuffer("Input");
|
|
// exp.printIndexedBuffer("Cosine");
|
|
ASSERT_TRUE(exp.equalsTo(z));
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, ScalarTadTest_1) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto y = NDArrayFactory::create<float>(10.);
|
|
auto exp = NDArrayFactory::create<float>('c', {5,5});
|
|
auto z = NDArrayFactory::create<float>('c', {5,5});
|
|
|
|
Nd4jPointer extra[6];
|
|
#ifdef __CUDABLAS__
|
|
extra[1] = x.getContext()->getCudaStream();
|
|
extra[0] = extra[2] = extra[3] = extra[4] = extra[5] = nullptr;
|
|
x.syncToHost();
|
|
y.syncToHost();
|
|
printf("Unsupported for CUDA platform yet.\n");
|
|
return;
|
|
#endif
|
|
x.linspace(1.0);
|
|
z.linspace(10., 10.);
|
|
//y.assign(2.);
|
|
x.syncToDevice();
|
|
z.syncToDevice();
|
|
auto dimension = NDArrayFactory::create<int>({0, 1});
|
|
auto dimensions = reinterpret_cast<int*>(dimension.buffer());
|
|
auto tadPackX = nd4j::ConstantTadHelper::getInstance()->tadForDimensions(x.shapeInfo(), dimensions, dimension.lengthOf());
|
|
auto tadPackZ = nd4j::ConstantTadHelper::getInstance()->tadForDimensions(z.shapeInfo(), dimensions, dimension.lengthOf());
|
|
|
|
::execScalarTad(extra,
|
|
scalar::Multiply,
|
|
x.buffer(), x.shapeInfo(),
|
|
x.specialBuffer(), x.specialShapeInfo(),
|
|
exp.buffer(), exp.shapeInfo(),
|
|
exp.specialBuffer(), exp.specialShapeInfo(),
|
|
y.buffer(), y.shapeInfo(),
|
|
y.specialBuffer(), y.specialShapeInfo(),
|
|
nullptr,
|
|
dimension.buffer(), dimension.shapeInfo(),
|
|
dimension.specialBuffer(), dimension.specialShapeInfo(),
|
|
tadPackX.primaryShapeInfo(), tadPackX.primaryOffsets(), tadPackZ.primaryShapeInfo(), tadPackZ.primaryOffsets());
|
|
// x.printIndexedBuffer("Input");
|
|
// exp.printIndexedBuffer("Reduce All");
|
|
ASSERT_TRUE(exp.equalsTo(z));
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, ScalarTadTest_2) {
|
|
auto x = NDArrayFactory::create<bool>('c', {5, 5});
|
|
auto y = NDArrayFactory::create<bool>(true);
|
|
auto exp = NDArrayFactory::create<bool>('c', {5,5});
|
|
auto z = NDArrayFactory::create<bool>('c', {5, 5});
|
|
|
|
Nd4jPointer extra[6];
|
|
#ifdef __CUDABLAS__
|
|
extra[1] = x.getContext()->getCudaStream();
|
|
extra[0] = extra[2] = extra[3] = extra[4] = extra[5] = nullptr;
|
|
x.syncToHost();
|
|
y.syncToHost();
|
|
printf("Unsupported for CUDA platform yet.\n");
|
|
return;
|
|
#endif
|
|
x.assign(false);
|
|
x.p(5, true);
|
|
x.p(15, true);
|
|
//z.linspace(10., 10.);
|
|
//y.assign(2.);
|
|
x.syncToDevice();
|
|
z.syncToDevice();
|
|
auto dimension = NDArrayFactory::create<int>({0, 1});
|
|
auto dimensions = reinterpret_cast<int*>(dimension.buffer());
|
|
auto tadPackX = nd4j::ConstantTadHelper::getInstance()->tadForDimensions(x.shapeInfo(), dimensions, dimension.lengthOf());
|
|
auto tadPackZ = nd4j::ConstantTadHelper::getInstance()->tadForDimensions(z.shapeInfo(), dimensions, dimension.lengthOf());
|
|
z.assign(true);
|
|
|
|
::execScalarBoolTad(extra,
|
|
scalar::And,
|
|
x.buffer(), x.shapeInfo(),
|
|
x.specialBuffer(), x.specialShapeInfo(),
|
|
exp.buffer(), exp.shapeInfo(),
|
|
exp.specialBuffer(), exp.specialShapeInfo(),
|
|
y.buffer(), y.shapeInfo(),
|
|
y.specialBuffer(), y.specialShapeInfo(),
|
|
nullptr,
|
|
dimension.buffer(), dimension.shapeInfo(),
|
|
dimension.specialBuffer(), dimension.specialShapeInfo(),
|
|
tadPackX.primaryShapeInfo(), tadPackX.primaryOffsets(), tadPackZ.primaryShapeInfo(), tadPackZ.primaryOffsets());
|
|
// x.printIndexedBuffer("Input");
|
|
// exp.printIndexedBuffer("And");
|
|
ASSERT_TRUE(exp.e<bool>(5) == z.e<bool>(5) && exp.e<bool>(15));
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, ConcatTest_2) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto y = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto exp = NDArrayFactory::create<float>('c', {10,5});
|
|
auto z = NDArrayFactory::create<float>('c', {10,5});
|
|
|
|
Nd4jPointer extra[6];
|
|
#ifdef __CUDABLAS__
|
|
extra[1] = x.getContext()->getCudaStream();
|
|
extra[0] = extra[2] = extra[3] = extra[4] = extra[5] = nullptr;
|
|
x.syncToHost();
|
|
y.syncToHost();
|
|
printf("Unsupported for CUDA platform yet.\n");
|
|
return;
|
|
#endif
|
|
x.linspace(1.0);
|
|
y.linspace(26);
|
|
|
|
//y.assign(2.);
|
|
x.syncToDevice();
|
|
z.syncToDevice();
|
|
int d = 0;
|
|
auto dimension = NDArrayFactory::create<int>('c', {1}, {d});
|
|
auto dimensions = reinterpret_cast<int*>(dimension.buffer());
|
|
//auto tadPackX = nd4j::ConstantTadHelper::getInstance()->tadForDimensions(x.shapeInfo(), dimensions, dimension.lengthOf());
|
|
auto tadPackZ = nd4j::ConstantTadHelper::getInstance()->tadForDimensions(z.shapeInfo(), dimensions, dimension.lengthOf());
|
|
exp.linspace(1);
|
|
Nd4jPointer datas[] = {x.buffer(), y.buffer()};
|
|
Nd4jPointer shapes[] = {x.shapeInfo(), y.shapeInfo()};
|
|
|
|
::specialConcat(extra,
|
|
0, 2, datas, shapes, z.buffer(), z.shapeInfo(), nullptr, nullptr);
|
|
|
|
// exp.printIndexedBuffer("Exp");
|
|
// z.printIndexedBuffer("Concat");
|
|
ASSERT_TRUE(exp.equalsTo(z));
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, InitializeTest_1) {
|
|
// ::initializeDevicesAndFunctions();
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, MallocTest_1) {
|
|
auto a = ::mallocHost(16, 0);
|
|
::freeHost(a);
|
|
auto dA = ::mallocDevice(16, 0, 0);
|
|
::freeDevice(dA, 0);
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, OMPTest_1) {
|
|
auto maxThreads = ::ompGetMaxThreads();
|
|
auto numThreads = ::ompGetNumThreads();
|
|
//::setOmpMinThreads(maxThreads);
|
|
//::setOmpNumThreads(numThreads);
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, CreateTest_1) {
|
|
auto xx = ::createContext();
|
|
auto yy = ::createStream();
|
|
auto zz = ::createEvent();
|
|
::destroyEvent(zz);
|
|
if (xx)
|
|
delete (LaunchContext*)xx;
|
|
if (yy)
|
|
printf("Stream should be destoyed before.");
|
|
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, MemTest_1) {
|
|
auto x = NDArrayFactory::create<double>({10, 20, 30, 40, 50});
|
|
auto y = NDArrayFactory::create<double>({20, 20, 20, 20, 20});
|
|
|
|
#ifdef __CUDABLAS__
|
|
return ;
|
|
#endif
|
|
//ASSERT_TRUE(0 == ::memcpy(x.buffer(), y.buffer(), x.lengthOf() * sizeof(double), 0, nullptr));
|
|
ASSERT_TRUE(0 == ::memcpyAsync(x.buffer(), y.buffer(), x.lengthOf() * sizeof(double), 0, nullptr));
|
|
//ASSERT_TRUE(0 == ::memset(x.buffer(), 119, x.lengthOf() * sizeof(double), 0, nullptr));
|
|
ASSERT_TRUE(0 == ::memsetAsync(x.buffer(), 119, x.lengthOf() * sizeof(double), 0, nullptr));
|
|
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, PullRowsTest_1) {
|
|
NDArray x('c', {5, 1}, {0,1,2,3,4});
|
|
NDArray z('c', {4, 1}, nd4j::DataType::DOUBLE);
|
|
NDArray exp('c', {4, 1}, {0,2,3,4});
|
|
|
|
Nd4jLong indexes[] = {0,2,3,4};
|
|
PointersManager pm(LaunchContext::defaultContext(), "NativeOpsTests::pullRows");
|
|
auto pidx = reinterpret_cast<Nd4jLong *>(pm.replicatePointer(indexes, 4 * sizeof(Nd4jLong)));
|
|
|
|
std::vector<int> dims = {1};
|
|
|
|
auto xTadPack = nd4j::ConstantTadHelper::getInstance()->tadForDimensions(x.getShapeInfo(), dims);
|
|
auto zTadPack = nd4j::ConstantTadHelper::getInstance()->tadForDimensions(z.getShapeInfo(), dims);
|
|
|
|
Nd4jPointer nativeStart[2];
|
|
|
|
#ifdef __CUDABLAS__
|
|
nativeStart[1] = (x.getContext()->getCudaStream());
|
|
#endif
|
|
|
|
pullRows(nativeStart, x.buffer(), x.getShapeInfo(), x.getSpecialBuffer(), x.getSpecialShapeInfo(),
|
|
z.buffer(), z.getShapeInfo(), z.specialBuffer(), z.specialShapeInfo(),
|
|
4, pidx,
|
|
xTadPack.platformShapeInfo(), xTadPack.platformOffsets(),
|
|
zTadPack.platformShapeInfo(), zTadPack.platformOffsets());
|
|
|
|
ASSERT_TRUE(z.equalsTo(exp));
|
|
pm.synchronize();
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, TadPackTest_1) {
|
|
int dimension[] = {1};
|
|
int const dimensionLength = 1;
|
|
auto x = NDArrayFactory::create<int>('c', {2,3,4});
|
|
nd4j::TadPack* pack = ::tadOnlyShapeInfo(x.shapeInfo(),
|
|
dimension,
|
|
dimensionLength);
|
|
ASSERT_TRUE(pack != nullptr);
|
|
delete pack;
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, AverageTest_1) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto y = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto exp = NDArrayFactory::create<float>('c', {5,5});
|
|
auto z = NDArrayFactory::create<float>('c', {5,5});
|
|
#ifdef __CUDABLAS__
|
|
return;
|
|
#endif
|
|
x.linspace(1);
|
|
exp.linspace(1);
|
|
Nd4jPointer xList[] = {x.buffer(), x.buffer()};
|
|
Nd4jPointer dxList[] = {x.specialBuffer(), x.specialBuffer()};
|
|
::average(nullptr,
|
|
xList, x.shapeInfo(),
|
|
dxList, x.specialShapeInfo(),
|
|
z.buffer(), z.shapeInfo(),
|
|
z.specialBuffer(), z.specialShapeInfo(),
|
|
2,
|
|
x.lengthOf(),
|
|
true);
|
|
// z.printIndexedBuffer("RES");
|
|
ASSERT_TRUE(z.equalsTo(exp));
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, AccumulateTest_1) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto y = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto exp = NDArrayFactory::create<float>('c', {5,5});
|
|
auto z = NDArrayFactory::create<float>('c', {5,5});
|
|
#ifdef __CUDABLAS__
|
|
return;
|
|
#endif
|
|
x.linspace(1);
|
|
exp.linspace(2,2);
|
|
Nd4jPointer xList[] = {x.buffer(), x.buffer()};
|
|
Nd4jPointer dxList[] = {x.specialBuffer(), x.specialBuffer()};
|
|
::accumulate(nullptr,
|
|
xList, x.shapeInfo(),
|
|
dxList, x.specialShapeInfo(),
|
|
z.buffer(), z.shapeInfo(),
|
|
z.specialBuffer(), z.specialShapeInfo(),
|
|
2,
|
|
x.lengthOf());
|
|
// z.printIndexedBuffer("RES");
|
|
ASSERT_TRUE(z.equalsTo(exp));
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, P2PTest_1) {
|
|
::enableP2P(true);
|
|
::checkP2P();
|
|
::isP2PAvailable();
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, ShuffleTest_1) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto y = NDArrayFactory::create<float>('c', {5, 5});
|
|
auto exp = NDArrayFactory::create<float>('c', {5,5});
|
|
auto z = NDArrayFactory::create<float>('c', {5,5});
|
|
#ifdef __CUDABLAS__
|
|
return;
|
|
#endif
|
|
x.linspace(1);
|
|
y.linspace(34);
|
|
exp.linspace(2,2);
|
|
Nd4jPointer xList[] = {x.buffer(), x.buffer()};
|
|
Nd4jPointer dxList[] = {x.specialBuffer(), y.specialBuffer()};
|
|
Nd4jPointer xShapeList[] = {x.shapeInfo(), y.shapeInfo()};
|
|
Nd4jPointer dxShapeList[] = {x.specialShapeInfo(), y.specialShapeInfo()};
|
|
Nd4jPointer zList[] = {z.buffer(), z.buffer()};
|
|
Nd4jPointer dzList[] = {z.specialBuffer(), z.specialBuffer()};
|
|
Nd4jPointer zShapeList[] = {z.shapeInfo(), z.shapeInfo()};
|
|
Nd4jPointer dzShapeList[] = {z.specialShapeInfo(), z.specialShapeInfo()};
|
|
int shuffleMap[] = {1, 0, 4, 3, 2};
|
|
auto zTadPack = nd4j::ConstantTadHelper::getInstance()->tadForDimensions(x.getShapeInfo(), {1});
|
|
Nd4jPointer zListOffset[] = {zTadPack.platformOffsets(), zTadPack.platformOffsets()};
|
|
Nd4jPointer zListTADs[] = {zTadPack.platformShapeInfo(), zTadPack.platformShapeInfo()};
|
|
::shuffle(nullptr,
|
|
xList, xShapeList,
|
|
dxList, dxShapeList,
|
|
zList, zShapeList,
|
|
dzList, dzShapeList,
|
|
2,
|
|
shuffleMap, zListTADs, zListOffset);
|
|
// z.printIndexedBuffer("RES");
|
|
// x.printIndexedBuffer("INPUT shuffled");
|
|
// y.printIndexedBuffer("INPUT 2 shuffled");
|
|
// ASSERT_TRUE(z.equalsTo(exp));
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, ConvertTypesTest_1) {
|
|
auto x = NDArrayFactory::create<float>('c', {5, 5});
|
|
|
|
auto exp = NDArrayFactory::create<double>('c', {5, 5});
|
|
auto z = NDArrayFactory::create<double>('c', {5, 5});
|
|
|
|
#ifdef __CUDABLAS__
|
|
return;
|
|
#endif
|
|
x.linspace(2, 2);
|
|
exp.linspace(2, 2);
|
|
::convertTypes(nullptr, ND4J_FLOAT32, x.buffer(), x.lengthOf(), ND4J_DOUBLE, z.buffer());
|
|
ASSERT_TRUE(z.equalsTo(exp));
|
|
}
|
|
|
|
//TEST_F(NativeOpsTests, Test_Aggregations_1) {
|
|
// NativeOps ops;
|
|
// auto x = NDArrayFactory::create<float>('c', {5,5});
|
|
// auto y = NDArrayFactory::create<float>('c', {5,5});
|
|
//
|
|
//
|
|
// ops.execAggregate(nullptr, 0, maxArgs, maxShapes, maxIntArrays, maxIntArraySize, maxIndexArguments, maxRealArguments, pointer.data(), nd4j::DataType::FLOAT32);
|
|
// void **arguments,
|
|
// int numArguments,
|
|
// Nd4jLong **shapeArguments,
|
|
// int numShapeArguments,
|
|
// int *indexArguments,
|
|
// int numIndexArguments,
|
|
// int **intArrays,
|
|
// int numIntArrays,
|
|
// void *realArguments,
|
|
// int numRealArguments,
|
|
// nd4j::DataType dtype
|
|
//}
|
|
|
|
TEST_F(NativeOpsTests, RandomTest_1) {
|
|
auto z = NDArrayFactory::create<double>('c', {100});
|
|
Nd4jPointer extra[] = {nullptr, nullptr};
|
|
#ifdef __CUDABLAS__
|
|
return;
|
|
extra[1] = z.getContext()->getCudaStream();
|
|
#endif
|
|
graph::RandomGenerator rng(1023, 119);
|
|
double p = 0.5;
|
|
::execRandom(extra, random::BernoulliDistribution, &rng, z.buffer(), z.shapeInfo(), z.specialBuffer(), z.specialShapeInfo(), &p);
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, RandomTest_2) {
|
|
auto x = NDArrayFactory::create<double>('c', {100});
|
|
auto z = NDArrayFactory::create<double>('c', {100});
|
|
Nd4jPointer extra[] = {nullptr, nullptr};
|
|
#ifdef __CUDABLAS__
|
|
return;
|
|
extra[1] = z.getContext()->getCudaStream();
|
|
#endif
|
|
x.linspace(0, 0.01);
|
|
graph::RandomGenerator rng(1023, 119);
|
|
double p = 0.5;
|
|
::execRandom2(extra, random::DropOut, &rng, x.buffer(), x.shapeInfo(), x.specialBuffer(), x.specialShapeInfo(), z.buffer(), z.shapeInfo(), z.specialBuffer(), z.specialShapeInfo(), &p);
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, RandomTest_3) {
|
|
auto x = NDArrayFactory::create<double>('c', {100});
|
|
auto y = NDArrayFactory::create<double>('c', {100});
|
|
auto z = NDArrayFactory::create<double>('c', {100});
|
|
Nd4jPointer extra[] = {nullptr, nullptr};
|
|
#ifdef __CUDABLAS__
|
|
return;
|
|
extra[1] = z.getContext()->getCudaStream();
|
|
#endif
|
|
x.linspace(0, 0.01);
|
|
x.linspace(1, -0.01);
|
|
graph::RandomGenerator rng(1023, 119);
|
|
double p = 0.5;
|
|
::execRandom3(extra, random::ProbablisticMerge, &rng, x.buffer(), x.shapeInfo(), x.specialBuffer(), x.specialShapeInfo(), y.buffer(), y.shapeInfo(), y.specialBuffer(), y.specialShapeInfo(), z.buffer(), z.shapeInfo(), z.specialBuffer(), z.specialShapeInfo(), &p);
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, RandomTest_4) {
|
|
#ifdef __CUDABLAS__
|
|
return ;
|
|
#endif
|
|
graph::RandomGenerator* rng = (graph::RandomGenerator*)::initRandom(nullptr, 1023, 0, nullptr);
|
|
::refreshBuffer(nullptr, 1203L, rng);
|
|
::reSeedBuffer(nullptr, 3113L, rng);
|
|
::destroyRandom(rng);
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, SortTest_1) {
|
|
#ifdef __CUDABLAS__
|
|
return ;
|
|
#endif
|
|
auto sortedVals = NDArrayFactory::create<int>(
|
|
{10, 1, 5, 120, 34, 5, 78, 138, 3, 111, 331, 29, 91, 71, 73, 50, 56, 4});
|
|
auto exp = NDArrayFactory::create<int>({1, 3, 4, 5, 5, 10, 29, 34, 50, 56, 71, 73, 78, 91, 111, 120, 138, 331});
|
|
|
|
::sort(nullptr, sortedVals.buffer(), sortedVals.shapeInfo(), sortedVals.specialBuffer(),
|
|
sortedVals.specialShapeInfo(), false);
|
|
ASSERT_TRUE(sortedVals.equalsTo(exp));
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, SortTests_2) {
|
|
auto k = NDArrayFactory::create<Nd4jLong>('c', {10}, {1, 3, 5, 9, 0, 2, 4, 6, 7, 8});
|
|
auto v = NDArrayFactory::create<double>('c', {10}, {1.5, 3.5, 5.5, 9.5, 0.5, 2.5, 4.5, 6.5, 7.5, 8.5});
|
|
|
|
auto ek = NDArrayFactory::create<Nd4jLong>('c', {10}, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
|
|
auto ev = NDArrayFactory::create<double>('c', {10}, {0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5});
|
|
Nd4jPointer extras[2];
|
|
#ifdef __CUDABLAS__
|
|
extras[1] = LaunchContext::defaultContext()->getCudaStream();
|
|
#endif
|
|
|
|
::sortByKey(extras, k.buffer(), k.shapeInfo(), k.specialBuffer(), k.specialShapeInfo(), v.buffer(), v.shapeInfo(), v.specialBuffer(), v.specialShapeInfo(), false);
|
|
k.tickWriteDevice();
|
|
v.tickWriteDevice();
|
|
|
|
ASSERT_EQ(ek, k);
|
|
ASSERT_EQ(ev, v);
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, SortTest_3) {
|
|
auto k = NDArrayFactory::create<Nd4jLong>('c', {10}, {1, 3, 5, 9, 0, 2, 4, 6, 7, 8});
|
|
auto v = NDArrayFactory::create<double>('c', {10}, {1.5, 3.5, 5.5, 9.5, 0.5, 2.5, 4.5, 6.5, 7.5, 8.5});
|
|
|
|
auto ek = NDArrayFactory::create<Nd4jLong>('c', {10}, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
|
|
auto ev = NDArrayFactory::create<double>('c', {10}, {0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5});
|
|
|
|
#ifdef __CUDABLAS__
|
|
Nd4jPointer extras[2] = {nullptr, LaunchContext::defaultContext()->getCudaStream()};
|
|
#else
|
|
Nd4jPointer extras[2];
|
|
#endif
|
|
|
|
::sortByKey(extras, k.buffer(), k.shapeInfo(), k.specialBuffer(), k.specialShapeInfo(), v.buffer(), v.shapeInfo(), v.specialBuffer(), v.specialShapeInfo(), false);
|
|
k.tickWriteDevice();
|
|
v.tickWriteDevice();
|
|
|
|
ASSERT_EQ(ek, k);
|
|
ASSERT_EQ(ev, v);
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, SortTest_4) {
|
|
#ifdef __CUDABLAS__
|
|
return ;
|
|
#endif
|
|
auto sortedVals = NDArrayFactory::create<int>('c', {3, 6},
|
|
{ 10, 1, 5, 120, 34, 5,
|
|
78, 138, 3, 111, 331, 29,
|
|
91, 71, 73, 50, 56, 4});
|
|
auto exp = NDArrayFactory::create<int>('c', {3, 6}, {1, 5, 5, 10, 34, 120, 3, 29, 78, 111, 138, 331, 4, 50, 56, 71, 73, 91});
|
|
|
|
std::vector<int> dims({1});
|
|
auto packX = ConstantTadHelper::getInstance()->tadForDimensions(sortedVals.shapeInfo(), {1});
|
|
::sortTad(nullptr, sortedVals.buffer(), sortedVals.shapeInfo(), sortedVals.specialBuffer(),
|
|
sortedVals.specialShapeInfo(), dims.data(), dims.size(), packX.platformShapeInfo(), packX.platformOffsets(), false);
|
|
// sortedVals.printBuffer("OUT");
|
|
// exp.printIndexedBuffer("EXP");
|
|
ASSERT_TRUE(sortedVals.equalsTo(exp));
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, SortTests_5) {
|
|
auto k = NDArrayFactory::create<Nd4jLong>('c', {2, 10}, {1, 3, 5, 9, 0, 2, 4, 6, 7, 8, 1, 3, 5, 9, 0, 2, 4, 6, 7, 8});
|
|
auto v = NDArrayFactory::create<double>('c', {2, 10}, {1.5, 3.5, 5.5, 9.5, 0.5, 2.5, 4.5, 6.5, 7.5, 8.5, 1.5, 3.5, 5.5, 9.5, 0.5, 2.5, 4.5, 6.5, 7.5, 8.5});
|
|
|
|
auto ek = NDArrayFactory::create<Nd4jLong>('c', {2, 10}, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
|
|
auto ev = NDArrayFactory::create<double>('c', {2, 10}, {0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5, 0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5});
|
|
|
|
Nd4jPointer extras[2];
|
|
#ifdef __CUDABLAS__
|
|
extras[1] = LaunchContext::defaultContext()->getCudaStream();
|
|
#endif
|
|
|
|
int axis = 1;
|
|
|
|
::sortTadByKey(extras, k.buffer(), k.shapeInfo(), k.specialBuffer(), k.specialShapeInfo(), v.buffer(), v.shapeInfo(), v.specialBuffer(), v.specialShapeInfo(), &axis, 1, false);
|
|
k.tickWriteDevice();
|
|
v.tickWriteDevice();
|
|
|
|
// k.printIndexedBuffer("k");
|
|
// v.printIndexedBuffer("v");
|
|
|
|
ASSERT_EQ(ek, k);
|
|
ASSERT_EQ(ev, v);
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, SortTests_6) {
|
|
auto k = NDArrayFactory::create<Nd4jLong>('c', {2, 10}, {1, 3, 5, 9, 0, 2, 4, 6, 7, 8, 1, 3, 5, 9, 0, 2, 4, 6, 7, 8});
|
|
auto v = NDArrayFactory::create<double>('c', {2, 10}, {1.5, 3.5, 5.5, 9.5, 0.5, 2.5, 4.5, 6.5, 7.5, 8.5, 1.5, 3.5, 5.5, 9.5, 0.5, 2.5, 4.5, 6.5, 7.5, 8.5});
|
|
|
|
auto ek = NDArrayFactory::create<Nd4jLong>('c', {2, 10}, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
|
|
auto ev = NDArrayFactory::create<double>('c', {2, 10}, {0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5, 0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5});
|
|
|
|
Nd4jPointer extras[2];
|
|
#ifdef __CUDABLAS__
|
|
extras[1] = LaunchContext::defaultContext()->getCudaStream();
|
|
#endif
|
|
|
|
int axis = 1;
|
|
|
|
::sortTadByValue(extras, k.buffer(), k.shapeInfo(), k.specialBuffer(), k.specialShapeInfo(), v.buffer(), v.shapeInfo(), v.specialBuffer(), v.specialShapeInfo(), &axis, 1, false);
|
|
k.tickWriteDevice();
|
|
v.tickWriteDevice();
|
|
|
|
ASSERT_EQ(ek, k);
|
|
ASSERT_EQ(ev, v);
|
|
}
|
|
|
|
//TEST_F(NativeOpsTests, MapTests_1) {
|
|
//#ifdef __CUDABLAS__
|
|
// return ;
|
|
//#endif
|
|
//#ifdef GTEST_OS_LINUX
|
|
// auto ptrMap = ::mmapFile(nullptr, "/tmp/maptest.$$$", 100LL);
|
|
//
|
|
// ::munmapFile(nullptr, ptrMap, 100LL);
|
|
//#endif
|
|
//
|
|
//}
|
|
|
|
TEST_F(NativeOpsTests, MapTests_1) {
|
|
//printf("Custom ops: %s\n", ::getAllCustomOps());
|
|
//printf("All ops: %s\n", ::getAllOperations());
|
|
|
|
::getAllCustomOps();
|
|
::getAllOperations();
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, CustomOpTest_1) {
|
|
auto x = NDArrayFactory::create<float>('c', {1, 6}, {1, 2, 3, 4, 5, 6});
|
|
auto z = NDArrayFactory::create<float>('c', {6});
|
|
auto e = NDArrayFactory::create<float>('c', {6}, {1, 2, 3, 4, 5, 6});
|
|
|
|
nd4j::ops::squeeze op;
|
|
|
|
Nd4jPointer ptrsInBuffer[] = {(Nd4jPointer) x.getBuffer(), x.getSpecialBuffer()};
|
|
Nd4jPointer ptrsInShapes[] = {(Nd4jPointer) x.getShapeInfo(), x.getSpecialShapeInfo()};
|
|
|
|
Nd4jPointer ptrsOutBuffers[] = {(Nd4jPointer) z.getBuffer(), z.getSpecialBuffer()};
|
|
Nd4jPointer ptrsOutShapes[] = {(Nd4jPointer) z.getShapeInfo(), z.getSpecialShapeInfo()};
|
|
|
|
|
|
auto status = ::execCustomOp(nullptr, op.getOpHash(), ptrsInBuffer, ptrsInShapes, 1, ptrsOutBuffers, ptrsOutShapes, 1, nullptr, 0, nullptr, 0, nullptr, 0, false);
|
|
ASSERT_EQ(Status::OK(), status);
|
|
|
|
ASSERT_EQ(e, z);
|
|
}
|
|
TEST_F(NativeOpsTests, CustomOpTests_2) {
|
|
auto array0 = NDArrayFactory::create<float>('c', {3, 2}, {1.f, 2.f, 3.f, 4.f, 5.f, 6.f});
|
|
auto array1 = NDArrayFactory::create<float>('c', {3, 2}, {1.f, 2.f, 3.f, 4.f, 5.f, 6.f});
|
|
auto z = NDArrayFactory::create<float>('c', {3, 2});
|
|
|
|
auto exp = NDArrayFactory::create<float>('c', {3, 2}, {2.f, 4.f, 6.f, 8.f, 10.f, 12.f});
|
|
Context ctx(1);
|
|
|
|
NDArray::prepareSpecialUse({&z}, {&array0, &array1});
|
|
|
|
ctx.setInputArray(0, array0.buffer(), array0.shapeInfo(), array0.getSpecialBuffer(), array0.getSpecialShapeInfo());
|
|
ctx.setInputArray(1, array1.buffer(), array1.shapeInfo(), array1.getSpecialBuffer(), array1.getSpecialShapeInfo());
|
|
ctx.setOutputArray(0, z.buffer(), z.shapeInfo(), z.getSpecialBuffer(), z.getSpecialShapeInfo());
|
|
|
|
ASSERT_EQ(2, ctx.width());
|
|
|
|
nd4j::ops::add op;
|
|
::execCustomOp2(nullptr, op.getOpHash(), &ctx);
|
|
|
|
NDArray::registerSpecialUse({&z}, {&array0, &array1});
|
|
|
|
ASSERT_EQ(exp, z);
|
|
}
|
|
TEST_F(NativeOpsTests, CalculateOutputShapeTests_1) {
|
|
auto input = NDArrayFactory::create<float>('c', {1, 2, 5, 4});
|
|
auto weights = NDArrayFactory::create<float>('c', {2, 2, 2, 3});
|
|
auto exp = NDArrayFactory::create<float>('c', {1, 3, 5, 4});
|
|
|
|
nd4j::ops::conv2d op;
|
|
|
|
std::vector<double> tArgs({});
|
|
std::vector<Nd4jLong> iArgs({2, 2, 1, 1, 0, 0, 1, 1, 1});
|
|
|
|
Nd4jPointer ptrs[] = {(Nd4jPointer) input.getShapeInfo(), (Nd4jPointer) weights.getShapeInfo()};
|
|
#ifdef __CUDABLAS__
|
|
return;
|
|
#endif
|
|
|
|
auto shapeList = ::calculateOutputShapes(nullptr, op.getOpHash(), ptrs, 2, tArgs.data(), tArgs.size(), iArgs.data(), iArgs.size());
|
|
|
|
ASSERT_EQ(1, shapeList->size());
|
|
|
|
ASSERT_EQ(exp.rankOf(), shape::rank((Nd4jLong *)shapeList->at(0)));
|
|
ASSERT_EQ(exp.sizeAt(0), shape::shapeOf((Nd4jLong *)shapeList->at(0))[0]);
|
|
ASSERT_EQ(exp.sizeAt(1), shape::shapeOf((Nd4jLong *)shapeList->at(0))[1]);
|
|
ASSERT_EQ(exp.sizeAt(2), shape::shapeOf((Nd4jLong *)shapeList->at(0))[2]);
|
|
ASSERT_EQ(exp.sizeAt(3), shape::shapeOf((Nd4jLong *)shapeList->at(0))[3]);
|
|
|
|
//int *ptr = (int *) shapeList[0];
|
|
//delete[] ptr;
|
|
//delete shapeList;
|
|
|
|
::deleteShapeList((Nd4jPointer) shapeList);
|
|
}
|
|
|
|
TEST_F(NativeOpsTests, CalculateOutputShapeTests_2) {
|
|
auto input = NDArrayFactory::create<float>('c', {1, 2, 5, 4});
|
|
auto weights = NDArrayFactory::create<float>('c', {2, 2, 2, 3});
|
|
auto exp = NDArrayFactory::create<float>('c', {1, 3, 5, 4});
|
|
|
|
nd4j::ops::conv2d op;
|
|
|
|
std::vector<double> tArgs({});
|
|
std::vector<bool> bArgsF({});
|
|
std::vector<Nd4jLong> iArgs({2, 2, 1, 1, 0, 0, 1, 1, 1});
|
|
|
|
Nd4jPointer shapePtrs[] = {(Nd4jPointer) input.getShapeInfo(), (Nd4jPointer) weights.getShapeInfo()};
|
|
Nd4jPointer dataPtrs[] = {(Nd4jPointer)input.buffer(), (Nd4jPointer)weights.buffer()};
|
|
#ifdef __CUDABLAS__
|
|
return;
|
|
#endif
|
|
|
|
auto shapeList = ::calculateOutputShapes2(nullptr, op.getOpHash(), dataPtrs, shapePtrs, 2, const_cast<double*>(tArgs.data()), tArgs.size(),
|
|
const_cast<Nd4jLong*>(iArgs.data()), iArgs.size(), nullptr, bArgsF.size());
|
|
// Nd4jPointer* extraPointers, Nd4jLong hash, Nd4jPointer* inputBuffers, Nd4jPointer* inputShapes, int numInputShapes, double* tArgs, int numTArgs, Nd4jLong *iArgs, int numIArgs, bool *bArgs, int numBArgs
|
|
ASSERT_EQ(1, shapeList->size());
|
|
|
|
ASSERT_EQ(exp.rankOf(), shape::rank((Nd4jLong *)shapeList->at(0)));
|
|
ASSERT_EQ(exp.sizeAt(0), shape::shapeOf((Nd4jLong *)shapeList->at(0))[0]);
|
|
ASSERT_EQ(exp.sizeAt(1), shape::shapeOf((Nd4jLong *)shapeList->at(0))[1]);
|
|
ASSERT_EQ(exp.sizeAt(2), shape::shapeOf((Nd4jLong *)shapeList->at(0))[2]);
|
|
ASSERT_EQ(exp.sizeAt(3), shape::shapeOf((Nd4jLong *)shapeList->at(0))[3]);
|
|
|
|
//int *ptr = (int *) shapeList[0];
|
|
//delete[] ptr;
|
|
//delete shapeList;
|
|
|
|
::deleteShapeList((Nd4jPointer) shapeList);
|
|
}
|
|
|
|
//Uncomment when needed only - massive calculations
|
|
//TEST_F(NativeOpsTests, BenchmarkTests_1) {
|
|
//
|
|
// printf("%s\n", ::runLightBenchmarkSuit(true));
|
|
// printf("%s\n", ::runFullBenchmarkSuit(true));
|
|
//}
|