aclnnEqScalar&aclnnInplaceEqScalar
Applicable Products
| Product | Supported |
|---|---|
| √ | |
| √ | |
| √ | |
| × | |
| × | |
| √ |
Function
Description: Compares whether the value of each element in self is equal to the value of other, and writes the comparison result of each element in self with the value of other into out.
Formula:
Function Prototype
aclnnEqScalar and aclnnInplaceEqScalar implement the same functionality. The differences in usage are as follows. Select the appropriate operator based on your actual scenario.
aclnnEqScalar: Requires creating a new output tensor object to store the computation result.
aclnnInplaceEqScalar: Does not require creating a new output tensor object. The computation result is stored directly in the memory of the input tensor.
Each operator uses a two-phase API. You must first call the "aclnnEqScalarGetWorkspaceSize" or "aclnnInplaceEqScalarGetWorkspaceSize" API to obtain the workspace size required for computation and the executor that encapsulates the operator computation process, and then call the "aclnnEqScalar" or "aclnnInplaceEqScalar" API to perform the computation.
aclnnStatus aclnnEqScalarGetWorkspaceSize(
const aclTensor *self,
const aclScalar *other,
aclTensor *out,
uint64_t *workspaceSize,
aclOpExecutor **executor)aclnnStatus aclnnEqScalar(
void* workspace,
uint64_t workspaceSize,
aclOpExecutor* executor,
const aclrtStream stream)aclnnStatus aclnnInplaceEqScalarGetWorkspaceSize(
const aclTensor *selfRef,
const aclScalar *other,
uint64_t *workspaceSize,
aclOpExecutor **executor)aclnnStatus aclnnInplaceEqScalar(
void *workspace,
uint64_t workspaceSize,
aclOpExecutor *executor,
aclrtStream stream)aclnnEqScalarGetWorkspaceSize
Parameters:
Ascend 950PR/Ascend 950DT :self and other satisfies the TensorScalar Deduction Relationship.
UINT32 data type is not supported for self and other.
Atlas A2 training products/Atlas A2 inference products ,Atlas A3 training products/Atlas A3 inference products :self and other satisfies the Deduction Relationship.
UINT32 and UINT64 data types are not supported for self and other.
UINT64, UINT32, and UINT16 data types are not supported for out.
Atlas training products :self and other satisfy the Deduction Relationship.
The BFLOAT16 data type is not supported.
UINT64, UINT32, UINT16, and BFLOAT16 data types are not supported for out.
Return value
aclnnStatus: return code. For details, see aclnn Return Codes.
The first-phase API performs input parameter validation and returns an error in the following scenarios:
Return Code Error Code Description ACLNN_ERR_PARAM_NULLPTR 161001 self, other, or out is a null pointer. ACLNN_ERR_PARAM_INVALID 161002 The data type of self, other, or out is not within the supported range. The data types of self and other do not satisfy the data type deduction rule. The shapes of self and out are different. The dimensions of self and out are greater than 8.
aclnnEqScalar
Parameters:
Parameter Input/Output Description workspace Input Address of the workspace memory applied on the Device side. workspaceSize Input Size of the workspace applied on the Device side, obtained through the first-phase API aclnnEqScalarGetWorkspaceSize. executor Input Operator executor, which includes the operator computation process. stream Input Specifies the stream that executes the task. Return value
aclnnStatus: return code. For details, see aclnn Return Codes.
aclnnInplaceEqScalarGetWorkspaceSize
Parameters:
Parameter Input/Output Description Instruction Data Type Data Format Dimension (shape) Non-contiguous Tensor selfRef Input/Output selfRef in the formula. - DOUBLE, FLOAT16, FLOAT, BFLOAT16, INT64, INT32, INT8, UINT8, BOOL, INT16, COMPLEX64, COMPLEX128, UINT32, UINT64 ND No more than 8 dimensions. √ other Input other in the formula. - DOUBLE, FLOAT16, FLOAT, BFLOAT16, INT64, INT32, INT8, UINT8, BOOL, INT16, COMPLEX64, COMPLEX128, UINT32, UINT64 - - - workspaceSize Output Returns the workspace size to be applied on the Device side. - - - - - executor Output Returns the operator executor, which includes the operator computation process. - - - - - Ascend 950PR/Ascend 950DT :selfRef and other satisfy the TensorScalar Deduction Relationship.
The UINT32 data type is not supported for selfRef and other.
Atlas A2 training products/Atlas A2 inference products ,Atlas A3 training products/Atlas A3 inference products :selfRef and other satisfies the Deduction Relationship.
selfRef and other do not support UINT32 or UINT64 data types.
Atlas training products :selfRef and other satisfies the Deduction Relationship.
BFLOAT16 data type is not supported.
Return value
aclnnStatus: return code. For details, see aclnn Return Codes.
The first-phase API performs input parameter validation and returns an error in the following scenarios:
Return Code Error Code Description ACLNN_ERR_PARAM_NULLPTR 161001 When the input selfRef and other are null pointers. ACLNN_ERR_PARAM_INVALID 161002 The data type of selfRef and other is not within the supported range. The data type of selfRef and other does not satisfy the data type deduction rules. The number of dimensions of selfRef is greater than 8.
aclnnInplaceEqScalar
Parameters:
Parameter Input/Output Description workspace Input Address of the workspace memory applied on the Device side. workspaceSize Input Size of the workspace applied on the Device side, obtained from the first-phase API aclnnInplaceEqScalarGetWorkspaceSize. executor Input Operator executor, which includes the operator computation flow. stream Input Specifies the stream for task execution. Return value
aclnnStatus: return code. For details, see aclnn Return Codes.
Constraints
Deterministic computation:
- aclnnEqScalar&aclnnInplaceEqScalar defaults to a deterministic implementation.
Example
The following provides example code for reference only. For details about compilation and running, see Compile and Run Samples.
aclnnEqScalar sample code:
#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_eq_scalar.h"
#define CHECK_RET(cond, return_expr) \
do { \
if (!(cond)) { \
return_expr; \
} \
} while (0)
#define LOG_PRINT(message, ...) \
do { \
printf(message, ##__VA_ARGS__); \
} while (0)
int64_t GetShapeSize(const std::vector<int64_t>& shape)
{
int64_t shape_size = 1;
for (auto i : shape) {
shape_size *= i;
}
return shape_size;
}
int Init(int32_t deviceId, aclrtStream* stream)
{
// Boilerplate: resource initialization.
auto ret = aclInit(nullptr);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclInit failed. ERROR: %d\n", ret); return ret);
ret = aclrtSetDevice(deviceId);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSetDevice failed. ERROR: %d\n", ret); return ret);
ret = aclrtCreateStream(stream);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateStream failed. ERROR: %d\n", ret); return ret);
return 0;
}
template <typename T>
int CreateAclTensor(
const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr, aclDataType dataType,
aclTensor** tensor)
{
auto size = GetShapeSize(shape) * sizeof(T);
// Call aclrtMalloc to apply for device-side memory.
auto ret = aclrtMalloc(deviceAddr, size, ACL_MEM_MALLOC_HUGE_FIRST);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMalloc failed. ERROR: %d\n", ret); return ret);
// Copy data from the host to the device memory by calling aclrtMemcpy.
ret = aclrtMemcpy(*deviceAddr, size, hostData.data(), size, ACL_MEMCPY_HOST_TO_DEVICE);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMemcpy failed. ERROR: %d\n", ret); return ret);
// Calculate the strides of the contiguous tensor.
std::vector<int64_t> strides(shape.size(), 1);
for (int64_t i = shape.size() - 2; i >= 0; i--) {
strides[i] = shape[i + 1] * strides[i + 1];
}
// Create an aclTensor by calling the aclCreateTensor API.
*tensor = aclCreateTensor(
shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_ND, shape.data(), shape.size(),
*deviceAddr);
return 0;
}
aclError InitAcl(int32_t deviceId, aclrtStream* stream)
{
auto ret = Init(deviceId, stream);
CHECK_RET(ret == 0, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret);
return ACL_SUCCESS;
}
aclError CreateInputs(
std::vector<int64_t>& selfShape, std::vector<int64_t>& outShape, void** selfDeviceAddr, void** outDeviceAddr,
aclTensor** self, aclScalar** other, aclTensor** out)
{
std::vector<double> selfHostData = {0, 1, 1.2, 0.3, 4.1, 5, 1.6, 7};
std::vector<char> outHostData = {0, 0, 0, 0, 0, 0, 0, 0};
double otherValue = 1.2;
// Create the self tensor.
auto ret = CreateAclTensor(selfHostData, selfShape, selfDeviceAddr, aclDataType::ACL_DOUBLE, self);
CHECK_RET(ret == ACL_SUCCESS, return ret);
// Create the other scalar.
*other = aclCreateScalar(&otherValue, aclDataType::ACL_DOUBLE);
CHECK_RET(*other != nullptr, return ret);
// Create the out tensor.
ret = CreateAclTensor(outHostData, outShape, &(*outDeviceAddr), aclDataType::ACL_BOOL, out);
CHECK_RET(ret == ACL_SUCCESS, return ret);
return ACL_SUCCESS;
}
aclError ExecOpApi(
aclTensor* self, aclScalar* other, aclTensor* out, void** workspaceAddrOut, uint64_t& workspaceSize,
void* outDeviceAddr, std::vector<int64_t>& outShape, aclrtStream stream)
{
aclOpExecutor* executor;
// Obtain the workspace size.
auto ret = aclnnEqScalarGetWorkspaceSize(self, other, out, &workspaceSize, &executor);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnEqScalarGetWorkspaceSize failed. ERROR: %d\n", ret); return ret);
// Apply for workspace (release in main).
void* workspaceAddr = nullptr;
if (workspaceSize > 0) {
ret = aclrtMalloc(&workspaceAddr, workspaceSize, ACL_MEM_MALLOC_HUGE_FIRST);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("allocate workspace failed. ERROR: %d\n", ret); return ret);
}
*workspaceAddrOut = workspaceAddr;
// Call the operator.
ret = aclnnEqScalar(workspaceAddr, workspaceSize, executor, stream);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnEqScalar failed. ERROR: %d\n", ret); return ret);
// Synchronize.
ret = aclrtSynchronizeStream(stream);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSynchronizeStream failed. ERROR: %d\n", ret); return ret);
// Copy the output.
auto size = GetShapeSize(outShape);
std::vector<char> resultData(size, 0);
ret = aclrtMemcpy(
resultData.data(), resultData.size() * sizeof(resultData[0]), outDeviceAddr, size * sizeof(char),
ACL_MEMCPY_DEVICE_TO_HOST);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("copy result from device to host failed. ERROR: %d\n", ret); return ret);
for (int64_t i = 0; i < size; i++) {
LOG_PRINT("result[%ld] is: %d\n", i, resultData[i]);
}
return ACL_SUCCESS;
}
int main()
{
int32_t deviceId = 0;
aclrtStream stream;
auto ret = InitAcl(deviceId, &stream);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("InitAcl failed. ERROR: %d\n", ret); return ret);
std::vector<int64_t> selfShape = {4, 2};
std::vector<int64_t> outShape = {4, 2};
void* selfDeviceAddr = nullptr;
void* outDeviceAddr = nullptr;
aclTensor* self = nullptr;
aclScalar* other = nullptr;
aclTensor* out = nullptr;
ret = CreateInputs(selfShape, outShape, &selfDeviceAddr, &outDeviceAddr, &self, &other, &out);
CHECK_RET(ret == ACL_SUCCESS, return ret);
uint64_t workspaceSize = 0;
void* workspaceAddr = nullptr;
ret = ExecOpApi(self, other, out, &workspaceAddr, workspaceSize, outDeviceAddr, outShape, stream);
CHECK_RET(ret == ACL_SUCCESS, return ret);
// Release the tensor/scalar.
aclDestroyTensor(self);
aclDestroyScalar(other);
aclDestroyTensor(out);
// Release the device memory.
aclrtFree(selfDeviceAddr);
aclrtFree(outDeviceAddr);
if (workspaceSize > 0) {
aclrtFree(workspaceAddr);
}
aclrtDestroyStream(stream);
aclrtResetDevice(deviceId);
aclFinalize();
return 0;
}aclnnInplaceEqScalar sample code:
#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_eq_scalar.h"
#define CHECK_RET(cond, return_expr) \
do { \
if (!(cond)) { \
return_expr; \
} \
} while (0)
#define LOG_PRINT(message, ...) \
do { \
printf(message, ##__VA_ARGS__); \
} while (0)
int64_t GetShapeSize(const std::vector<int64_t>& shape)
{
int64_t shapeSize = 1;
for (auto i : shape) {
shapeSize *= i;
}
return shapeSize;
}
int Init(int32_t deviceId, aclrtStream* stream)
{
// Boilerplate: resource initialization.
auto ret = aclInit(nullptr);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclInit failed. ERROR: %d\n", ret); return ret);
ret = aclrtSetDevice(deviceId);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSetDevice failed. ERROR: %d\n", ret); return ret);
ret = aclrtCreateStream(stream);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateStream failed. ERROR: %d\n", ret); return ret);
return 0;
}
template <typename T>
int CreateAclTensor(
const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr, aclDataType dataType,
aclTensor** tensor)
{
auto size = GetShapeSize(shape) * sizeof(T);
// Call aclrtMalloc to apply for device-side memory.
auto ret = aclrtMalloc(deviceAddr, size, ACL_MEM_MALLOC_HUGE_FIRST);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMalloc failed. ERROR: %d\n", ret); return ret);
// Call aclrtMemcpy to copy host-side data to device-side memory.
ret = aclrtMemcpy(*deviceAddr, size, hostData.data(), size, ACL_MEMCPY_HOST_TO_DEVICE);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMemcpy failed. ERROR: %d\n", ret); return ret);
// Calculate the strides of a contiguous tensor.
std::vector<int64_t> strides(shape.size(), 1);
for (int64_t i = shape.size() - 2; i >= 0; i--) {
strides[i] = shape[i + 1] * strides[i + 1];
}
// Call the aclCreateTensor API to create an aclTensor.
*tensor = aclCreateTensor(
shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_ND, shape.data(), shape.size(),
*deviceAddr);
return 0;
}
aclError InitAcl(int32_t deviceId, aclrtStream* stream)
{
auto ret = Init(deviceId, stream);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret);
return ACL_SUCCESS;
}
aclError CreateInputs(std::vector<int64_t>& selfShape, void** selfDeviceAddr, aclTensor** self, aclScalar** other)
{
std::vector<double> selfHostData = {0, 1, 2, 3, 4, 5, 6, 7};
double otherValue = 2.0;
// Create the self aclTensor.
auto ret = CreateAclTensor(selfHostData, selfShape, selfDeviceAddr, aclDataType::ACL_DOUBLE, self);
CHECK_RET(ret == ACL_SUCCESS, return ret);
// Create the other aclScalar.
*other = aclCreateScalar(&otherValue, aclDataType::ACL_DOUBLE);
CHECK_RET(*other != nullptr, return ACL_ERROR_INVALID_PARAM);
return ACL_SUCCESS;
}
aclError ExecOpApi(
aclTensor* self, aclScalar* other, void* selfDeviceAddr, std::vector<int64_t>& selfShape, aclrtStream stream,
void** workspaceAddrOut)
{
uint64_t workspaceSize = 0;
aclOpExecutor* executor;
auto ret = aclnnInplaceEqScalarGetWorkspaceSize(self, other, &workspaceSize, &executor);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnInplaceEqScalarGetWorkspaceSize failed. ERROR: %d\n", ret); return ret);
// Allocate workspace.
void* workspaceAddr = nullptr;
if (workspaceSize > 0) {
ret = aclrtMalloc(&workspaceAddr, workspaceSize, ACL_MEM_MALLOC_HUGE_FIRST);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("allocate workspace failed. ERROR: %d\n", ret); return ret);
}
*workspaceAddrOut = workspaceAddr;
// Execute.
ret = aclnnInplaceEqScalar(workspaceAddr, workspaceSize, executor, stream);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnInplaceEqScalar failed. ERROR: %d\n", ret); return ret);
// Synchronize.
ret = aclrtSynchronizeStream(stream);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSynchronizeStream failed. ERROR: %d\n", ret); return ret);
// Copy the output.
auto size = GetShapeSize(selfShape);
std::vector<double> resultData(size);
ret = aclrtMemcpy(
resultData.data(), resultData.size() * sizeof(resultData[0]), selfDeviceAddr, size * sizeof(resultData[0]),
ACL_MEMCPY_DEVICE_TO_HOST);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("copy result from device to host failed. ERROR: %d\n", ret); return ret);
for (int64_t i = 0; i < size; i++) {
LOG_PRINT("result[%ld] is: %lf\n", i, resultData[i]);
}
return ACL_SUCCESS;
}
int main()
{
int32_t deviceId = 0;
aclrtStream stream;
auto ret = InitAcl(deviceId, &stream);
CHECK_RET(ret == ACL_SUCCESS, return ret);
std::vector<int64_t> selfShape = {4, 2};
void* selfDeviceAddr = nullptr;
aclTensor* self = nullptr;
aclScalar* other = nullptr;
ret = CreateInputs(selfShape, &selfDeviceAddr, &self, &other);
CHECK_RET(ret == ACL_SUCCESS, return ret);
void* workspaceAddr = nullptr;
ret = ExecOpApi(self, other, selfDeviceAddr, selfShape, stream, &workspaceAddr);
CHECK_RET(ret == ACL_SUCCESS, return ret);
// Destroy.
aclDestroyTensor(self);
aclDestroyScalar(other);
aclrtFree(selfDeviceAddr);
if (workspaceAddr != nullptr) {
aclrtFree(workspaceAddr);
}
// Release.
aclrtDestroyStream(stream);
aclrtResetDevice(deviceId);
aclFinalize();
return 0;
}