cavis/libnd4j/include/helpers/cpu/loops/IndexReductionLoops.cpp

316 lines
14 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
******************************************************************************/
//
// @author Yurii Shyrma (iuriish@yahoo.com), created on 14.03.2019
//
#include <helpers/Loops.h>
using namespace simdOps;
//////////////////////////////////////////////////////////////////////////////
template <typename X, typename Z>
template <typename OpType>
void nd4j::IndexReductionLoops<X,Z>::loopIndexReduce(X* x, Nd4jLong* xShapeInfo,
Z* z, Nd4jLong* zShapeInfo,
Nd4jLong* tadShapeInfo, Nd4jLong* tadOffsets,
X* extraParams) {
nd4j::LoopKind::Kind kindOfLoop = nd4j::LoopKind::deduceKindOfLoopTadXZ(xShapeInfo, zShapeInfo, tadShapeInfo);
if(kindOfLoop == nd4j::LoopKind::SMALLARR2DX)
kindOfLoop = nd4j::LoopKind::EWSNONZERO;
const Nd4jLong zLen = shape::length(zShapeInfo);
const Nd4jLong tadLen = shape::length(tadShapeInfo);
const uint tadEws = shape::elementWiseStride(tadShapeInfo);
const uint zEws = shape::elementWiseStride(zShapeInfo);
const Nd4jLong* tadShape = shape::shapeOf(const_cast<Nd4jLong*>(tadShapeInfo));
const Nd4jLong* tadStride = shape::stride(const_cast<Nd4jLong*>(tadShapeInfo));
switch (kindOfLoop) {
//*********************************************//
case nd4j::LoopKind::EWS1: {
auto func = PRAGMA_THREADS_FOR {
for (auto i = start; i < stop; i += increment) {
auto tad = const_cast<X *>(x) + tadOffsets[i];
auto indexValue = OpType::startingIndexValue(tad);
for (uint j = 0; j < tadLen; j++) {
functions::indexreduce::IndexValue<X> comp(tad[j], j);
indexValue = OpType::update(indexValue, comp, extraParams);
}
z[i] = (Z) indexValue.index;
}
};
samediff::Threads::parallel_tad(func, 0, zLen);
}
break;
//*********************************************//
case nd4j::LoopKind::EWSNONZERO: {
auto func = PRAGMA_THREADS_FOR {
for (auto i = start; i < stop; i += increment) {
auto tad = const_cast<X *>(x) + tadOffsets[i];
auto indexValue = OpType::startingIndexValue(tad);
for (uint j = 0; j < tadLen; j++) {
functions::indexreduce::IndexValue<X> comp(tad[j * tadEws], j);
indexValue = OpType::update(indexValue, comp, extraParams);
}
z[i * zEws] = (Z) indexValue.index;
}
};
samediff::Threads::parallel_tad(func, 0, zLen);
}
break;
//*********************************************//
case nd4j::LoopKind::RANK1: {
auto func = PRAGMA_THREADS_FOR {
for (auto i = start; i < stop; i += increment) {
auto tad = const_cast<X *>(x) + tadOffsets[i];
auto indexValue = OpType::startingIndexValue(tad);
for (uint i0 = 0; i0 < tadLen; ++i0) {
functions::indexreduce::IndexValue<X> comp(tad[i0 * tadStride[0]], i0);
indexValue = OpType::update(indexValue, comp, extraParams);
}
z[i] = (Z) indexValue.index;
}
};
samediff::Threads::parallel_tad(func, 0, zLen);
}
break;
//*********************************************//
case nd4j::LoopKind::RANK2: {
Nd4jLong newStride[2];
shape::updateStrides(2, tadShape, newStride, 'c');
auto func = PRAGMA_THREADS_FOR {
for (auto i = start; i < stop; i += increment) {
auto tad = const_cast<X *>(x) + tadOffsets[i];
auto indexValue = OpType::startingIndexValue(tad);
for (uint i0 = 0; i0 < tadShape[0]; ++i0) {
for (uint i1 = 0; i1 < tadShape[1]; ++i1) {
const auto tadOffset = i0 * tadStride[0] + i1 * tadStride[1];
const auto tadIndex = i0 * newStride[0] + i1;
functions::indexreduce::IndexValue<X> comp(tad[tadOffset], tadIndex);
indexValue = OpType::update(indexValue, comp, extraParams);
}
}
z[i] = (Z) indexValue.index;
}
};
samediff::Threads::parallel_tad(func, 0, zLen);
}
break;
//*********************************************//
case nd4j::LoopKind::RANK3: {
Nd4jLong newStride[3];
shape::updateStrides(3, tadShape, newStride, 'c');
auto func = PRAGMA_THREADS_FOR {
for (auto i = start; i < stop; i += increment) {
auto tad = const_cast<X *>(x) + tadOffsets[i];
auto indexValue = OpType::startingIndexValue(tad);
for (uint i0 = 0; i0 < tadShape[0]; ++i0) {
for (uint i1 = 0; i1 < tadShape[1]; ++i1) {
for (uint i2 = 0; i2 < tadShape[2]; ++i2) {
const auto tadOffset = i0 * tadStride[0] + i1 * tadStride[1] + i2 * tadStride[2];
const auto tadIndex = i0 * newStride[0] + i1 * newStride[1] + i2;
functions::indexreduce::IndexValue<X> comp(tad[tadOffset], tadIndex);
indexValue = OpType::update(indexValue, comp, extraParams);
}
}
}
z[i] = (Z) indexValue.index;
}
};
samediff::Threads::parallel_tad(func, 0, zLen);
}
break;
//*********************************************//
case nd4j::LoopKind::RANK4: {
Nd4jLong newStride[4];
shape::updateStrides(4, tadShape, newStride, 'c');
auto func = PRAGMA_THREADS_FOR {
for (auto i = start; i < stop; i += increment) {
auto tad = const_cast<X *>(x) + tadOffsets[i];
auto indexValue = OpType::startingIndexValue(tad);
for (uint i0 = 0; i0 < tadShape[0]; ++i0) {
for (uint i1 = 0; i1 < tadShape[1]; ++i1) {
for (uint i2 = 0; i2 < tadShape[2]; ++i2) {
for (uint i3 = 0; i3 < tadShape[3]; ++i3) {
const auto tadOffset = i0 * tadStride[0] + i1 * tadStride[1] + i2 * tadStride[2] + i3 * tadStride[3];
const auto tadIndex = i0 * newStride[0] + i1 * newStride[1] + i2 * newStride[2] + i3;
functions::indexreduce::IndexValue<X> comp(tad[tadOffset], tadIndex);
indexValue = OpType::update(indexValue, comp, extraParams);
}
}
}
}
z[i] = (Z) indexValue.index;
}
};
samediff::Threads::parallel_tad(func, 0, zLen);
}
break;
//*********************************************//
case nd4j::LoopKind::RANK5: {
Nd4jLong newStride[5];
shape::updateStrides(5, tadShape, newStride, 'c');
auto func = PRAGMA_THREADS_FOR {
for (auto i = start; i < stop; i += increment) {
auto tad = const_cast<X *>(x) + tadOffsets[i];
auto indexValue = OpType::startingIndexValue(tad);
for (uint i0 = 0; i0 < tadShape[0]; ++i0) {
for (uint i1 = 0; i1 < tadShape[1]; ++i1) {
for (uint i2 = 0; i2 < tadShape[2]; ++i2) {
for (uint i3 = 0; i3 < tadShape[3]; ++i3) {
for (uint i4 = 0; i4 < tadShape[4]; ++i4) {
const auto tadOffset = i0 * tadStride[0] + i1 * tadStride[1] + i2 * tadStride[2] + i3 * tadStride[3] + i4 * tadStride[4];
const auto tadIndex = i0 * newStride[0] + i1 * newStride[1] + i2 * newStride[2] + i3 * newStride[3] + i4;
functions::indexreduce::IndexValue<X> comp(tad[tadOffset], tadIndex);
indexValue = OpType::update(indexValue, comp, extraParams);
}
}
}
}
}
z[i] = (Z) indexValue.index;
}
};
samediff::Threads::parallel_tad(func, 0, zLen);
}
break;
//*********************************************//
case nd4j::LoopKind::X_EWSNONZERO: {
uint castZShapeInfo[MAX_RANK];
const bool canCastZ = nd4j::DataTypeUtils::castShapeInfo<uint>(zShapeInfo, castZShapeInfo);
auto func = PRAGMA_THREADS_FOR {
for (auto i = start; i < stop; i += increment) {
auto tad = const_cast<X *>(x) + tadOffsets[i];
auto indexValue = OpType::startingIndexValue(tad);
for (uint j = 0; j < tadLen; j++) {
functions::indexreduce::IndexValue<X> comp(tad[j * tadEws], j);
indexValue = OpType::update(indexValue, comp, extraParams);
}
auto zOffset = shape::indexOffset(i, zShapeInfo, castZShapeInfo, canCastZ);
z[zOffset] = (Z) indexValue.index;
}
};
samediff::Threads::parallel_tad(func, 0, zLen);
}
break;
//*********************************************//
case nd4j::LoopKind::Z_EWSNONZERO: {
uint castTadShapeInfo[MAX_RANK];
const bool canCastTad = nd4j::DataTypeUtils::castShapeInfo<uint>(tadShapeInfo, castTadShapeInfo);
auto func = PRAGMA_THREADS_FOR {
for (auto i = start; i < stop; i += increment) {
auto tad = const_cast<X *>(x) + tadOffsets[i];
auto indexValue = OpType::startingIndexValue(tad);
for (uint j = 0; j < tadLen; j++) {
auto tadOffset = shape::indexOffset(j, tadShapeInfo, castTadShapeInfo, canCastTad);
functions::indexreduce::IndexValue<X> comp(tad[tadOffset], j);
indexValue = OpType::update(indexValue, comp, extraParams);
}
z[i * zEws] = (Z) indexValue.index;
}
};
samediff::Threads::parallel_tad(func, 0, zLen);
}
break;
//*********************************************//
default: {
uint castTadShapeInfo[MAX_RANK];
uint castZShapeInfo[MAX_RANK];
const bool canCastTad = nd4j::DataTypeUtils::castShapeInfo<uint>(tadShapeInfo, castTadShapeInfo);
const bool canCastZ = nd4j::DataTypeUtils::castShapeInfo<uint>(zShapeInfo, castZShapeInfo);
auto func = PRAGMA_THREADS_FOR {
for (auto i = start; i < stop; i += increment) {
auto tad = const_cast<X *>(x) + tadOffsets[i];
auto indexValue = OpType::startingIndexValue(tad);
for (uint j = 0; j < tadLen; j++) {
auto tadOffset = shape::indexOffset(j, tadShapeInfo, castTadShapeInfo, canCastTad);
functions::indexreduce::IndexValue<X> comp(tad[tadOffset], j);
indexValue = OpType::update(indexValue, comp, extraParams);
}
auto zOffset = shape::indexOffset(i, zShapeInfo, castZShapeInfo, canCastZ);
z[zOffset] = (Z) indexValue.index;
}
};
samediff::Threads::parallel_tad(func, 0, zLen);
}
}
}
template <typename X, typename Y>
void nd4j::IndexReductionLoops<X, Y>::wrapIndexReduce(const int opNum, void* vx, Nd4jLong* xShapeInfo, void* vz, Nd4jLong* zShapeInfo, Nd4jLong* tadShapeInfo, Nd4jLong* tadOffsets, void* vextraParams) {
auto x = reinterpret_cast<X *>(vx);
auto z = reinterpret_cast<Y *>(vz);
auto extraParams = reinterpret_cast<X *>(vextraParams);
DISPATCH_BY_OPNUM_TT(loopIndexReduce, PARAMS(x, xShapeInfo, z, zShapeInfo, tadShapeInfo, tadOffsets, extraParams), INDEX_REDUCE_OPS);
}
BUILD_DOUBLE_TEMPLATE(template void nd4j::IndexReductionLoops, ::wrapIndexReduce(const int opNum, void* vx, Nd4jLong* xShapeInfo, void* z, Nd4jLong* zShapeInfo, Nd4jLong* tadShapeInfo, Nd4jLong* tadOffsets, void* vextraParams), LIBND4J_TYPES, INDEXING_TYPES);