chore: import upstream snapshot with attribution
This commit is contained in:
wehub-resource-sync
@@ -0,0 +1,799 @@
|
||||
#ifndef ND4J_ARRAY_OPTIONS_HXX
|
||||
#define ND4J_ARRAY_OPTIONS_HXX
|
||||
#include <array/ArrayOptions.h>
|
||||
#include <system/op_boilerplate.h>
|
||||
#include <helpers/shape.h>
|
||||
#include <array/DataTypeUtils.h>
|
||||
#pragma once
|
||||
|
||||
namespace sd {
|
||||
|
||||
|
||||
|
||||
SD_HOST SD_INLINE sd::LongType ArrayOptions::extraIndex(const sd::LongType *shapeInfo) {
|
||||
return ArrayOptions::extraIndex(const_cast<sd::LongType *>(shapeInfo));
|
||||
}
|
||||
|
||||
|
||||
SD_HOST SD_INLINE sd::LongType ArrayOptions::extraIndex(sd::LongType *shapeInfo) {
|
||||
if(shapeInfo == nullptr)
|
||||
THROW_EXCEPTION("Shape info was null!");
|
||||
sd::LongType rank = shapeInfo[0];
|
||||
|
||||
sd::LongType idx = 0;
|
||||
//rank takes up 1 element + usual elements
|
||||
if(rank == 0)
|
||||
idx = 3;
|
||||
else
|
||||
// FIXME magic numbers
|
||||
idx = rank + rank + 1;
|
||||
|
||||
return idx;
|
||||
}
|
||||
|
||||
|
||||
SD_HOST SD_INLINE void ArrayOptions::setExtra(sd::LongType *shapeInfo, sd::LongType value) {
|
||||
sd::LongType idx = ArrayOptions::extraIndex(shapeInfo);
|
||||
shapeInfo[idx] = value;
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE LongType ArrayOptions::extra(const LongType *shapeInfo) {
|
||||
sd::LongType idx = ArrayOptions::extraIndex(shapeInfo);
|
||||
if(idx > shape::shapeInfoLength(shape::rank(shapeInfo)))
|
||||
THROW_EXCEPTION("Extra index is out of bounds!");
|
||||
return shapeInfo[idx];
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE bool ArrayOptions::isNewFormat(const sd::LongType *shapeInfo) {
|
||||
return (extra(const_cast<sd::LongType *>(shapeInfo)) != 0);
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE bool ArrayOptions::isSparseArray(sd::LongType *shapeInfo) {
|
||||
return hasPropertyBitSet(shapeInfo, ARRAY_SPARSE);
|
||||
}
|
||||
|
||||
SD_HOST_DEVICE SD_INLINE bool ArrayOptions::hasExtraProperties(sd::LongType *shapeInfo) {
|
||||
return hasPropertyBitSet(shapeInfo, ARRAY_EXTRAS);
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE bool ArrayOptions::hasPropertyBitSet(const sd::LongType extra, LongType property) {
|
||||
return ((static_cast<int>(extra) & static_cast<int>(property)) == static_cast<int>(property));
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE bool ArrayOptions:: hasPropertyBitSet(const sd::LongType *shapeInfo, LongType property) {
|
||||
if (!isNewFormat(shapeInfo)) return false;
|
||||
|
||||
return ((static_cast<int>(extra(const_cast<sd::LongType *>(shapeInfo)) & property)) == static_cast<int>(property));
|
||||
}
|
||||
|
||||
|
||||
SD_HOST_DEVICE SD_INLINE bool hasPropertyBitSetForFlags(const sd::LongType& flagStorage, LongType property) {
|
||||
return static_cast<sd::LongType>(flagStorage & (property)) == (property);
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE void unsetPropertyBitForFlags(sd::LongType& flagStorage, LongType property) {
|
||||
flagStorage &= ~property;
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE const char *ArrayOptions::enumerateSetFlagsForFlags(const LongType flagStorage) {
|
||||
int maxFlags = 24;
|
||||
int flagsArray[] = {
|
||||
ARRAY_SPARSE,
|
||||
ARRAY_COMPRESSED,
|
||||
ARRAY_EMPTY,
|
||||
ARRAY_RAGGED,
|
||||
ARRAY_CSR,
|
||||
ARRAY_CSC,
|
||||
ARRAY_COO,
|
||||
ARRAY_COMPLEX,
|
||||
ARRAY_QUANTIZED,
|
||||
ARRAY_HALF,
|
||||
ARRAY_BHALF,
|
||||
ARRAY_FLOAT,
|
||||
ARRAY_DOUBLE,
|
||||
ARRAY_CHAR,
|
||||
ARRAY_SHORT,
|
||||
ARRAY_INT,
|
||||
ARRAY_LONG,
|
||||
ARRAY_BOOL,
|
||||
ARRAY_UTF8,
|
||||
ARRAY_UTF16,
|
||||
ARRAY_UTF32,
|
||||
ARRAY_EXTRAS,
|
||||
ARRAY_UNSIGNED,
|
||||
ARRAY_HAS_PADDED_BUFFER,
|
||||
ARRAY_IS_VIEW
|
||||
};
|
||||
|
||||
const char* flagsStrings[] = {
|
||||
"ARRAY_SPARSE",
|
||||
"ARRAY_COMPRESSED",
|
||||
"ARRAY_EMPTY",
|
||||
"ARRAY_RAGGED",
|
||||
"ARRAY_CSR",
|
||||
"ARRAY_CSC",
|
||||
"ARRAY_COO",
|
||||
"ARRAY_COMPLEX",
|
||||
"ARRAY_QUANTIZED",
|
||||
"ARRAY_HALF",
|
||||
"ARRAY_BHALF",
|
||||
"ARRAY_FLOAT",
|
||||
"ARRAY_DOUBLE",
|
||||
"ARRAY_CHAR",
|
||||
"ARRAY_SHORT",
|
||||
"ARRAY_INT",
|
||||
"ARRAY_LONG",
|
||||
"ARRAY_BOOL",
|
||||
"ARRAY_UTF8",
|
||||
"ARRAY_UTF16",
|
||||
"ARRAY_UTF32",
|
||||
"ARRAY_EXTRAS",
|
||||
"ARRAY_UNSIGNED",
|
||||
"ARRAY_HAS_PADDED_BUFFER",
|
||||
"ARRAY_IS_VIEW"
|
||||
};
|
||||
|
||||
std::string flags;
|
||||
for (int i = 0; i < maxFlags; i++) {
|
||||
if (hasPropertyBitSetForFlags(flagStorage, flagsArray[i])) {
|
||||
flags += flagsStrings[i];
|
||||
flags += " ";
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
auto ret = new std::string(flags); // Returns the number of set flags found
|
||||
return ret->c_str();
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE void ArrayOptions::unsetAllFlags(sd::LongType& flagStorage) {
|
||||
|
||||
int flagsArray[] = {
|
||||
ARRAY_SPARSE,
|
||||
ARRAY_COMPRESSED,
|
||||
ARRAY_EMPTY,
|
||||
ARRAY_RAGGED,
|
||||
ARRAY_CSR,
|
||||
ARRAY_CSC,
|
||||
ARRAY_COO,
|
||||
ARRAY_COMPLEX,
|
||||
ARRAY_QUANTIZED,
|
||||
ARRAY_HALF,
|
||||
ARRAY_BHALF,
|
||||
ARRAY_FLOAT,
|
||||
ARRAY_DOUBLE,
|
||||
ARRAY_CHAR,
|
||||
ARRAY_SHORT,
|
||||
ARRAY_INT,
|
||||
ARRAY_LONG,
|
||||
ARRAY_BOOL,
|
||||
ARRAY_UTF8,
|
||||
ARRAY_UTF16,
|
||||
ARRAY_UTF32,
|
||||
ARRAY_EXTRAS,
|
||||
ARRAY_UNSIGNED,
|
||||
ARRAY_HAS_PADDED_BUFFER
|
||||
};
|
||||
|
||||
for (int i = 0; i < 24; i++) {
|
||||
unsetPropertyBitForFlags(flagStorage, flagsArray[i]);
|
||||
}
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE const char *ArrayOptions::enumerateSetFlags(const sd::LongType *shapeInfo) {
|
||||
return enumerateSetFlagsForFlags(shapeInfo[ArrayOptions::extraIndex(shapeInfo)]);
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE void ArrayOptions::unsetAllFlags(sd::LongType *shapeInfo) {
|
||||
ArrayOptions::unsetAllFlags(shapeInfo[ArrayOptions::extraIndex(shapeInfo)]);
|
||||
}
|
||||
|
||||
|
||||
SD_HOST SD_INLINE bool ArrayOptions::isUnsigned(sd::LongType *shapeInfo) {
|
||||
if (!isNewFormat(shapeInfo)) return false;
|
||||
|
||||
return hasPropertyBitSet(shapeInfo, ARRAY_UNSIGNED);
|
||||
}
|
||||
|
||||
|
||||
|
||||
#define DATA_TYPE_FLAGS { \
|
||||
ARRAY_FLOAT, \
|
||||
ARRAY_DOUBLE, \
|
||||
ARRAY_HALF, \
|
||||
ARRAY_BHALF, \
|
||||
ARRAY_BOOL, \
|
||||
ARRAY_CHAR, \
|
||||
ARRAY_SHORT, \
|
||||
ARRAY_INT, \
|
||||
ARRAY_LONG, \
|
||||
ARRAY_UTF8, \
|
||||
ARRAY_UTF16, \
|
||||
ARRAY_UTF32 \
|
||||
}
|
||||
|
||||
#define DATA_TYPES { \
|
||||
sd::DataType::FLOAT32, \
|
||||
sd::DataType::DOUBLE, \
|
||||
sd::DataType::HALF, \
|
||||
sd::DataType::BFLOAT16, \
|
||||
sd::DataType::BOOL, \
|
||||
sd::DataType::INT8, \
|
||||
sd::DataType::INT16, \
|
||||
sd::DataType::INT32, \
|
||||
sd::DataType::INT64, \
|
||||
sd::DataType::UTF8, \
|
||||
sd::DataType::UTF16, \
|
||||
sd::DataType::UTF32 \
|
||||
}
|
||||
|
||||
#define ARRAY_UNSIGNED_TYPES { \
|
||||
ARRAY_CHAR, \
|
||||
ARRAY_SHORT, \
|
||||
ARRAY_INT, \
|
||||
ARRAY_LONG, \
|
||||
ARRAY_UTF8, \
|
||||
ARRAY_UTF16, \
|
||||
ARRAY_UTF32 \
|
||||
}
|
||||
|
||||
#define UNSIGNED_DATA_TYPES { \
|
||||
sd::DataType::UINT8, \
|
||||
sd::DataType::UINT16, \
|
||||
sd::DataType::UINT32, \
|
||||
sd::DataType::UINT64, \
|
||||
sd::DataType::UTF8, \
|
||||
sd::DataType::UTF16, \
|
||||
sd::DataType::UTF32 \
|
||||
}
|
||||
|
||||
|
||||
SD_HOST SD_INLINE sd::DataType ArrayOptions::dataTypeValue(sd::LongType property) {
|
||||
const sd::LongType dataTypeFlags[] = DATA_TYPE_FLAGS;
|
||||
const sd::DataType dataTypes[] = DATA_TYPES;
|
||||
const size_t numTypes = sizeof(dataTypeFlags) / sizeof(sd::LongType);
|
||||
|
||||
|
||||
if (hasPropertyBitSetForFlags(property, ARRAY_UNSIGNED)) {
|
||||
const sd::LongType unsignedTypeFlags[] = ARRAY_UNSIGNED_TYPES;
|
||||
const sd::DataType unsignedDataTypes[] = UNSIGNED_DATA_TYPES;
|
||||
const size_t numUnsignedTypes = sizeof(unsignedTypeFlags) / sizeof(sd::LongType);
|
||||
|
||||
for (size_t i = 0; i < numUnsignedTypes; ++i) {
|
||||
if (hasPropertyBitSetForFlags(property, unsignedTypeFlags[i])) {
|
||||
return unsignedDataTypes[i];
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (size_t i = 0; i < numTypes; ++i) {
|
||||
if (hasPropertyBitSetForFlags(property, dataTypeFlags[i])) {
|
||||
return dataTypes[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return sd::DataType::UNKNOWN;
|
||||
}
|
||||
|
||||
|
||||
|
||||
SD_HOST SD_INLINE void validateFlags(sd::LongType property, const sd::LongType flags[], size_t numFlags) {
|
||||
LongType *flagIndices = new LongType[numFlags];
|
||||
int numFlagsSet = 0;
|
||||
for (size_t i = 0; i < numFlags; ++i) {
|
||||
if (hasPropertyBitSetForFlags(property, flags[i])) {
|
||||
flagIndices[i] = 1;
|
||||
numFlagsSet++;
|
||||
} else {
|
||||
flagIndices[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (numFlagsSet > 1) {
|
||||
std::ostringstream errorMsg;
|
||||
errorMsg << "Multiple data types are set for the given property: ";
|
||||
for (size_t i = 0; i < numFlags; i++) {
|
||||
if(flagIndices[i] == 1) {
|
||||
errorMsg << "Flag index " << i << " (flag value: " << flags[i] << "), ";
|
||||
}
|
||||
}
|
||||
errorMsg << "Total: " << numFlagsSet << " data types set.";
|
||||
THROW_EXCEPTION(errorMsg.str().c_str());
|
||||
}
|
||||
|
||||
delete[] flagIndices;
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE void ArrayOptions::validateSingleDataType(sd::LongType property) {
|
||||
const sd::LongType dataTypeFlags[] = DATA_TYPE_FLAGS;
|
||||
const size_t numDataTypeFlags = sizeof(dataTypeFlags) / sizeof(sd::LongType);
|
||||
validateFlags(property, dataTypeFlags, numDataTypeFlags);
|
||||
|
||||
if (hasPropertyBitSetForFlags(property, ARRAY_UNSIGNED)) {
|
||||
const sd::LongType unsignedTypeFlags[] = ARRAY_UNSIGNED_TYPES;
|
||||
const size_t numUnsignedTypeFlags = sizeof(unsignedTypeFlags) / sizeof(sd::LongType);
|
||||
validateFlags(property, unsignedTypeFlags, numUnsignedTypeFlags);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
SD_HOST SD_INLINE sd::LongType ArrayOptions::numDataTypesSet(sd::LongType property) {
|
||||
const sd::LongType dataTypeFlags[] = DATA_TYPE_FLAGS;
|
||||
const size_t numDataTypeFlags = sizeof(dataTypeFlags) / sizeof(sd::LongType);
|
||||
|
||||
sd::LongType numFlagsSet = 0;
|
||||
for (size_t i = 0; i < numDataTypeFlags; ++i) {
|
||||
if (hasPropertyBitSetForFlags(property, dataTypeFlags[i])) {
|
||||
numFlagsSet++;
|
||||
}
|
||||
}
|
||||
|
||||
return numFlagsSet;
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE sd::DataType ArrayOptions::dataType(const sd::LongType *shapeInfo) {
|
||||
// Return safe default instead of throwing - prevents SIGABRT crashes
|
||||
if(shapeInfo == nullptr)
|
||||
return DataType::FLOAT32; // Safe default for uninitialized arrays
|
||||
|
||||
auto extra = ArrayOptions::extra(shapeInfo);
|
||||
return ArrayOptions::dataTypeValue(extra);
|
||||
}
|
||||
|
||||
|
||||
|
||||
SD_HOST SD_INLINE SpaceType ArrayOptions::spaceTypeForFlags(const sd::LongType& flagStorage) {
|
||||
if (hasPropertyBitSetForFlags(flagStorage, ARRAY_QUANTIZED)) return SpaceType::QUANTIZED;
|
||||
if (hasPropertyBitSetForFlags(flagStorage, ARRAY_COMPLEX)) return SpaceType::COMPLEX;
|
||||
return SpaceType::CONTINUOUS; // by default we return continuous type here
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE ArrayType ArrayOptions::arrayTypeForFlags(const sd::LongType& flagStorage) {
|
||||
if (hasPropertyBitSetForFlags(flagStorage, ARRAY_SPARSE)) return ArrayType::SPARSE;
|
||||
if (hasPropertyBitSetForFlags(flagStorage, ARRAY_COMPRESSED)) return ArrayType::COMPRESSED;
|
||||
if (hasPropertyBitSetForFlags(flagStorage, ARRAY_EMPTY)) return ArrayType::EMPTY;
|
||||
if (hasPropertyBitSetForFlags(flagStorage, ARRAY_RAGGED)) return ArrayType::RAGGED;
|
||||
return ArrayType::DENSE; // by default we return DENSE type here
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE bool ArrayOptions::togglePropertyBitForFlags(sd::LongType& flagStorage, LongType property) {
|
||||
flagStorage ^= property;
|
||||
return hasPropertyBitSetForFlags(flagStorage, property);
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE sd::LongType ArrayOptions::unsetPropertyBitForFlags(sd::LongType& flagStorage, LongType property) {
|
||||
return flagStorage & ~property;
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE SparseType ArrayOptions::sparseTypeForFlags(const sd::LongType& flagStorage) {
|
||||
if (hasPropertyBitSetForFlags(flagStorage, ARRAY_CSC)) return SparseType::CSC;
|
||||
if (hasPropertyBitSetForFlags(flagStorage, ARRAY_CSR)) return SparseType::CSR;
|
||||
if (hasPropertyBitSetForFlags(flagStorage, ARRAY_COO)) return SparseType::COO;
|
||||
return SparseType::LIL;
|
||||
}
|
||||
|
||||
// Existing function that works with shapeInfo:
|
||||
SD_HOST_DEVICE SD_INLINE SpaceType ArrayOptions::spaceType(const sd::LongType *shapeInfo) {
|
||||
return spaceTypeForFlags(shapeInfo[ArrayOptions::extraIndex(shapeInfo)]);
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE ArrayType ArrayOptions::arrayType(const sd::LongType *shapeInfo) {
|
||||
return arrayTypeForFlags(shapeInfo[ArrayOptions::extraIndex(shapeInfo)]);
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE ArrayType ArrayOptions::arrayType(sd::LongType *shapeInfo) {
|
||||
return arrayTypeForFlags(shapeInfo[ArrayOptions::extraIndex(shapeInfo)]);
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE bool ArrayOptions::isEmpty(sd::LongType *shapeInfo) {
|
||||
return hasPropertyBitSet(shapeInfo, EMPTY);
|
||||
}
|
||||
|
||||
|
||||
SD_HOST SD_INLINE bool ArrayOptions::arrayNeedsCopy(LongType *shapeInfo) {
|
||||
return hasPropertyBitSetForFlags(shapeInfo[ArrayOptions::extraIndex(shapeInfo)], ARRAY_NEEDS_COPY);
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE void ArrayOptions::toggleArrayNeedsCopy(LongType *shapeInfo) {
|
||||
togglePropertyBit(shapeInfo, ARRAY_NEEDS_COPY);
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE void ArrayOptions::toggleIsEmpty(sd::LongType *shapeInfo) {
|
||||
togglePropertyBit(shapeInfo, EMPTY);
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE bool ArrayOptions::isView(sd::LongType *shapeInfo) {
|
||||
return hasPropertyBitSet(shapeInfo, ARRAY_IS_VIEW);
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE void ArrayOptions::toggleIsView(sd::LongType *shapeInfo) {
|
||||
togglePropertyBit(shapeInfo, ARRAY_IS_VIEW);
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE bool ArrayOptions::togglePropertyBit(sd::LongType *shapeInfo, LongType property) {
|
||||
return togglePropertyBitForFlags(shapeInfo[ArrayOptions::extraIndex(shapeInfo)], property);
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE void ArrayOptions::setPropertyBit(sd::LongType *shapeInfo, LongType property) {
|
||||
shapeInfo[ArrayOptions::extraIndex(shapeInfo)] = setPropertyBitForFlagsValue(shapeInfo[ArrayOptions::extraIndex(shapeInfo)], property);
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE void ArrayOptions::unsetPropertyBit(sd::LongType *shapeInfo, LongType property) {
|
||||
shapeInfo[ArrayOptions::extraIndex(shapeInfo)] = unsetPropertyBitForFlags(shapeInfo[ArrayOptions::extraIndex(shapeInfo)], property);
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE SparseType ArrayOptions::sparseType(const sd::LongType *shapeInfo) {
|
||||
return sparseTypeForFlags(shapeInfo[ArrayOptions::extraIndex(shapeInfo)]);
|
||||
}
|
||||
SD_HOST SD_INLINE void ArrayOptions::setPropertyBits(sd::LongType *shapeInfo, std::initializer_list<LongType> properties) {
|
||||
for (auto v : properties) {
|
||||
if (!hasPropertyBitSet(shapeInfo, v)) setPropertyBit(shapeInfo, v);
|
||||
}
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE void ArrayOptions::flagAsPaddedBuffer(sd::LongType *shapeInfo) {
|
||||
if (!isNewFormat(shapeInfo)) return;
|
||||
|
||||
return setPropertyBit(shapeInfo, ARRAY_HAS_PADDED_BUFFER);
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE bool ArrayOptions::hasPaddedBuffer(const sd::LongType *shapeInfo) {
|
||||
if (!isNewFormat(shapeInfo)) return false;
|
||||
|
||||
return hasPropertyBitSet(shapeInfo, ARRAY_HAS_PADDED_BUFFER);
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE sd::LongType ArrayOptions::propertyWithoutDataTypeValue(sd::LongType extra) {
|
||||
sd::LongType property = extra;
|
||||
property = property & (~ARRAY_BOOL);
|
||||
property = property & (~ARRAY_HALF);
|
||||
property = property & (~ARRAY_BHALF);
|
||||
property = property & (~ARRAY_FLOAT);
|
||||
property = property & (~ARRAY_DOUBLE);
|
||||
property = property & (~ARRAY_INT);
|
||||
property = property & (~ARRAY_LONG);
|
||||
property = property & (~ARRAY_CHAR);
|
||||
property = property & (~ARRAY_SHORT);
|
||||
property = property & (~ARRAY_UNSIGNED);
|
||||
return property;
|
||||
}
|
||||
|
||||
|
||||
SD_HOST SD_INLINE sd::LongType ArrayOptions::propertyWithoutDataType(const sd::LongType *shapeInfo) {
|
||||
auto newCast = const_cast<sd::LongType *>(shapeInfo);
|
||||
sd::LongType property = extra(newCast);
|
||||
return propertyWithoutDataTypeValue(property);
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE void ArrayOptions::resetDataType(sd::LongType *shapeInfo) {
|
||||
setExtra(shapeInfo, propertyWithoutDataType(shapeInfo));
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE LongType ArrayOptions::flagForDataType(const sd::DataType dataType) {
|
||||
switch (dataType) {
|
||||
case sd::DataType::BOOL:
|
||||
return ARRAY_BOOL;
|
||||
case sd::DataType::HALF:
|
||||
return ARRAY_HALF;
|
||||
case sd::DataType::BFLOAT16:
|
||||
return ARRAY_BHALF;
|
||||
case sd::DataType::FLOAT32:
|
||||
return ARRAY_FLOAT;
|
||||
case sd::DataType::DOUBLE:
|
||||
return ARRAY_DOUBLE;
|
||||
case sd::DataType::INT8:
|
||||
return ARRAY_CHAR;
|
||||
case sd::DataType::INT16:
|
||||
return ARRAY_SHORT;
|
||||
case sd::DataType::INT32:
|
||||
return ARRAY_INT;
|
||||
case sd::DataType::INT64:
|
||||
return ARRAY_LONG;
|
||||
case sd::DataType::UINT8:
|
||||
return ARRAY_CHAR | ARRAY_UNSIGNED;
|
||||
case sd::DataType::UINT16:
|
||||
return ARRAY_SHORT | ARRAY_UNSIGNED;
|
||||
case sd::DataType::UINT32 :
|
||||
return ARRAY_INT | ARRAY_UNSIGNED;
|
||||
case sd::DataType::UINT64 :
|
||||
return ARRAY_LONG | ARRAY_UNSIGNED;
|
||||
case sd::DataType::UTF8:
|
||||
return ARRAY_UTF8;
|
||||
case sd::DataType::UTF16:
|
||||
return ARRAY_UTF16;
|
||||
case sd::DataType::UTF32:
|
||||
return ARRAY_UTF32;
|
||||
default:
|
||||
#ifndef __CUDA_ARCH__
|
||||
std::string errorMessage;
|
||||
errorMessage += "Can't set unknown data type ArrayOptions: ";
|
||||
errorMessage += sd::DataTypeUtils::asString(dataType);
|
||||
THROW_EXCEPTION(errorMessage.c_str());
|
||||
return 0; // Never reached, but satisfies compiler warning
|
||||
|
||||
#else
|
||||
printf("Can't set unknown data type");
|
||||
return 0; // Return sentinel value for unknown types in CUDA code
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE void ArrayOptions::setDataType(sd::LongType *shapeInfo, const sd::DataType dataType) {
|
||||
switch (dataType) {
|
||||
case sd::DataType::BOOL:
|
||||
ArrayOptions::resetDataType(shapeInfo);
|
||||
setPropertyBit(shapeInfo, ARRAY_BOOL);
|
||||
break;
|
||||
case sd::DataType::HALF:
|
||||
ArrayOptions::resetDataType(shapeInfo);
|
||||
setPropertyBit(shapeInfo, ARRAY_HALF);
|
||||
break;
|
||||
case sd::DataType::BFLOAT16:
|
||||
ArrayOptions::resetDataType(shapeInfo);
|
||||
setPropertyBit(shapeInfo, ARRAY_BHALF);
|
||||
break;
|
||||
case sd::DataType::FLOAT32:
|
||||
ArrayOptions::resetDataType(shapeInfo);
|
||||
setPropertyBit(shapeInfo, ARRAY_FLOAT);
|
||||
break;
|
||||
case sd::DataType::DOUBLE:
|
||||
ArrayOptions::resetDataType(shapeInfo);
|
||||
setPropertyBit(shapeInfo, ARRAY_DOUBLE);
|
||||
break;
|
||||
case sd::DataType::INT8:
|
||||
ArrayOptions::resetDataType(shapeInfo);
|
||||
setPropertyBit(shapeInfo, ARRAY_CHAR);
|
||||
break;
|
||||
case sd::DataType::INT16:
|
||||
ArrayOptions::resetDataType(shapeInfo);
|
||||
setPropertyBit(shapeInfo, ARRAY_SHORT);
|
||||
break;
|
||||
case sd::DataType::INT32:
|
||||
ArrayOptions::resetDataType(shapeInfo);
|
||||
setPropertyBit(shapeInfo, ARRAY_INT);
|
||||
break;
|
||||
case sd::DataType::INT64:
|
||||
ArrayOptions::resetDataType(shapeInfo);
|
||||
setPropertyBit(shapeInfo, ARRAY_LONG);
|
||||
break;
|
||||
case sd::DataType::UINT8:
|
||||
ArrayOptions::resetDataType(shapeInfo);
|
||||
setPropertyBit(shapeInfo, ARRAY_CHAR | ARRAY_UNSIGNED);
|
||||
break;
|
||||
case sd::DataType::UINT16:
|
||||
ArrayOptions::resetDataType(shapeInfo);
|
||||
setPropertyBit(shapeInfo, ARRAY_SHORT | ARRAY_UNSIGNED);
|
||||
break;
|
||||
case sd::DataType::UINT32:
|
||||
ArrayOptions::resetDataType(shapeInfo);
|
||||
setPropertyBit(shapeInfo, ARRAY_INT | ARRAY_UNSIGNED);
|
||||
break;
|
||||
case sd::DataType::UINT64:
|
||||
ArrayOptions::resetDataType(shapeInfo);
|
||||
setPropertyBit(shapeInfo, ARRAY_LONG | ARRAY_UNSIGNED);
|
||||
break;
|
||||
case sd::DataType::UTF8:
|
||||
ArrayOptions::resetDataType(shapeInfo);
|
||||
setPropertyBit(shapeInfo, ARRAY_UTF8);
|
||||
break;
|
||||
case sd::DataType::UTF16:
|
||||
ArrayOptions::resetDataType(shapeInfo);
|
||||
setPropertyBit(shapeInfo, ARRAY_UTF16);
|
||||
break;
|
||||
case sd::DataType::UTF32:
|
||||
ArrayOptions::resetDataType(shapeInfo);
|
||||
setPropertyBit(shapeInfo, ARRAY_UTF32);
|
||||
break;
|
||||
default:
|
||||
#ifndef __CUDA_ARCH__
|
||||
std::string errorMessage;
|
||||
errorMessage += "Can't set unknown data type: ";
|
||||
errorMessage += DataTypeUtils::asString(dataType);
|
||||
THROW_EXCEPTION(errorMessage.c_str());
|
||||
#else
|
||||
printf("Can't set unknown data type");
|
||||
#endif
|
||||
|
||||
validateSingleDataType(shapeInfo[ArrayOptions::extraIndex(shapeInfo)]);
|
||||
|
||||
}
|
||||
|
||||
#ifndef __CUDA_ARCH__
|
||||
if(ArrayOptions::dataType(shapeInfo) != dataType) {
|
||||
std::string errorMessage;
|
||||
errorMessage += "setDataType: Data type set was not correct one. Expected ";
|
||||
errorMessage += DataTypeUtils::asString(dataType);
|
||||
errorMessage += " but got ";
|
||||
errorMessage += sd::DataTypeUtils::asString(dataType);
|
||||
THROW_EXCEPTION(errorMessage.c_str());
|
||||
}
|
||||
|
||||
#else
|
||||
printf("setDataType: Data type set was incorrect.");
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
SD_HOST SD_INLINE sd::LongType ArrayOptions::setDataTypeValue(sd::LongType extraStorage, const sd::DataType dataType) {
|
||||
sd::LongType ret = extraStorage;
|
||||
if (dataType == sd::DataType::UINT8
|
||||
|| dataType == sd::DataType::UINT16
|
||||
|| dataType == sd::DataType::UINT32 ||
|
||||
dataType == sd::DataType::UINT64) {
|
||||
ret = setPropertyBitForFlagsValue(extraStorage, ARRAY_UNSIGNED);
|
||||
extraStorage = ret;
|
||||
return extraStorage;
|
||||
}
|
||||
|
||||
|
||||
switch (dataType) {
|
||||
case sd::DataType::BOOL:
|
||||
ret = setPropertyBitForFlagsValue(extraStorage, ARRAY_BOOL);
|
||||
break;
|
||||
case sd::DataType::HALF:
|
||||
ret = setPropertyBitForFlagsValue(extraStorage, ARRAY_HALF);
|
||||
break;
|
||||
case sd::DataType::BFLOAT16:
|
||||
ret = setPropertyBitForFlagsValue(extraStorage, ARRAY_BHALF);
|
||||
break;
|
||||
case sd::DataType::FLOAT32:
|
||||
ret = setPropertyBitForFlagsValue(extraStorage, ARRAY_FLOAT);
|
||||
break;
|
||||
case sd::DataType::DOUBLE:
|
||||
ret = setPropertyBitForFlagsValue(extraStorage, ARRAY_DOUBLE);
|
||||
break;
|
||||
case sd::DataType::INT8:
|
||||
ret = setPropertyBitForFlagsValue(extraStorage, ARRAY_CHAR);
|
||||
break;
|
||||
case sd::DataType::INT16:
|
||||
ret = setPropertyBitForFlagsValue(extraStorage, ARRAY_SHORT);
|
||||
break;
|
||||
case sd::DataType::INT32:
|
||||
ret = setPropertyBitForFlagsValue(extraStorage, ARRAY_INT);
|
||||
break;
|
||||
case sd::DataType::INT64:
|
||||
ret = setPropertyBitForFlagsValue(extraStorage, ARRAY_LONG);
|
||||
break;
|
||||
case sd::DataType::UINT8:
|
||||
ret = setPropertyBitForFlagsValue(extraStorage, ARRAY_CHAR);
|
||||
break;
|
||||
case sd::DataType::UINT16:
|
||||
ret = setPropertyBitForFlagsValue(extraStorage, ARRAY_SHORT);
|
||||
break;
|
||||
case sd::DataType::UINT32:
|
||||
ret = setPropertyBitForFlagsValue(extraStorage, ARRAY_INT);
|
||||
break;
|
||||
case sd::DataType::UINT64:
|
||||
ret = setPropertyBitForFlagsValue(extraStorage, ARRAY_LONG);
|
||||
break;
|
||||
case sd::DataType::UTF8:
|
||||
ret = setPropertyBitForFlagsValue(extraStorage, ARRAY_UTF8);
|
||||
break;
|
||||
case sd::DataType::UTF16:
|
||||
ret = setPropertyBitForFlagsValue(extraStorage, ARRAY_UTF16);
|
||||
break;
|
||||
case sd::DataType::UTF32:
|
||||
ret = setPropertyBitForFlagsValue(extraStorage, ARRAY_UTF32);
|
||||
break;
|
||||
default:
|
||||
#ifndef __CUDA_ARCH__
|
||||
THROW_EXCEPTION("Can't set unknown data type");
|
||||
#else
|
||||
printf("Can't set unknown data type");
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
|
||||
return ret;
|
||||
|
||||
}
|
||||
|
||||
SD_HOST sd::LongType ArrayOptions::defaultFlag() {
|
||||
return DEFAULT_FLAG;
|
||||
}
|
||||
|
||||
SD_HOST void ArrayOptions::resetFlags(sd::LongType *to) {
|
||||
to[ArrayOptions::extraIndex(to)] = 1;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
SD_HOST SD_INLINE void ArrayOptions::copyDataType(sd::LongType *to, const sd::LongType *from) {
|
||||
if(to == nullptr)
|
||||
THROW_EXCEPTION("To Shape info was null!");
|
||||
if(from == nullptr)
|
||||
THROW_EXCEPTION("From Shape info was null!");
|
||||
DataType dt = dataType(from);
|
||||
sd::LongType flagForDt = flagForDataType(dt);
|
||||
if(hasPropertyBitSet(to, flagForDt))
|
||||
return;
|
||||
setDataType(to, dt);
|
||||
}
|
||||
SD_HOST sd::LongType ArrayOptions::setPropertyBitForFlagsValue(LongType extraStorage, LongType property) {
|
||||
if(hasPropertyBitSet(extraStorage, property))
|
||||
return extraStorage;
|
||||
return extraStorage | property;
|
||||
}
|
||||
|
||||
// New method implementations to add to ArrayOptions.hXX
|
||||
|
||||
// needsCopy - const overload to check if array needs copy
|
||||
SD_HOST SD_INLINE bool ArrayOptions::needsCopy(const LongType *shapeInfo) {
|
||||
return hasPropertyBitSet(shapeInfo, ARRAY_NEEDS_COPY);
|
||||
}
|
||||
|
||||
// hasCopyOffset - check if specific input index has copy offset flag set
|
||||
SD_HOST SD_INLINE bool ArrayOptions::hasCopyOffset(const LongType *shapeInfo, int inputIndex) {
|
||||
if (inputIndex < 0 || inputIndex > 10) {
|
||||
return false;
|
||||
}
|
||||
LongType flag = copyOffsetFlagForInput(inputIndex);
|
||||
return hasPropertyBitSet(shapeInfo, flag);
|
||||
}
|
||||
|
||||
// toggleCopyOffset - toggle copy offset flag for specific input index
|
||||
SD_HOST SD_INLINE void ArrayOptions::toggleCopyOffset(LongType *shapeInfo, int inputIndex) {
|
||||
if (inputIndex < 0 || inputIndex > 10) {
|
||||
#ifndef __CUDA_ARCH__
|
||||
THROW_EXCEPTION("Input index out of range [0-10]");
|
||||
#else
|
||||
printf("Input index out of range [0-10]\n");
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
LongType flag = copyOffsetFlagForInput(inputIndex);
|
||||
togglePropertyBit(shapeInfo, flag);
|
||||
}
|
||||
|
||||
// copyOffsetFlagForInput - get the flag constant for a specific input index
|
||||
SD_HOST SD_INLINE LongType ArrayOptions::copyOffsetFlagForInput(int inputIndex) {
|
||||
switch (inputIndex) {
|
||||
case 0: return ARRAY_COPY_OFFSET_INPUT_0;
|
||||
case 1: return ARRAY_COPY_OFFSET_INPUT_1;
|
||||
case 2: return ARRAY_COPY_OFFSET_INPUT_2;
|
||||
case 3: return ARRAY_COPY_OFFSET_INPUT_3;
|
||||
case 4: return ARRAY_COPY_OFFSET_INPUT_4;
|
||||
case 5: return ARRAY_COPY_OFFSET_INPUT_5;
|
||||
case 6: return ARRAY_COPY_OFFSET_INPUT_6;
|
||||
case 7: return ARRAY_COPY_OFFSET_INPUT_7;
|
||||
case 8: return ARRAY_COPY_OFFSET_INPUT_8;
|
||||
case 9: return ARRAY_COPY_OFFSET_INPUT_9;
|
||||
case 10: return ARRAY_COPY_OFFSET_INPUT_10;
|
||||
default:
|
||||
#ifndef __CUDA_ARCH__
|
||||
THROW_EXCEPTION("Invalid input index for copy offset flag");
|
||||
#else
|
||||
printf("Invalid input index for copy offset flag\n");
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
// clearAllCopyOffsets - clear all 11 copy offset flags at once
|
||||
SD_HOST SD_INLINE void ArrayOptions::clearAllCopyOffsets(LongType *shapeInfo) {
|
||||
for (int i = 0; i <= 10; i++) {
|
||||
LongType flag = copyOffsetFlagForInput(i);
|
||||
if (hasPropertyBitSet(shapeInfo, flag)) {
|
||||
unsetPropertyBit(shapeInfo, flag);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// getActiveCopyOffsets - return count or bitmask of which inputs have offset flags set
|
||||
SD_HOST SD_INLINE int ArrayOptions::getActiveCopyOffsets(const LongType *shapeInfo) {
|
||||
int count = 0;
|
||||
for (int i = 0; i <= 10; i++) {
|
||||
LongType flag = copyOffsetFlagForInput(i);
|
||||
if (hasPropertyBitSet(shapeInfo, flag)) {
|
||||
count++;
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
// isView - const overload for consistency
|
||||
SD_HOST SD_INLINE bool ArrayOptions::isView(const LongType *shapeInfo) {
|
||||
return hasPropertyBitSet(shapeInfo, ARRAY_IS_VIEW);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
Reference in New Issue
Block a user