2019-06-06 14:21:15 +02:00
|
|
|
/*******************************************************************************
|
|
|
|
|
* 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
|
|
|
|
|
******************************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#include <vector>
|
2020-03-02 10:49:41 +01:00
|
|
|
#include <system/pointercast.h>
|
|
|
|
|
#include "legacy/NativeOpExecutioner.h"
|
2019-06-06 14:21:15 +02:00
|
|
|
#include <types/types.h>
|
|
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
#include <helpers/LoopKind.h>
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
#include <loops/pairwise_bool.h>
|
|
|
|
|
#include <loops/broadcasting_bool.h>
|
|
|
|
|
#include <loops/scalar_bool.h>
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
#include <loops/pairwise_int.h>
|
|
|
|
|
#include <loops/broadcasting_int.h>
|
|
|
|
|
#include <loops/scalar_int.h>
|
2019-08-30 09:12:40 +02:00
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
#include <loops/transform_float.h>
|
|
|
|
|
#include <loops/transform_bool.h>
|
|
|
|
|
#include <loops/transform_any.h>
|
|
|
|
|
#include <loops/transform_same.h>
|
|
|
|
|
#include <loops/transform_strict.h>
|
|
|
|
|
|
|
|
|
|
#include <loops/reduce_float.h>
|
|
|
|
|
#include <loops/reduce_same.h>
|
|
|
|
|
#include <loops/reduce_bool.h>
|
|
|
|
|
#include <loops/reduce_long.h>
|
|
|
|
|
|
|
|
|
|
#include <loops/broadcasting.h>
|
|
|
|
|
#include <loops/indexreduce.h>
|
|
|
|
|
#include <loops/pairwise_transform.h>
|
|
|
|
|
#include <loops/reduce_float.h>
|
|
|
|
|
#include <loops/reduce3.h>
|
|
|
|
|
#include <loops/summarystatsreduce.h>
|
|
|
|
|
#include <loops/transform_same.h>
|
|
|
|
|
#include <loops/scalar.h>
|
|
|
|
|
#include <loops/random.h>
|
2020-03-02 10:49:41 +01:00
|
|
|
#include <system/pointercast.h>
|
2019-06-06 14:21:15 +02:00
|
|
|
#include <exceptions/datatype_exception.h>
|
2019-11-13 15:15:18 +01:00
|
|
|
#include <array/TadPack.h>
|
|
|
|
|
#include <helpers/ConstantTadHelper.h>
|
2019-06-06 14:21:15 +02:00
|
|
|
|
|
|
|
|
|
2019-08-02 19:01:03 +02:00
|
|
|
#ifdef _OPENMP
|
|
|
|
|
|
|
|
|
|
#include <omp.h>
|
2019-11-13 15:15:18 +01:00
|
|
|
#include <helpers/ConstantTadHelper.h>
|
2019-08-02 19:01:03 +02:00
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
|
/**
|
|
|
|
|
*
|
|
|
|
|
* @param opNum
|
|
|
|
|
* @param hX
|
|
|
|
|
* @param hXShapeInfo
|
|
|
|
|
* @param extraParams
|
|
|
|
|
* @param hZ
|
|
|
|
|
* @param hZShapeInfo
|
|
|
|
|
*/
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execIndexReduceScalar(sd::LaunchContext *lc, int opNum,
|
2019-06-06 14:21:15 +02:00
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *extraParams,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo) {
|
|
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-08-02 19:01:03 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
auto hz = reinterpret_cast<Nd4jLong*>(hZ);
|
|
|
|
|
|
2019-08-27 09:37:10 +02:00
|
|
|
BUILD_DOUBLE_SELECTOR(xType, zType, hz[0] = functions::indexreduce::IndexReduce, ::execScalar(opNum,hX,hXShapeInfo,extraParams), LIBND4J_TYPES, INDEXING_TYPES);
|
2019-06-06 14:21:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
|
/**
|
|
|
|
|
*
|
|
|
|
|
* @param opNum
|
|
|
|
|
* @param hX
|
|
|
|
|
* @param hXShapeInfo
|
|
|
|
|
* @param extraParams
|
|
|
|
|
* @param hZ
|
|
|
|
|
* @param hZShapeInfo
|
|
|
|
|
* @param dimension
|
|
|
|
|
* @param dimensionLength
|
|
|
|
|
*/
|
|
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execIndexReduce(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *extraParams,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
int *dimension, int dimensionLength,
|
|
|
|
|
Nd4jLong *tadShapeInfo, Nd4jLong *tadOffsets) {
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
Nd4jLong* hz = reinterpret_cast<Nd4jLong*>(hZ);
|
|
|
|
|
|
2019-08-27 09:37:10 +02:00
|
|
|
BUILD_DOUBLE_SELECTOR(xType, zType, functions::indexreduce::IndexReduce, ::exec(opNum, hX, hXShapeInfo, extraParams, hz, hZShapeInfo, dimension, dimensionLength, tadShapeInfo, tadOffsets), LIBND4J_TYPES, INDEXING_TYPES);
|
2019-06-06 14:21:15 +02:00
|
|
|
// BUILD_SINGLE_SELECTOR(xType, functions::indexreduce::IndexReduce, ::exec(opNum, hX, hXShapeInfo, dX, dXShapeInfo, extraParams, hZ, hZShapeInfo, dZ, dZShapeInfo, dimension, dimensionLength, tadShapeInfo, tadOffsets), LIBND4J_TYPES);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
|
/**
|
|
|
|
|
*
|
|
|
|
|
* @param opNum
|
|
|
|
|
* @param hX
|
|
|
|
|
* @param hXShapeInfo
|
|
|
|
|
* @param hY
|
|
|
|
|
* @param hYShapeInfo
|
|
|
|
|
* @param hZ
|
|
|
|
|
* @param hZShapeInfo
|
|
|
|
|
* @param dimension
|
|
|
|
|
* @param dimensionLength
|
|
|
|
|
*/
|
|
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execBroadcast(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *hY, Nd4jLong *hYShapeInfo,
|
|
|
|
|
void *dY, Nd4jLong *dYShapeInfo,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
int *dimension, int dimensionLength,
|
|
|
|
|
Nd4jLong *tadOnlyShapeInfo, Nd4jLong *tadOffsets,
|
|
|
|
|
Nd4jLong *tadOnlyShapeInfoZ,Nd4jLong *tadOffsetsZ) {
|
|
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-08-02 19:01:03 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto yType = sd::ArrayOptions::dataType(hYShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2019-11-21 13:43:03 +01:00
|
|
|
if (shape::isEmpty(hXShapeInfo) || shape::isEmpty(hYShapeInfo))
|
|
|
|
|
return;
|
|
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
#ifdef __ND4J_EXPERIMENTAL__
|
|
|
|
|
BUILD_PAIRWISE_SELECTOR(xType, yType, zType, functions::broadcast::Broadcast, ::exec(opNum, hX, hXShapeInfo, hY, hYShapeInfo, hZ, hZShapeInfo, dimension, dimensionLength, tadOnlyShapeInfo, tadOffsets, tadOnlyShapeInfoZ, tadOffsetsZ), LIBND4J_TYPES, LIBND4J_TYPES);
|
|
|
|
|
#else
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto loopKind = sd::LoopKind::deduceKindOfLoopBroadcast(hXShapeInfo, hYShapeInfo, hZShapeInfo);
|
2020-02-17 14:25:10 +01:00
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
auto func = PRAGMA_THREADS_FOR {
|
2020-02-17 14:25:10 +01:00
|
|
|
BUILD_SINGLE_SELECTOR_THRICE(xType, functions::broadcast::Broadcast, ::exec(opNum, hX, hXShapeInfo, hY, hYShapeInfo, hZ, hZShapeInfo, dimension, dimensionLength, tadOnlyShapeInfo, tadOffsets, tadOnlyShapeInfoZ, tadOffsetsZ, loopKind, start, stop), LIBND4J_TYPES);
|
2019-11-13 15:15:18 +01:00
|
|
|
};
|
|
|
|
|
|
2020-02-17 14:25:10 +01:00
|
|
|
Nd4jLong numTads = 0;
|
|
|
|
|
|
|
|
|
|
switch (loopKind) {
|
2020-03-02 10:49:41 +01:00
|
|
|
case sd::LoopKind::BROADCAST_SCALAR_X: {
|
2020-02-17 14:25:10 +01:00
|
|
|
numTads = shape::length(hXShapeInfo);
|
|
|
|
|
}
|
|
|
|
|
break;
|
2020-03-02 10:49:41 +01:00
|
|
|
case sd::LoopKind::BROADCAST_SCALAR_Y: {
|
2020-02-17 14:25:10 +01:00
|
|
|
numTads = shape::length(hYShapeInfo);
|
|
|
|
|
}
|
|
|
|
|
break;
|
2020-03-02 10:49:41 +01:00
|
|
|
case sd::LoopKind::BROADCAST_3D: {
|
Oleh broadcast4d (#257)
* libnd4j raw implementation of native broadcast for special cases
Signed-off-by: Oleg <oleg.semeniv@gmail.com>
* libnd4j fixed bugs for special case of 4D loop broadcast, add some tests, need more testing and discussion
Signed-off-by: Oleg <oleg.semeniv@gmail.com>
* libnd4j added 3D and 5D cases support and tests, need testing with different orders
Signed-off-by: Oleg <oleg.semeniv@gmail.com>
* libnd4j correctd case selection for broadcast 3,4,5D loops, fixed several places for more stable behavior, clean up
Signed-off-by: Oleg <oleg.semeniv@gmail.com>
* libnd4j minor corrections to avoid some risks in strides selection, added tests and rename some variables
Signed-off-by: Oleg <oleg.semeniv@gmail.com>
* libnd4j optimize usage the stride selection for all loops in separate ShapeUtils method copyCertainStridesFromShapeInfo, merge master
Signed-off-by: Oleg <oleg.semeniv@gmail.com>
* libnd4j remove per request several tests for 3D, 4D and 5D broadcast loops
Signed-off-by: Oleg <oleg.semeniv@gmail.com>
* libnd4j removed some loac changes that had not been sync with serve playground, turn on new loops usage
2020-02-21 05:46:05 +01:00
|
|
|
numTads = shape::sizeAt(hZShapeInfo, 0);
|
|
|
|
|
}
|
|
|
|
|
break;
|
2020-03-02 10:49:41 +01:00
|
|
|
case sd::LoopKind::BROADCAST_4D: {
|
Oleh broadcast4d (#257)
* libnd4j raw implementation of native broadcast for special cases
Signed-off-by: Oleg <oleg.semeniv@gmail.com>
* libnd4j fixed bugs for special case of 4D loop broadcast, add some tests, need more testing and discussion
Signed-off-by: Oleg <oleg.semeniv@gmail.com>
* libnd4j added 3D and 5D cases support and tests, need testing with different orders
Signed-off-by: Oleg <oleg.semeniv@gmail.com>
* libnd4j correctd case selection for broadcast 3,4,5D loops, fixed several places for more stable behavior, clean up
Signed-off-by: Oleg <oleg.semeniv@gmail.com>
* libnd4j minor corrections to avoid some risks in strides selection, added tests and rename some variables
Signed-off-by: Oleg <oleg.semeniv@gmail.com>
* libnd4j optimize usage the stride selection for all loops in separate ShapeUtils method copyCertainStridesFromShapeInfo, merge master
Signed-off-by: Oleg <oleg.semeniv@gmail.com>
* libnd4j remove per request several tests for 3D, 4D and 5D broadcast loops
Signed-off-by: Oleg <oleg.semeniv@gmail.com>
* libnd4j removed some loac changes that had not been sync with serve playground, turn on new loops usage
2020-02-21 05:46:05 +01:00
|
|
|
numTads = shape::sizeAt(hZShapeInfo, 0) * shape::sizeAt(hZShapeInfo, 1);
|
|
|
|
|
}
|
|
|
|
|
break;
|
2020-03-02 10:49:41 +01:00
|
|
|
case sd::LoopKind::BROADCAST_5D: {
|
Oleh broadcast4d (#257)
* libnd4j raw implementation of native broadcast for special cases
Signed-off-by: Oleg <oleg.semeniv@gmail.com>
* libnd4j fixed bugs for special case of 4D loop broadcast, add some tests, need more testing and discussion
Signed-off-by: Oleg <oleg.semeniv@gmail.com>
* libnd4j added 3D and 5D cases support and tests, need testing with different orders
Signed-off-by: Oleg <oleg.semeniv@gmail.com>
* libnd4j correctd case selection for broadcast 3,4,5D loops, fixed several places for more stable behavior, clean up
Signed-off-by: Oleg <oleg.semeniv@gmail.com>
* libnd4j minor corrections to avoid some risks in strides selection, added tests and rename some variables
Signed-off-by: Oleg <oleg.semeniv@gmail.com>
* libnd4j optimize usage the stride selection for all loops in separate ShapeUtils method copyCertainStridesFromShapeInfo, merge master
Signed-off-by: Oleg <oleg.semeniv@gmail.com>
* libnd4j remove per request several tests for 3D, 4D and 5D broadcast loops
Signed-off-by: Oleg <oleg.semeniv@gmail.com>
* libnd4j removed some loac changes that had not been sync with serve playground, turn on new loops usage
2020-02-21 05:46:05 +01:00
|
|
|
numTads = shape::sizeAt(hZShapeInfo, 0) * shape::sizeAt(hZShapeInfo, 1);
|
|
|
|
|
}
|
|
|
|
|
break;
|
2020-02-17 14:25:10 +01:00
|
|
|
default: {
|
|
|
|
|
auto xLen = shape::length(hXShapeInfo);
|
|
|
|
|
auto yLen = shape::length(hYShapeInfo);
|
|
|
|
|
numTads = xLen / yLen;
|
|
|
|
|
}
|
|
|
|
|
}
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2020-03-09 06:22:49 +01:00
|
|
|
samediff::Threads::parallel_tad(func, 0, numTads);
|
2020-02-17 14:25:10 +01:00
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execInverseBroadcast(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *hY, Nd4jLong *hYShapeInfo,
|
|
|
|
|
void *dY, Nd4jLong *dYShapeInfo,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
int *dimension, int dimensionLength,
|
|
|
|
|
Nd4jLong *tadOnlyShapeInfo, Nd4jLong *tadOffsets,
|
|
|
|
|
Nd4jLong *tadOnlyShapeInfoZ,Nd4jLong *tadOffsetsZ) {
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto yType = sd::ArrayOptions::dataType(hYShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2019-11-21 13:43:03 +01:00
|
|
|
if (shape::isEmpty(hXShapeInfo) || shape::isEmpty(hYShapeInfo))
|
|
|
|
|
return;
|
2019-08-02 19:01:03 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
if (!sd::Environment::getInstance()->isExperimentalBuild())
|
|
|
|
|
if ((yType != xType && yType != sd::DataType::BOOL) || xType != zType)
|
|
|
|
|
throw sd::datatype_exception::build("NativeOps::execBroadcast both operands must have same data type", xType, yType);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
|
|
|
|
#ifdef __ND4J_EXPERIMENTAL__
|
|
|
|
|
BUILD_PAIRWISE_SELECTOR(xType, yType, zType, functions::broadcast::Broadcast, ::execInverse(opNum, hX, hXShapeInfo, hY, hYShapeInfo, hZ, hZShapeInfo, dimension, dimensionLength, tadOnlyShapeInfo, tadOffsets, tadOnlyShapeInfoZ, tadOffsetsZ), LIBND4J_TYPES, LIBND4J_TYPES);
|
|
|
|
|
#else
|
2019-11-13 15:15:18 +01:00
|
|
|
auto func = PRAGMA_THREADS_FOR {
|
|
|
|
|
BUILD_SINGLE_SELECTOR_THRICE(xType, functions::broadcast::Broadcast, ::execInverse(opNum, hX, hXShapeInfo, hY, hYShapeInfo, hZ, hZShapeInfo, dimension, dimensionLength, tadOnlyShapeInfo, tadOffsets, tadOnlyShapeInfoZ, tadOffsetsZ, start, stop), LIBND4J_TYPES);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
auto xLen = shape::length(hXShapeInfo);
|
|
|
|
|
auto yLen = shape::length(hYShapeInfo);
|
|
|
|
|
auto numTads = yLen / xLen;
|
|
|
|
|
|
2020-03-09 06:22:49 +01:00
|
|
|
samediff::Threads::parallel_tad(func, 0, numTads);
|
2019-06-06 14:21:15 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execBroadcastBool(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *hY, Nd4jLong *hYShapeInfo,
|
|
|
|
|
void *dY, Nd4jLong *dYShapeInfo,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
2019-11-21 13:43:03 +01:00
|
|
|
void *extraParams,
|
2019-06-06 14:21:15 +02:00
|
|
|
int *dimension, int dimensionLength,
|
|
|
|
|
Nd4jLong *tadOnlyShapeInfo, Nd4jLong *tadOffsets,
|
|
|
|
|
Nd4jLong *tadOnlyShapeInfoZ,Nd4jLong *tadOffsetsZ) {
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto yType = sd::ArrayOptions::dataType(hYShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2019-11-21 13:43:03 +01:00
|
|
|
if (shape::isEmpty(hXShapeInfo) || shape::isEmpty(hYShapeInfo))
|
|
|
|
|
return;
|
|
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
auto func = PRAGMA_THREADS_FOR {
|
2019-11-21 13:43:03 +01:00
|
|
|
BUILD_DOUBLE_SELECTOR(xType, zType, functions::broadcast::BroadcastBool, ::exec(opNum, hX, hXShapeInfo, hY, hYShapeInfo, hZ, hZShapeInfo, extraParams, dimension, dimensionLength, tadOnlyShapeInfo, tadOffsets, tadOnlyShapeInfoZ, tadOffsetsZ, start, stop), LIBND4J_TYPES, BOOL_TYPES);
|
2019-11-13 15:15:18 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
auto xLen = shape::length(hXShapeInfo);
|
|
|
|
|
auto yLen = shape::length(hYShapeInfo);
|
|
|
|
|
auto numTads = xLen / yLen;
|
|
|
|
|
|
2020-03-09 06:22:49 +01:00
|
|
|
samediff::Threads::parallel_tad(func, 0, numTads);
|
2019-06-06 14:21:15 +02:00
|
|
|
}
|
|
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execInverseBroadcastBool(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *hY, Nd4jLong *hYShapeInfo,
|
|
|
|
|
void *dY, Nd4jLong *dYShapeInfo,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
2019-11-21 13:43:03 +01:00
|
|
|
void *extraParams,
|
2019-06-06 14:21:15 +02:00
|
|
|
int *dimension, int dimensionLength,
|
|
|
|
|
Nd4jLong *tadOnlyShapeInfo, Nd4jLong *tadOffsets,
|
|
|
|
|
Nd4jLong *tadOnlyShapeInfoZ,Nd4jLong *tadOffsetsZ) {
|
2019-08-02 19:01:03 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto yType = sd::ArrayOptions::dataType(hYShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2019-11-21 13:43:03 +01:00
|
|
|
if (shape::isEmpty(hXShapeInfo) || shape::isEmpty(hYShapeInfo))
|
|
|
|
|
return;
|
|
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
if (!sd::Environment::getInstance()->isExperimentalBuild())
|
|
|
|
|
if (yType != xType || sd::DataType::BOOL != zType)
|
|
|
|
|
throw sd::datatype_exception::build("NativeOps::execInverseBroadcastBool both operands must have same data type", xType, yType);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
auto func = PRAGMA_THREADS_FOR {
|
2019-11-21 13:43:03 +01:00
|
|
|
BUILD_DOUBLE_SELECTOR(xType, zType, functions::broadcast::BroadcastBool, ::execInverse(opNum, hX, hXShapeInfo, hY, hYShapeInfo, hZ, hZShapeInfo, extraParams, dimension, dimensionLength, tadOnlyShapeInfo, tadOffsets, tadOnlyShapeInfoZ, tadOffsetsZ, start, stop), LIBND4J_TYPES, BOOL_TYPES);
|
2019-11-13 15:15:18 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
auto xLen = shape::length(hXShapeInfo);
|
|
|
|
|
auto yLen = shape::length(hYShapeInfo);
|
|
|
|
|
auto numTads = yLen / xLen;
|
|
|
|
|
|
2020-03-09 06:22:49 +01:00
|
|
|
samediff::Threads::parallel_tad(func, 0, numTads);
|
2019-06-06 14:21:15 +02:00
|
|
|
}
|
|
|
|
|
|
2019-08-30 09:12:40 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execBroadcastInt(sd::LaunchContext *lc,
|
2019-08-30 09:12:40 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *hY, Nd4jLong *hYShapeInfo,
|
|
|
|
|
void *dY, Nd4jLong *dYShapeInfo,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
int *dimension, int dimensionLength,
|
|
|
|
|
Nd4jLong *tadOnlyShapeInfo, Nd4jLong *tadOffsets,
|
|
|
|
|
Nd4jLong *tadOnlyShapeInfoZ,Nd4jLong *tadOffsetsZ) {
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-08-30 09:12:40 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto yType = sd::ArrayOptions::dataType(hYShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-08-30 09:12:40 +02:00
|
|
|
|
2019-11-21 13:43:03 +01:00
|
|
|
if (shape::isEmpty(hXShapeInfo) || shape::isEmpty(hYShapeInfo))
|
|
|
|
|
return;
|
|
|
|
|
|
2019-08-30 09:12:40 +02:00
|
|
|
if (xType != yType || xType != zType)
|
2020-03-02 10:49:41 +01:00
|
|
|
throw sd::datatype_exception::build("NativeOpExecutioner::execBroadcastInt", zType, xType, yType);
|
2019-08-30 09:12:40 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
if (!sd::DataTypeUtils::isZ(zType))
|
|
|
|
|
throw sd::datatype_exception::build("NativeOpExecutioner::execBroadcastInt requires integer data type", zType);
|
2019-08-30 09:12:40 +02:00
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
auto func = PRAGMA_THREADS_FOR {
|
|
|
|
|
BUILD_SINGLE_SELECTOR(xType, functions::broadcast::BroadcastInt, ::exec(opNum, hX, hXShapeInfo, hY, hYShapeInfo, hZ, hZShapeInfo, dimension, dimensionLength, tadOnlyShapeInfo, tadOffsets, tadOnlyShapeInfoZ, tadOffsetsZ, start, stop), INTEGER_TYPES);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
auto xLen = shape::length(hXShapeInfo);
|
|
|
|
|
auto yLen = shape::length(hYShapeInfo);
|
|
|
|
|
auto numTads = xLen / yLen;
|
|
|
|
|
|
2020-03-09 06:22:49 +01:00
|
|
|
samediff::Threads::parallel_tad(func, 0, numTads);
|
2019-08-30 09:12:40 +02:00
|
|
|
}
|
|
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execInverseBroadcastInt(sd::LaunchContext *lc,
|
2019-08-30 09:12:40 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *hY, Nd4jLong *hYShapeInfo,
|
|
|
|
|
void *dY, Nd4jLong *dYShapeInfo,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
int *dimension, int dimensionLength,
|
|
|
|
|
Nd4jLong *tadOnlyShapeInfo, Nd4jLong *tadOffsets,
|
|
|
|
|
Nd4jLong *tadOnlyShapeInfoZ,Nd4jLong *tadOffsetsZ) {
|
|
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto yType = sd::ArrayOptions::dataType(hYShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-08-30 09:12:40 +02:00
|
|
|
|
2019-11-21 13:43:03 +01:00
|
|
|
if (shape::isEmpty(hXShapeInfo) || shape::isEmpty(hYShapeInfo))
|
|
|
|
|
return;
|
|
|
|
|
|
2019-08-30 09:12:40 +02:00
|
|
|
if (xType != yType || xType != zType)
|
2020-03-02 10:49:41 +01:00
|
|
|
throw sd::datatype_exception::build("NativeOpExecutioner::execInverseBroadcastInt", zType, xType, yType);
|
2019-08-30 09:12:40 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
if (!sd::DataTypeUtils::isZ(zType))
|
|
|
|
|
throw sd::datatype_exception::build("NativeOpExecutioner::execInverseBroadcastInt requires integer data type", zType);
|
2019-08-30 09:12:40 +02:00
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
auto func = PRAGMA_THREADS_FOR {
|
|
|
|
|
BUILD_SINGLE_SELECTOR(xType, functions::broadcast::BroadcastInt,::execInverse(opNum, hX, hXShapeInfo, hY, hYShapeInfo, hZ, hZShapeInfo, dimension, dimensionLength, tadOnlyShapeInfo, tadOffsets, tadOnlyShapeInfoZ, tadOffsetsZ, start, stop), INTEGER_TYPES);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
auto xLen = shape::length(hXShapeInfo);
|
|
|
|
|
auto yLen = shape::length(hYShapeInfo);
|
|
|
|
|
auto numTads = yLen / xLen;
|
|
|
|
|
|
2020-03-09 06:22:49 +01:00
|
|
|
samediff::Threads::parallel_tad(func, 0, numTads);
|
2019-08-30 09:12:40 +02:00
|
|
|
}
|
|
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
|
/**
|
|
|
|
|
*
|
|
|
|
|
* @param opNum
|
|
|
|
|
* @param hX
|
|
|
|
|
* @param xStride
|
|
|
|
|
* @param hY
|
|
|
|
|
* @param yStride
|
|
|
|
|
* @param hZ
|
|
|
|
|
* @param resultStride
|
|
|
|
|
* @param extraParams
|
|
|
|
|
* @param n
|
|
|
|
|
*/
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execPairwiseTransform(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *hY, Nd4jLong *hYShapeInfo,
|
|
|
|
|
void *dY, Nd4jLong *dYShapeInfo,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
void *extraParams) {
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto yType = sd::ArrayOptions::dataType(hYShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2019-11-21 13:43:03 +01:00
|
|
|
if (shape::isEmpty(hXShapeInfo) || shape::isEmpty(hYShapeInfo))
|
|
|
|
|
return;
|
|
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
#ifdef __ND4J_EXPERIMENTAL__
|
|
|
|
|
BUILD_PAIRWISE_SELECTOR(xType, yType, zType, functions::pairwise_transforms::PairWiseTransform, ::exec(opNum, hX, hXShapeInfo, hY, hYShapeInfo, hZ, hZShapeInfo, extraParams), LIBND4J_TYPES, LIBND4J_TYPES);
|
|
|
|
|
#else
|
2019-11-13 15:15:18 +01:00
|
|
|
auto func = PRAGMA_THREADS_FOR {
|
|
|
|
|
BUILD_SINGLE_SELECTOR_THRICE(xType, functions::pairwise_transforms::PairWiseTransform,
|
|
|
|
|
::exec(opNum, hX, hXShapeInfo, hY, hYShapeInfo, hZ, hZShapeInfo, extraParams, start, stop),
|
|
|
|
|
LIBND4J_TYPES);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
auto zLen = shape::length(hZShapeInfo);
|
2020-03-09 06:22:49 +01:00
|
|
|
samediff::Threads::parallel_for(func, 0, zLen, 1, sd::math::nd4j_max<int>(1, sd::math::nd4j_min<int>(zLen / 1024, sd::Environment::getInstance()->maxMasterThreads())));
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execPairwiseBoolTransform(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *hY, Nd4jLong *hYShapeInfo,
|
|
|
|
|
void *dY, Nd4jLong *dYShapeInfo,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
void *extraParams) {
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto yType = sd::ArrayOptions::dataType(hYShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2019-11-21 13:43:03 +01:00
|
|
|
if (shape::isEmpty(hXShapeInfo) || shape::isEmpty(hYShapeInfo))
|
|
|
|
|
return;
|
|
|
|
|
|
2019-08-30 09:12:40 +02:00
|
|
|
if (xType != yType)
|
2020-03-02 10:49:41 +01:00
|
|
|
throw sd::datatype_exception::build("NativeOpExecutioner::execPairwiseBoolTransform", xType, yType);
|
2019-08-30 09:12:40 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
if (zType != sd::DataType::BOOL)
|
|
|
|
|
throw sd::datatype_exception::build("NativeOpExecutioner::execPairwiseBoolTransform", sd::DataType::BOOL, zType);
|
2019-08-30 09:12:40 +02:00
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
auto func = PRAGMA_THREADS_FOR {
|
|
|
|
|
BUILD_DOUBLE_SELECTOR(xType, zType, functions::pairwise_transforms::PairWiseBoolTransform, ::exec(opNum, hX, hXShapeInfo, hY, hYShapeInfo, hZ, hZShapeInfo, extraParams, start, stop), LIBND4J_TYPES, BOOL_TYPES);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
auto zLen = shape::length(hZShapeInfo);
|
2020-03-09 06:22:49 +01:00
|
|
|
samediff::Threads::parallel_for(func, 0, zLen, 1, sd::math::nd4j_max<int>(1, sd::math::nd4j_min<int>(zLen / 1024, sd::Environment::getInstance()->maxMasterThreads())));
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
}
|
|
|
|
|
|
2019-08-30 09:12:40 +02:00
|
|
|
////////////////////////////////////////////////////////////////////////
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execPairwiseIntTransform(sd::LaunchContext *lc,
|
2019-08-30 09:12:40 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *hY, Nd4jLong *hYShapeInfo,
|
|
|
|
|
void *dY, Nd4jLong *dYShapeInfo,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
void *extraParams) {
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto yType = sd::ArrayOptions::dataType(hYShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-08-30 09:12:40 +02:00
|
|
|
|
2019-11-21 13:43:03 +01:00
|
|
|
if (shape::isEmpty(hXShapeInfo) || shape::isEmpty(hYShapeInfo))
|
|
|
|
|
return;
|
|
|
|
|
|
2019-08-30 09:12:40 +02:00
|
|
|
if (xType != yType || xType != zType)
|
2020-03-02 10:49:41 +01:00
|
|
|
throw sd::datatype_exception::build("NativeOpExecutioner::execPairwiseIntTransform", zType, xType, yType);
|
2019-08-30 09:12:40 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
if (!sd::DataTypeUtils::isZ(zType))
|
|
|
|
|
throw sd::datatype_exception::build("NativeOpExecutioner::execSPairwiseInt requires integer data type", zType);
|
2019-08-30 09:12:40 +02:00
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
auto func = PRAGMA_THREADS_FOR {
|
|
|
|
|
BUILD_SINGLE_SELECTOR(xType, functions::pairwise_transforms::PairWiseIntTransform, ::exec(opNum, hX, hXShapeInfo, hY, hYShapeInfo, hZ, hZShapeInfo, extraParams, start, stop), INTEGER_TYPES);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
auto zLen = shape::length(hZShapeInfo);
|
2020-03-09 06:22:49 +01:00
|
|
|
samediff::Threads::parallel_for(func, 0, zLen, 1, sd::math::nd4j_max<int>(1, sd::math::nd4j_min<int>(zLen / 1024, sd::Environment::getInstance()->maxMasterThreads())));
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-08-30 09:12:40 +02:00
|
|
|
}
|
|
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
|
/**
|
|
|
|
|
*
|
|
|
|
|
* @param opNum
|
|
|
|
|
* @param hX
|
|
|
|
|
* @param hXShapeInfo
|
|
|
|
|
* @param extraParams
|
|
|
|
|
* @param hZ
|
|
|
|
|
* @param hZShapeInfo
|
|
|
|
|
*/
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execReduceFloat(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *extraParams,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
int *dimension, int dimensionLength,
|
|
|
|
|
Nd4jLong *tadShapeInfo, Nd4jLong *tadOffsets) {
|
|
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-08-02 19:01:03 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
// nothing to do here if result is empty
|
|
|
|
|
if (shape::isEmpty(hZShapeInfo))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
auto func = PRAGMA_THREADS_FOR {
|
|
|
|
|
BUILD_DOUBLE_SELECTOR(xType, zType, functions::reduce::ReduceFloatFunction, ::exec(opNum, hX, hXShapeInfo, extraParams, hZ, hZShapeInfo, dimension, dimensionLength, tadShapeInfo, tadOffsets, start, stop), LIBND4J_TYPES, FLOAT_TYPES);
|
|
|
|
|
};
|
|
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
const sd::LoopKind::Kind kindOfLoop = sd::LoopKind::deduceKindOfLoopTadXZ(hXShapeInfo, hZShapeInfo, tadShapeInfo);
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2020-03-09 06:22:49 +01:00
|
|
|
samediff::Threads::parallel_tad(func, 0, shape::length(hZShapeInfo), 1, kindOfLoop == sd::LoopKind::Kind::SMALLARR2DX ? 1 : sd::Environment::getInstance()->maxMasterThreads());
|
2019-06-06 14:21:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execReduceSame(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *extraParams,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
int *dimension, int dimensionLength,
|
|
|
|
|
Nd4jLong *tadShapeInfo, Nd4jLong *tadOffsets) {
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
// nothing to do here if result is empty
|
|
|
|
|
if (shape::isEmpty(hZShapeInfo))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
auto func = PRAGMA_THREADS_FOR {
|
|
|
|
|
BUILD_SINGLE_SELECTOR(xType, functions::reduce::ReduceSameFunction, ::exec(opNum, hX, hXShapeInfo, extraParams, hZ, hZShapeInfo, dimension, dimensionLength, tadShapeInfo, tadOffsets, start, stop), LIBND4J_TYPES);
|
|
|
|
|
};
|
|
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
const sd::LoopKind::Kind kindOfLoop = sd::LoopKind::deduceKindOfLoopTadXZ(hXShapeInfo, hZShapeInfo, tadShapeInfo);
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2020-03-09 06:22:49 +01:00
|
|
|
samediff::Threads::parallel_tad(func, 0, shape::length(hZShapeInfo), 1, kindOfLoop == sd::LoopKind::Kind::SMALLARR2DX ? 1 : sd::Environment::getInstance()->maxMasterThreads());
|
2019-06-06 14:21:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execReduceBool(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *extraParams,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
int *dimension, int dimensionLength,
|
|
|
|
|
Nd4jLong *tadShapeInfo, Nd4jLong *tadOffsets) {
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
// nothing to do here if result is empty
|
|
|
|
|
if (shape::isEmpty(hZShapeInfo))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
auto func = PRAGMA_THREADS_FOR {
|
|
|
|
|
BUILD_DOUBLE_SELECTOR(xType, zType, functions::reduce::ReduceBoolFunction, ::exec(opNum, hX, hXShapeInfo, extraParams, hZ, hZShapeInfo, dimension, dimensionLength, tadShapeInfo, tadOffsets, start, stop), LIBND4J_TYPES, BOOL_TYPES);
|
|
|
|
|
};
|
|
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
const sd::LoopKind::Kind kindOfLoop = sd::LoopKind::deduceKindOfLoopTadXZ(hXShapeInfo, hZShapeInfo, tadShapeInfo);
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2020-03-09 06:22:49 +01:00
|
|
|
samediff::Threads::parallel_tad(func, 0, shape::length(hZShapeInfo), 1, kindOfLoop == sd::LoopKind::Kind::SMALLARR2DX ? 1 : sd::Environment::getInstance()->maxMasterThreads());
|
2019-06-06 14:21:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execReduceLong(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *extraParams,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
int *dimension, int dimensionLength,
|
|
|
|
|
Nd4jLong *tadShapeInfo, Nd4jLong *tadOffsets) {
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
// nothing to do here if result is empty
|
|
|
|
|
if (shape::isEmpty(hZShapeInfo))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
auto func = PRAGMA_THREADS_FOR {
|
|
|
|
|
BUILD_DOUBLE_SELECTOR(xType, zType, functions::reduce::ReduceLongFunction, ::exec(opNum, hX, hXShapeInfo, extraParams, hZ, hZShapeInfo, dimension, dimensionLength, tadShapeInfo, tadOffsets, start, stop), LIBND4J_TYPES, LONG_TYPES);
|
|
|
|
|
};
|
|
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
const sd::LoopKind::Kind kindOfLoop = sd::LoopKind::deduceKindOfLoopTadXZ(hXShapeInfo, hZShapeInfo, tadShapeInfo);
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2020-03-09 06:22:49 +01:00
|
|
|
samediff::Threads::parallel_tad(func, 0, shape::length(hZShapeInfo), 1, kindOfLoop == sd::LoopKind::Kind::SMALLARR2DX ? 1 : sd::Environment::getInstance()->maxMasterThreads());
|
2019-06-06 14:21:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
|
/**
|
|
|
|
|
*
|
|
|
|
|
* @param opNum
|
|
|
|
|
* @param hX
|
|
|
|
|
* @param hXShapeInfo
|
|
|
|
|
* @param extraParams
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execReduceFloatScalar(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *extraParams,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo) {
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
|
|
|
|
BUILD_DOUBLE_SELECTOR(xType, zType, functions::reduce::ReduceFloatFunction, ::execScalar(opNum, hX, hXShapeInfo, extraParams, hZ, hZShapeInfo), LIBND4J_TYPES, FLOAT_TYPES);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execReduceSameScalar(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *extraParams,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo) {
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
|
|
|
|
BUILD_SINGLE_SELECTOR(xType, functions::reduce::ReduceSameFunction, ::execScalar(opNum, hX, hXShapeInfo, extraParams, hZ, hZShapeInfo), LIBND4J_TYPES);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execReduceBoolScalar(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *extraParams,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo) {
|
|
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-08-02 19:01:03 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
|
|
|
|
BUILD_DOUBLE_SELECTOR(xType, zType, functions::reduce::ReduceBoolFunction, ::execScalar(opNum, hX, hXShapeInfo, extraParams, hZ, hZShapeInfo), LIBND4J_TYPES, BOOL_TYPES);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execReduceLongScalar(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *extraParams,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo) {
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
|
|
|
|
BUILD_DOUBLE_SELECTOR(xType, zType, functions::reduce::ReduceLongFunction, ::execScalar(opNum, hX, hXShapeInfo, extraParams, hZ, hZShapeInfo), LIBND4J_TYPES, LONG_TYPES);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
|
/**
|
|
|
|
|
*
|
|
|
|
|
* @param opNum
|
|
|
|
|
* @param hX
|
|
|
|
|
* @param hXShapeInfo
|
|
|
|
|
* @param extraParamsVals
|
|
|
|
|
* @param hY
|
|
|
|
|
* @param hYShapeInfo
|
|
|
|
|
* @param hZ
|
|
|
|
|
* @param hZShapeInfo
|
|
|
|
|
* @param dimension
|
|
|
|
|
* @param dimensionLength
|
|
|
|
|
*/
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execReduce3Scalar(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *extraParamsVals,
|
|
|
|
|
void *hY, Nd4jLong *hYShapeInfo,
|
|
|
|
|
void *dY, Nd4jLong *dYShapeInfo,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo) {
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
BUILD_DOUBLE_SELECTOR(xType, zType, functions::reduce3::Reduce3, ::execScalar(opNum, hX, hXShapeInfo, extraParamsVals, hY, hYShapeInfo, hZ, hZShapeInfo), LIBND4J_TYPES, FLOAT_TYPES);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
|
/**
|
|
|
|
|
*
|
|
|
|
|
* @param opNum
|
|
|
|
|
* @param hX
|
|
|
|
|
* @param hXShapeInfo
|
|
|
|
|
* @param extraParamsVals
|
|
|
|
|
* @param hY
|
|
|
|
|
* @param hYShapeInfo
|
|
|
|
|
* @param hZ
|
|
|
|
|
* @param hZShapeInfo
|
|
|
|
|
*/
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execReduce3(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *extraParamsVals,
|
|
|
|
|
void *hY, Nd4jLong *hYShapeInfo,
|
|
|
|
|
void *dY, Nd4jLong *dYShapeInfo,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo) {
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
//BUILD_DOUBLE_SELECTOR(xType, zType, functions::reduce3::Reduce3, ::exec(opNum, hX, hXShapeInfo, extraParamsVals, hY, hYShapeInfo, hZ, hZShapeInfo, nullptr, 0), LIBND4J_TYPES, FLOAT_TYPES);
|
|
|
|
|
NativeOpExecutioner::execReduce3Scalar(lc, opNum, hX, hXShapeInfo, dX, dXShapeInfo, extraParamsVals, hY, hYShapeInfo, dY, dYShapeInfo, hZ, hZShapeInfo, dZ, dZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execReduce3(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *extraParamsVals,
|
|
|
|
|
void *hY, Nd4jLong *hYShapeInfo,
|
|
|
|
|
void *dY, Nd4jLong *dYShapeInfo,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
int *dimension, int dimensionLength,
|
|
|
|
|
Nd4jLong *xTadOnlyShapeInfo, Nd4jLong *xTadOffsets,
|
|
|
|
|
Nd4jLong *yTadOnlyShapeInfo, Nd4jLong *yTadOffsets) {
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
const auto xLen = shape::length(hXShapeInfo);
|
|
|
|
|
const auto yLen = shape::length(hYShapeInfo);
|
|
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
sd::TadPack tadPack;
|
2019-11-13 15:15:18 +01:00
|
|
|
|
|
|
|
|
if(xLen == yLen) {
|
2020-03-02 10:49:41 +01:00
|
|
|
tadPack = sd::ConstantTadHelper::getInstance()->tadForDimensions(hXShapeInfo, dimension, dimensionLength);
|
2019-11-13 15:15:18 +01:00
|
|
|
}
|
|
|
|
|
else if(yLen > xLen) {
|
2020-03-02 10:49:41 +01:00
|
|
|
tadPack = sd::ConstantTadHelper::getInstance()->tadForDimensions(hYShapeInfo, dimension, dimensionLength);
|
2019-11-13 15:15:18 +01:00
|
|
|
}
|
|
|
|
|
else {
|
2020-03-02 10:49:41 +01:00
|
|
|
tadPack = sd::ConstantTadHelper::getInstance()->tadForDimensions(hXShapeInfo, dimension, dimensionLength);
|
2019-11-13 15:15:18 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
auto func = PRAGMA_THREADS_FOR {
|
|
|
|
|
BUILD_DOUBLE_SELECTOR(xType, zType, functions::reduce3::Reduce3, ::exec(opNum, hX, hXShapeInfo, extraParamsVals, hY, hYShapeInfo, hZ, hZShapeInfo, dimension, dimensionLength, start, stop), LIBND4J_TYPES, FLOAT_TYPES);
|
|
|
|
|
};
|
|
|
|
|
|
2020-03-09 06:22:49 +01:00
|
|
|
samediff::Threads::parallel_tad(func, 0, tadPack.numberOfTads());
|
2019-06-06 14:21:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execReduce3All(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *extraParamsVals,
|
|
|
|
|
void *hY, Nd4jLong *hYShapeInfo,
|
|
|
|
|
void *dY, Nd4jLong *dYShapeInfo,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
int *dimension, int dimensionLength,
|
|
|
|
|
Nd4jLong *xTadShapeInfo, Nd4jLong *xOffsets,
|
|
|
|
|
Nd4jLong *yTadShapeInfo, Nd4jLong *yOffsets) {
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto tadPack = sd::ConstantTadHelper::getInstance()->tadForDimensions(hXShapeInfo, dimension, dimensionLength);
|
2019-11-13 15:15:18 +01:00
|
|
|
|
|
|
|
|
// TODO: make it 2d
|
|
|
|
|
auto func = PRAGMA_THREADS_FOR {
|
|
|
|
|
BUILD_DOUBLE_SELECTOR(xType, zType, functions::reduce3::Reduce3, ::execAll(opNum, hX, hXShapeInfo, extraParamsVals, hY, hYShapeInfo, hZ, hZShapeInfo, dimension, dimensionLength, xTadShapeInfo, xOffsets, yTadShapeInfo, yOffsets, start, stop), LIBND4J_TYPES, FLOAT_TYPES);
|
|
|
|
|
};
|
|
|
|
|
|
2020-03-09 06:22:49 +01:00
|
|
|
samediff::Threads::parallel_tad(func, 0, tadPack.numberOfTads());
|
2019-06-06 14:21:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execReduce3TAD(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *extraParamsVals,
|
|
|
|
|
void *hY, Nd4jLong *hYShapeInfo,
|
|
|
|
|
void *dY, Nd4jLong *dYShapeInfo,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
int *dimension, int dimensionLength,
|
|
|
|
|
Nd4jLong *tadShapeInfo, Nd4jLong *tadOffsets,
|
|
|
|
|
Nd4jLong *yTadShapeInfo, Nd4jLong *yTadOffsets) {
|
|
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-08-02 19:01:03 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
const auto xLen = shape::length(hXShapeInfo);
|
|
|
|
|
const auto yLen = shape::length(hYShapeInfo);
|
|
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
sd::TadPack tadPack;
|
2019-11-13 15:15:18 +01:00
|
|
|
|
|
|
|
|
if(xLen == yLen) {
|
2020-03-02 10:49:41 +01:00
|
|
|
tadPack = sd::ConstantTadHelper::getInstance()->tadForDimensions(hXShapeInfo, dimension, dimensionLength);
|
2019-11-13 15:15:18 +01:00
|
|
|
}
|
|
|
|
|
else if(yLen > xLen) {
|
2020-03-02 10:49:41 +01:00
|
|
|
tadPack = sd::ConstantTadHelper::getInstance()->tadForDimensions(hYShapeInfo, dimension, dimensionLength);
|
2019-11-13 15:15:18 +01:00
|
|
|
}
|
|
|
|
|
else {
|
2020-03-02 10:49:41 +01:00
|
|
|
tadPack = sd::ConstantTadHelper::getInstance()->tadForDimensions(hXShapeInfo, dimension, dimensionLength);
|
2019-11-13 15:15:18 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
auto func = PRAGMA_THREADS_FOR {
|
|
|
|
|
BUILD_DOUBLE_SELECTOR(xType, zType, functions::reduce3::Reduce3, ::exec(opNum, hX, hXShapeInfo, extraParamsVals, hY, hYShapeInfo, hZ, hZShapeInfo, dimension, dimensionLength, tadShapeInfo, tadOffsets, start, stop), LIBND4J_TYPES, FLOAT_TYPES);
|
|
|
|
|
};
|
|
|
|
|
|
2020-03-09 06:22:49 +01:00
|
|
|
samediff::Threads::parallel_tad(func, 0, tadPack.numberOfTads());
|
2019-06-06 14:21:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
|
/**
|
|
|
|
|
*
|
|
|
|
|
* @param opNum
|
|
|
|
|
* @param hX
|
|
|
|
|
* @param xStride
|
|
|
|
|
* @param hZ
|
|
|
|
|
* @param resultStride
|
|
|
|
|
* @param scalar
|
|
|
|
|
* @param extraParams
|
|
|
|
|
* @param n
|
|
|
|
|
*/
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execScalar(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
void *hScalar, Nd4jLong *hScalarShapeInfo,
|
|
|
|
|
void *dScalar, Nd4jLong *dScalarShapeInfo,
|
2019-08-02 19:01:03 +02:00
|
|
|
void *extraParams, bool allowParallelism) {
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto yType = sd::ArrayOptions::dataType(hScalarShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2019-11-21 13:43:03 +01:00
|
|
|
if (shape::isEmpty(hXShapeInfo) || shape::isEmpty(hScalarShapeInfo))
|
|
|
|
|
return;
|
|
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
#ifdef __ND4J_EXPERIMENTAL__
|
|
|
|
|
BUILD_PAIRWISE_SELECTOR(xType, yType, zType, functions::scalar::ScalarTransform, ::transform(opNum, hX, hXShapeInfo, hZ, hZShapeInfo, hScalar, extraParams), LIBND4J_TYPES, LIBND4J_TYPES);
|
|
|
|
|
#else
|
|
|
|
|
if (xType != yType || xType != zType)
|
2020-03-02 10:49:41 +01:00
|
|
|
throw sd::datatype_exception::build("NativeOpExecutioner::execScalar", zType, xType, yType);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
auto func = PRAGMA_THREADS_FOR {
|
|
|
|
|
BUILD_SINGLE_SELECTOR_THRICE(xType, functions::scalar::ScalarTransform,::transform(opNum, hX, hXShapeInfo, hZ, hZShapeInfo, hScalar, extraParams, start, stop), LIBND4J_TYPES);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
auto zLen = shape::length(hZShapeInfo);
|
2020-03-09 06:22:49 +01:00
|
|
|
samediff::Threads::parallel_for(func, 0, zLen, 1, !allowParallelism ? 1 : sd::math::nd4j_max<int>(1, sd::math::nd4j_min<int>(zLen / 1024, sd::Environment::getInstance()->maxMasterThreads())));
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execScalar(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *extraParams,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
void *hScalars, Nd4jLong *hScalarShapeInfo,
|
|
|
|
|
void *dScalars, Nd4jLong *dScalarShapeInfo,
|
|
|
|
|
int *dimension, int dimensionLength,
|
|
|
|
|
Nd4jLong *tadShapeInfo, Nd4jLong *tadOffsets,
|
|
|
|
|
Nd4jLong *tadShapeInfoZ, Nd4jLong *tadOffsetsZ) {
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto yType = sd::ArrayOptions::dataType(hScalarShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2019-11-21 13:43:03 +01:00
|
|
|
if (shape::isEmpty(hXShapeInfo) || shape::isEmpty(hScalarShapeInfo))
|
|
|
|
|
return;
|
|
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
#ifdef __ND4J_EXPERIMENTAL__
|
|
|
|
|
BUILD_PAIRWISE_SELECTOR(xType, yType, zType, functions::scalar::ScalarTransform, ::transform(opNum, hX, hXShapeInfo, extraParams, hZ, hZShapeInfo, hScalars, dimension, dimensionLength, tadShapeInfo, tadOffsets, tadShapeInfoZ, tadOffsetsZ), LIBND4J_TYPES, LIBND4J_TYPES);
|
|
|
|
|
#else
|
|
|
|
|
if (xType != yType || xType != zType)
|
2020-03-02 10:49:41 +01:00
|
|
|
throw sd::datatype_exception::build("NativeOpExecutioner::execScalar", zType, xType, yType);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
auto func = PRAGMA_THREADS_FOR {
|
|
|
|
|
BUILD_SINGLE_SELECTOR_THRICE(xType, functions::scalar::ScalarTransform, ::transform(opNum, hX, hXShapeInfo, extraParams, hZ, hZShapeInfo, hScalars, dimension, dimensionLength, tadShapeInfo, tadOffsets, tadShapeInfoZ, tadOffsetsZ, start, stop), LIBND4J_TYPES);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
auto yLen = shape::length(hScalarShapeInfo);
|
2020-03-09 06:22:49 +01:00
|
|
|
samediff::Threads::parallel_tad(func, 0, yLen, 1, sd::math::nd4j_min<int>(yLen, sd::Environment::getInstance()->maxMasterThreads()));
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execScalarBool(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
void *hScalar, Nd4jLong *hSscalarShapeInfo,
|
|
|
|
|
void *dScalar, Nd4jLong *dSscalarShapeInfo,
|
2019-08-02 19:01:03 +02:00
|
|
|
void *extraParams, bool allowParallelism) {
|
|
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto yType = sd::ArrayOptions::dataType(hSscalarShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2019-11-21 13:43:03 +01:00
|
|
|
if (shape::isEmpty(hXShapeInfo) || shape::isEmpty(hSscalarShapeInfo))
|
|
|
|
|
return;
|
|
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
if (xType != yType)
|
2020-03-02 10:49:41 +01:00
|
|
|
throw sd::datatype_exception::build("NativeOpExecutioner::execScalarBool", xType, yType);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
if (zType != sd::DataType::BOOL)
|
|
|
|
|
throw sd::datatype_exception::build("NativeOpExecutioner::execScalarBool", sd::DataType::BOOL, zType);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
auto func = PRAGMA_THREADS_FOR {
|
|
|
|
|
BUILD_DOUBLE_SELECTOR(xType, zType, functions::scalar::ScalarBoolTransform, ::transform(opNum, hX, hXShapeInfo, hZ, hZShapeInfo, hScalar, extraParams, start, stop), LIBND4J_TYPES, BOOL_TYPES);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
auto zLen = shape::length(hZShapeInfo);
|
2020-03-09 06:22:49 +01:00
|
|
|
samediff::Threads::parallel_for(func, 0, zLen, 1, !allowParallelism ? 1 : sd::math::nd4j_max<int>(1, sd::math::nd4j_min<int>(zLen / 1024, sd::Environment::getInstance()->maxMasterThreads())));
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execScalarBool(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *extraParams,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
void *hScalars, Nd4jLong *hScalarShapeInfo,
|
|
|
|
|
void *dScalars, Nd4jLong *dScalarShapeInfo,
|
|
|
|
|
int *dimension, int dimensionLength,
|
|
|
|
|
Nd4jLong *tadShapeInfo, Nd4jLong *tadOffsets,
|
|
|
|
|
Nd4jLong *tadShapeInfoZ, Nd4jLong *tadOffsetsZ) {
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto yType = sd::ArrayOptions::dataType(hScalarShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2019-11-21 13:43:03 +01:00
|
|
|
if (shape::isEmpty(hXShapeInfo) || shape::isEmpty(hScalarShapeInfo))
|
|
|
|
|
return;
|
|
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
if (xType != yType)
|
2020-03-02 10:49:41 +01:00
|
|
|
throw sd::datatype_exception::build("NativeOpExecutioner::execScalarBool", xType, yType);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
if (zType != sd::DataType::BOOL)
|
|
|
|
|
throw sd::datatype_exception::build("NativeOpExecutioner::execScalarBool", sd::DataType::BOOL, zType);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
auto func = PRAGMA_THREADS_FOR {
|
|
|
|
|
BUILD_DOUBLE_SELECTOR(xType, zType, functions::scalar::ScalarBoolTransform, ::transform(opNum, hX, hXShapeInfo, extraParams, hZ, hZShapeInfo, hScalars, dimension, dimensionLength, tadShapeInfo, tadOffsets, tadShapeInfoZ, tadOffsetsZ, start, stop), LIBND4J_TYPES, BOOL_TYPES);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
auto yLen = shape::length(hScalarShapeInfo);
|
2020-03-09 06:22:49 +01:00
|
|
|
samediff::Threads::parallel_tad(func, 0, yLen, 1, sd::math::nd4j_min<int>(yLen, sd::Environment::getInstance()->maxMasterThreads()));
|
2019-06-06 14:21:15 +02:00
|
|
|
}
|
|
|
|
|
|
2019-08-30 09:12:40 +02:00
|
|
|
////////////////////////////////////////////////////////////////////////
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execScalarInt(sd::LaunchContext *lc,
|
2019-08-30 09:12:40 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
void *hScalar, Nd4jLong *hSscalarShapeInfo,
|
|
|
|
|
void *dScalar, Nd4jLong *dSscalarShapeInfo,
|
|
|
|
|
void *extraParams, bool allowParallelism) {
|
|
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto yType = sd::ArrayOptions::dataType(hSscalarShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-08-30 09:12:40 +02:00
|
|
|
|
2019-11-21 13:43:03 +01:00
|
|
|
if (shape::isEmpty(hXShapeInfo) || shape::isEmpty(hSscalarShapeInfo))
|
|
|
|
|
return;
|
|
|
|
|
|
2019-08-30 09:12:40 +02:00
|
|
|
if (xType != yType || xType != zType)
|
2020-03-02 10:49:41 +01:00
|
|
|
throw sd::datatype_exception::build("NativeOpExecutioner::execScalarInt", xType, yType);
|
2019-08-30 09:12:40 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
if (!sd::DataTypeUtils::isZ(zType))
|
|
|
|
|
throw sd::datatype_exception::build("NativeOpExecutioner::execScalarInt", sd::DataType::INT32, zType);
|
2019-08-30 09:12:40 +02:00
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
auto func = PRAGMA_THREADS_FOR {
|
|
|
|
|
BUILD_SINGLE_SELECTOR(xType, functions::scalar::ScalarIntTransform, ::transform(opNum, hX, hXShapeInfo, hZ, hZShapeInfo, hScalar, extraParams, start, stop), INTEGER_TYPES);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
auto zLen = shape::length(hZShapeInfo);
|
2020-03-09 06:22:49 +01:00
|
|
|
samediff::Threads::parallel_for(func, 0, zLen, 1, !allowParallelism ? 1 : sd::math::nd4j_max<int>(1, sd::math::nd4j_min<int>(zLen / 1024, sd::Environment::getInstance()->maxMasterThreads())));
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-08-30 09:12:40 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execScalarInt(sd::LaunchContext *lc,
|
2019-08-30 09:12:40 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *extraParams,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
void *hScalars, Nd4jLong *hScalarShapeInfo,
|
|
|
|
|
void *dScalars, Nd4jLong *dScalarShapeInfo,
|
|
|
|
|
int *dimension, int dimensionLength,
|
|
|
|
|
Nd4jLong *tadShapeInfo, Nd4jLong *tadOffsets,
|
|
|
|
|
Nd4jLong *tadShapeInfoZ, Nd4jLong *tadOffsetsZ) {
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto yType = sd::ArrayOptions::dataType(hScalarShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-08-30 09:12:40 +02:00
|
|
|
|
2019-11-21 13:43:03 +01:00
|
|
|
if (shape::isEmpty(hXShapeInfo) || shape::isEmpty(hScalarShapeInfo))
|
|
|
|
|
return;
|
|
|
|
|
|
2019-08-30 09:12:40 +02:00
|
|
|
if (xType != yType || xType != zType)
|
2020-03-02 10:49:41 +01:00
|
|
|
throw sd::datatype_exception::build("NativeOpExecutioner::execScalarInt", xType, yType);
|
2019-08-30 09:12:40 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
if (!sd::DataTypeUtils::isZ(zType))
|
|
|
|
|
throw sd::datatype_exception::build("NativeOpExecutioner::execScalarInt requires integer data type", zType);
|
2019-08-30 09:12:40 +02:00
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
auto func = PRAGMA_THREADS_FOR {
|
|
|
|
|
BUILD_SINGLE_SELECTOR(xType, functions::scalar::ScalarIntTransform, ::transform(opNum, hX, hXShapeInfo, extraParams, hZ, hZShapeInfo, hScalars, dimension, dimensionLength, tadShapeInfo, tadOffsets, tadShapeInfoZ, tadOffsetsZ, start, stop), INTEGER_TYPES);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
auto yLen = shape::length(hScalarShapeInfo);
|
2020-03-09 06:22:49 +01:00
|
|
|
samediff::Threads::parallel_tad(func, 0, yLen, 1, sd::math::nd4j_min<int>(yLen, sd::Environment::getInstance()->maxMasterThreads()));
|
2019-08-30 09:12:40 +02:00
|
|
|
}
|
|
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
|
/**
|
|
|
|
|
*
|
|
|
|
|
* @param opNum
|
|
|
|
|
* @param hX
|
|
|
|
|
* @param hXShapeInfo
|
|
|
|
|
* @param extraParams
|
|
|
|
|
* @param hZ
|
|
|
|
|
* @param hZShapeInfo
|
|
|
|
|
*/
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execSummaryStats(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *extraParams,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
bool biasCorrected) {
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
|
|
|
|
BUILD_DOUBLE_SELECTOR(xType, zType, functions::summarystats::SummaryStatsReduce, ::exec(opNum, biasCorrected, hX, hXShapeInfo, extraParams, hZ, hZShapeInfo, nullptr, 1), LIBND4J_TYPES, FLOAT_TYPES);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
|
/**
|
|
|
|
|
*
|
|
|
|
|
* @param opNum
|
|
|
|
|
* @param hX
|
|
|
|
|
* @param hXShapeInfo
|
|
|
|
|
* @param extraParams
|
|
|
|
|
* @param hZ
|
|
|
|
|
* @param hZShapeInfo
|
|
|
|
|
*/
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execSummaryStatsScalar(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *extraParams,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
bool biasCorrected) {
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
|
|
|
|
BUILD_DOUBLE_SELECTOR(xType, zType, functions::summarystats::SummaryStatsReduce, ::execScalar(opNum, biasCorrected, hX, hXShapeInfo, extraParams, hZ, hZShapeInfo), LIBND4J_TYPES, FLOAT_TYPES);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
|
/**
|
|
|
|
|
*
|
|
|
|
|
* @param opNum
|
|
|
|
|
* @param hX
|
|
|
|
|
* @param hXShapeInfo
|
|
|
|
|
* @param extraParams
|
|
|
|
|
* @param hZ
|
|
|
|
|
* @param hZShapeInfo
|
|
|
|
|
* @param dimension
|
|
|
|
|
* @param dimensionLength
|
|
|
|
|
*/
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execSummaryStats(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *extraParams,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
int *dimension, int dimensionLength,
|
|
|
|
|
Nd4jLong *tadShapeInfo, Nd4jLong *tadOffsets,
|
|
|
|
|
bool biasCorrected) {
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
|
|
|
|
BUILD_DOUBLE_SELECTOR(xType, zType, functions::summarystats::SummaryStatsReduce, ::exec(opNum, biasCorrected, hX, hXShapeInfo, extraParams, hZ, hZShapeInfo, dimension, dimensionLength), LIBND4J_TYPES, FLOAT_TYPES);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
|
/**
|
|
|
|
|
*
|
|
|
|
|
* @param opNum
|
|
|
|
|
* @param hX
|
|
|
|
|
* @param xStride
|
|
|
|
|
* @param hZ
|
|
|
|
|
* @param resultStride
|
|
|
|
|
* @param extraParams
|
|
|
|
|
* @param n
|
|
|
|
|
*/
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execTransformFloat(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
void *extraParams,
|
|
|
|
|
Nd4jLong *tadShapeInfo, Nd4jLong *tadOffsets) {
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2019-11-21 13:43:03 +01:00
|
|
|
if (shape::isEmpty(hXShapeInfo))
|
|
|
|
|
return;
|
|
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
auto func = PRAGMA_THREADS_DO {
|
|
|
|
|
BUILD_DOUBLE_SELECTOR(xType, zType, functions::transform::TransformFloat, ::exec(opNum, hX, hXShapeInfo, hZ, hZShapeInfo, extraParams, thread_id, numThreads), LIBND4J_TYPES, FLOAT_TYPES);
|
|
|
|
|
};
|
|
|
|
|
|
2020-03-09 06:22:49 +01:00
|
|
|
samediff::Threads::parallel_do(func, sd::math::nd4j_max<int>(1, sd::math::nd4j_min<int>(shape::length(hZShapeInfo) / 1024, sd::Environment::getInstance()->maxMasterThreads())));
|
2019-06-06 14:21:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execTransformBool(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
void *extraParams,
|
|
|
|
|
Nd4jLong *tadShapeInfo, Nd4jLong *tadOffsets) {
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2019-11-21 13:43:03 +01:00
|
|
|
if (shape::isEmpty(hXShapeInfo))
|
|
|
|
|
return;
|
|
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
auto func = PRAGMA_THREADS_DO {
|
|
|
|
|
BUILD_DOUBLE_SELECTOR(xType, zType, functions::transform::TransformBool, ::exec(opNum, hX, hXShapeInfo, hZ, hZShapeInfo, extraParams, thread_id, numThreads), LIBND4J_TYPES, BOOL_TYPES);
|
|
|
|
|
};
|
|
|
|
|
|
2020-03-09 06:22:49 +01:00
|
|
|
samediff::Threads::parallel_do(func, sd::math::nd4j_max<int>(1, sd::math::nd4j_min<int>(shape::length(hZShapeInfo) / 1024, sd::Environment::getInstance()->maxMasterThreads())));
|
2019-06-06 14:21:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execTransformAny(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
void *extraParams,
|
2019-08-02 19:01:03 +02:00
|
|
|
Nd4jLong *tadShapeInfo, Nd4jLong *tadOffsets, bool allowParallelism) {
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2019-11-21 13:43:03 +01:00
|
|
|
if (shape::isEmpty(hXShapeInfo))
|
|
|
|
|
return;
|
|
|
|
|
|
2020-03-03 05:32:37 +01:00
|
|
|
if (opNum == sd::transform::Assign && shape::order(hXShapeInfo) == shape::order(hZShapeInfo) && shape::order(hXShapeInfo) == 'c' && xType == zType && shape::elementWiseStride(hXShapeInfo) == 1 && shape::elementWiseStride(hZShapeInfo) == 1) {
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2020-03-03 05:32:37 +01:00
|
|
|
memcpy(hZ, hX, shape::length(hXShapeInfo) * sd::DataTypeUtils::sizeOfElement(xType));
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
auto func = PRAGMA_THREADS_DO {
|
|
|
|
|
|
|
|
|
|
BUILD_DOUBLE_SELECTOR(xType, zType, functions::transform::TransformAny, ::exec(opNum, hX, hXShapeInfo, hZ, hZShapeInfo, extraParams, thread_id, numThreads), LIBND4J_TYPES, LIBND4J_TYPES);
|
|
|
|
|
};
|
|
|
|
|
|
2020-03-09 06:22:49 +01:00
|
|
|
samediff::Threads::parallel_do(func, sd::math::nd4j_max<int>(1, sd::math::nd4j_min<int>(shape::length(hZShapeInfo) / 1024, sd::Environment::getInstance()->maxMasterThreads())));
|
2020-03-03 05:32:37 +01:00
|
|
|
}
|
2019-06-06 14:21:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execTransformSame(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
void *extraParams,
|
|
|
|
|
Nd4jLong *tadShapeInfo, Nd4jLong *tadOffsets) {
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2019-11-21 13:43:03 +01:00
|
|
|
if (shape::isEmpty(hXShapeInfo))
|
|
|
|
|
return;
|
|
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
auto func = PRAGMA_THREADS_DO {
|
|
|
|
|
BUILD_SINGLE_SELECTOR(xType, functions::transform::TransformSame, ::exec(opNum, hX, hXShapeInfo, hZ, hZShapeInfo, extraParams, thread_id, numThreads), LIBND4J_TYPES);
|
|
|
|
|
};
|
|
|
|
|
|
2020-03-09 06:22:49 +01:00
|
|
|
samediff::Threads::parallel_do(func, sd::math::nd4j_max<int>(1, sd::math::nd4j_min<int>(shape::length(hZShapeInfo) / 1024, sd::Environment::getInstance()->maxMasterThreads())));
|
2019-06-06 14:21:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execTransformStrict(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
void *extraParams,
|
|
|
|
|
Nd4jLong *tadShapeInfo, Nd4jLong *tadOffsets) {
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hXShapeInfo);
|
|
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2019-11-21 13:43:03 +01:00
|
|
|
if (shape::isEmpty(hXShapeInfo))
|
|
|
|
|
return;
|
|
|
|
|
|
2019-11-13 15:15:18 +01:00
|
|
|
auto func = PRAGMA_THREADS_DO {
|
|
|
|
|
BUILD_SINGLE_SELECTOR(xType, functions::transform::TransformStrict, ::exec(opNum, hX, hXShapeInfo, hZ, hZShapeInfo, extraParams, thread_id, numThreads), FLOAT_TYPES);
|
|
|
|
|
};
|
|
|
|
|
|
2020-03-09 06:22:49 +01:00
|
|
|
samediff::Threads::parallel_do(func, sd::math::nd4j_max<int>(1, sd::math::nd4j_min<int>(shape::length(hZShapeInfo) / 1024, sd::Environment::getInstance()->maxMasterThreads())));
|
2019-06-06 14:21:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execRandom(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
Nd4jPointer state,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
void *extraArguments) {
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
|
|
|
|
BUILD_SINGLE_SELECTOR(zType, functions::random::RandomFunction, ::execTransform(opNum, state, hZ, hZShapeInfo, extraArguments), FLOAT_TYPES);
|
2019-07-16 17:48:40 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto rng = reinterpret_cast<sd::graph::RandomGenerator*>(state);
|
2019-07-16 17:48:40 +02:00
|
|
|
rng->rewindH(shape::length(hZShapeInfo));
|
2019-06-06 14:21:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execRandom(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
Nd4jPointer state,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
void *extraArguments) {
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto zType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
|
|
|
|
BUILD_SINGLE_SELECTOR(zType, functions::random::RandomFunction, ::execTransform(opNum, state, hX, hXShapeInfo, hZ, hZShapeInfo, extraArguments), FLOAT_TYPES);
|
2019-07-16 17:48:40 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto rng = reinterpret_cast<sd::graph::RandomGenerator*>(state);
|
2019-07-16 17:48:40 +02:00
|
|
|
rng->rewindH(shape::length(hZShapeInfo));
|
2019-06-06 14:21:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
2020-03-02 10:49:41 +01:00
|
|
|
void NativeOpExecutioner::execRandom(sd::LaunchContext *lc,
|
2019-06-06 14:21:15 +02:00
|
|
|
int opNum,
|
|
|
|
|
Nd4jPointer state,
|
|
|
|
|
void *hX, Nd4jLong *hXShapeInfo,
|
|
|
|
|
void *dX, Nd4jLong *dXShapeInfo,
|
|
|
|
|
void *hY, Nd4jLong *hYShapeInfo,
|
|
|
|
|
void *dY, Nd4jLong *dYShapeInfo,
|
|
|
|
|
void *hZ, Nd4jLong *hZShapeInfo,
|
|
|
|
|
void *dZ, Nd4jLong *dZShapeInfo,
|
|
|
|
|
void *extraArguments) {
|
2019-11-13 15:15:18 +01:00
|
|
|
|
2019-06-06 14:21:15 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto xType = sd::ArrayOptions::dataType(hZShapeInfo);
|
2019-06-06 14:21:15 +02:00
|
|
|
|
|
|
|
|
BUILD_SINGLE_SELECTOR(xType, functions::random::RandomFunction, ::execTransform(opNum, state, hX, hXShapeInfo, hY, hYShapeInfo, hZ, hZShapeInfo, extraArguments), FLOAT_TYPES);
|
2019-07-16 17:48:40 +02:00
|
|
|
|
2020-03-02 10:49:41 +01:00
|
|
|
auto rng = reinterpret_cast<sd::graph::RandomGenerator*>(state);
|
2019-07-16 17:48:40 +02:00
|
|
|
rng->rewindH(shape::length(hZShapeInfo));
|
2019-06-06 14:21:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
