aclnnIndexFillTensor&aclnnInplaceIndexFillTensor
Applicable Products
| Product | Supported |
|---|---|
| √ | |
| √ | |
| √ | |
| × | |
| × | |
| × |
Function
Description: Along the given dimension dim of the input self, replace the values at the positions specified by index with value.
Example:
Input self is:
[[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]
If dim = 0, index = [0, 2], and value = 0, the operator computes:
[[0, 0, 0],
[4, 5, 6],
[0, 0, 0]]If dim = 1, index = [0, 2], and value = 0, the computation result of the operator is:
[[0, 2, 0],
[0, 5, 0],
[0, 8, 0]]Function Prototype
aclnnIndexFillTensor and aclnnInplaceIndexFillTensor implement the same functionality. The differences are as follows. Select the appropriate operator based on your actual scenario.
aclnnIndexFillTensor: Creates a new output tensor object to store the computation result.
aclnnInplaceIndexFillTensor: Stores the computation result directly in the memory of the input tensor without creating a new output tensor object.
Each operator is divided into a two-phase API. You must first call the "aclnnIndexFillTensorGetWorkspaceSize" or "aclnnInplaceIndexFillTensorGetWorkspaceSize" API to obtain the workspace size required for computation and the executor that contains the operator computation process, and then call the "aclnnIndexFillTensor" or "aclnnInplaceIndexFillTensor" API to execute the computation.
aclnnStatus aclnnIndexFillTensorGetWorkspaceSize(
const aclTensor* self,
int64_t dim,
const aclIntArray* index,
const aclScalar* value,
aclTensor* out,
uint64_t* workspaceSize,
aclOpExecutor** executor)aclnnStatus aclnnIndexFillTensor(
void* workspace,
uint64_t workspaceSize,
aclOpExecutor* executor,
aclrtStream stream)aclnnStatus aclnnInplaceIndexFillTensorGetWorkspaceSize(
aclTensor* selfRef,
int64_t dim,
const aclIntArray* index,
const aclScalar* value,
uint64_t* workspaceSize,
aclOpExecutor** executor)aclnnStatus aclnnInplaceIndexFillTensor(
void* workspace,
uint64_t workspaceSize,
aclOpExecutor* executor,
aclrtStream stream)aclnnIndexFillTensorGetWorkspaceSize
Parameters
Parameter Input/Output Description Instruction Data Type Data Format Dimension (Shape) Non-Contiguous Tensor self Input The self tensor in the function example, i.e., the tensor whose values at specified positions are to be replaced with value. - FLOAT16, FLOAT, INT32, INT64, BOOL, BFLOAT16 ND 0-8 √ dim Input Specifies the dimension of self to be filled. When self is 1- to 8-dimensional, the value range of dim is [-self.dim(), self.dim()). When self is 0-dimensional, the value range of dim is [-1, 1). int64 - - - index Input Specifies the indices to be filled along the dim dimension of self. Each element value must be less than the size of the corresponding dim dimension of self. - - - - value Input Specifies the fill value. Must be convertible to the data type of self. Consistent with self. - - - out Output The specified output tensor. - Consistent with self. ND Consistent with self. √ workspaceSize Output Returns the workspace size to be applied for on the Device side. - - - - - executor Output Returns the op executor, which includes the operator computation flow. - - - - - Return Value
aclnnStatus: return code. For details, see aclnn Return Code.
The first-phase API performs input parameter validation and returns an error in the following scenarios:
Return Value Error Code Description ACLNN_ERR_PARAM_NULLPTR 161001 The input self, index, value, or out is a null pointer. ACLNN_ERR_PARAM_INVALID 161002 The data type of self, index, or value is not within the supported range. The absolute value of dim exceeds the maximum dimension of self or exceeds 8 dimensions. Values in index exceed the maximum value of the dimension specified by self. The shapes of self and out are not equal. The data types of self and out are not equal.
aclnnIndexFillTensor
Parameters
Parameter Input/Output Description workspace Input Device-side application workspace memory address. workspaceSize Input Device-side application workspace size, obtained by the first-phase API aclnnIndexFillTensorGetWorkspaceSize. executor Input The operator executor, which includes the operator computation process. stream Input Specifies the stream for executing the task. Return value
aclnnStatus: return code. For details, see aclnn Return Code.
aclnnInplaceIndexFillTensorGetWorkspaceSize
Parameters
Parameter Input/Output Description Instruction Data Type Data Format Dimension (Shape) Non-Contiguous Tensor selfRef Input Tensor whose values at the specified positions are to be replaced with value. - FLOAT16、FLOAT、INT32、INT64、BOOL、BFLOAT16 ND 0-8 √ dim Input Specifies the dimension along which selfRef is to be filled. When self is 1-8 dimensional, the value range of dim is [-self.dim(), self.dim()). When self is 0-dimensional, the value range of dim is [-1, 1). int64 - - - index Input Specifies the indices along the dim dimension of self to be filled. Each element value must be less than the size of the dim dimension corresponding to selfRef. - - - - value Input Specifies the data value to fill. - Consistent with selfRef. - - - workspaceSize Output Returns the workspace size to be applied for on the device side. - - - - - executor Output Returns the operator executor, which includes the operator computation process. - - - - - Return Value
aclnnStatus: return code. For details, see aclnn Return Code.
The first-phase API performs input parameter validation and returns an error in the following scenarios:
Return Value Error Code Description ACLNN_ERR_PARAM_NULLPTR 161001 The passed selfRef, index, or value is a null pointer. ACLNN_ERR_PARAM_INVALID 161002 The data types of selfRef, index, and value are not within the supported range. The absolute value of dim exceeds the maximum dimension of selfRef or exceeds 8 dimensions. The values in index exceed the maximum value of the dimension specified by dim in selfRef.
aclnnInplaceIndexFillTensor
Parameters
Parameter Input/Output Description workspace Input Device-side application workspace memory address. workspaceSize Input Device-side application workspace size, obtained from the first-phase API aclnnInplaceIndexFillTensorGetWorkspaceSize. Executor Input Operator executor, which includes the operator computation process. stream Input Specifies the stream for executing the task. Return Value
aclnnStatus: return code. For details, see aclnn Return Code.
Constraints
Deterministic computation:
- aclnnIndexFillTensor&aclnnInplaceIndexFillTensor default to a deterministic implementation.
Example
The following provides example code for reference only. For details about compilation and running, see Compile and Run Samples.
Example of aclnnIndexFillTensor:
#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_index_fill_tensor.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 for 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 data from the host side to the 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);
// Compute 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 aclCreateTensor 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;
}
int main() {
// 1. (Boilerplate) Initialize the device/stream. See the acl external API list.
// Fill in the deviceId based on your actual device.
int32_t deviceId = 0;
aclrtStream stream;
auto ret = Init(deviceId, &stream);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret);
// 2. Construct the input and output. Customize the construction based on the API interface.
std::vector<int64_t> selfShape = {3, 3};
std::vector<int64_t> outShape = selfShape;
void* selfDeviceAddr = nullptr;
void* outDeviceAddr = nullptr;
aclTensor* self = nullptr;
aclScalar* value = nullptr;
aclIntArray* index = nullptr;
aclTensor* out = nullptr;
std::vector<float> selfHostData = {0, 1, 2, 3, 4, 5, 6, 7, 8};
std::vector<float> outHostData = {0, 0, 0, 0, 0, 0, 0, 0, 0};
int64_t dim = 1;
float fillVal = 10;
int64_t indexVal = 0;
// Create the self aclTensor.
ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self);
CHECK_RET(ret == ACL_SUCCESS, return ret);
// Create the out aclTensor.
ret = CreateAclTensor(outHostData, outShape, &outDeviceAddr, aclDataType::ACL_FLOAT, &out);
CHECK_RET(ret == ACL_SUCCESS, return ret);
// Create the value aclScalar.
value = aclCreateScalar(&fillVal, aclDataType::ACL_FLOAT);
CHECK_RET(value != nullptr, return ret);
// Create the index aclIntArray.
index = aclCreateIntArray(&indexVal, 1);
CHECK_RET(index != nullptr, return ret);
// 3. Call the CANN operator library API. Modify it to the specific API name.
uint64_t workspaceSize = 0;
aclOpExecutor* executor;
// Call the first-phase API of aclnnIndexFillTensor.
ret = aclnnIndexFillTensorGetWorkspaceSize(self, dim, index, value, out, &workspaceSize, &executor);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnIndexFillTensorGetWorkspaceSize failed. ERROR: %d\n", ret); return ret);
// Apply for device memory based on the workspaceSize calculated by the first-phase API.
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);
}
// Call the second-phase API of aclnnIndexFillTensor.
ret = aclnnIndexFillTensor(workspaceAddr, workspaceSize, executor, stream);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnIndexFillTensor failed. ERROR: %d\n", ret); return ret);
// 4. (Boilerplate) Synchronously wait for task execution to complete.
ret = aclrtSynchronizeStream(stream);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSynchronizeStream failed. ERROR: %d\n", ret); return ret);
// 5. Obtain the output value and copy the result from device memory to host. Modify based on the specific API definition.
auto size = GetShapeSize(outShape);
std::vector<float> resultData(size, 0);
ret = aclrtMemcpy(resultData.data(), resultData.size() * sizeof(resultData[0]), outDeviceAddr,
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: %f\n", i, resultData[i]);
}
// 6. Release the allocated variables. Modify based on the specific API definition.
aclDestroyTensor(self);
aclDestroyTensor(out);
aclDestroyScalar(value);
aclDestroyIntArray(index);
// 7. Release device resources. Modify based on the specific API definition.
aclrtFree(selfDeviceAddr);
aclrtFree(outDeviceAddr);
if (workspaceSize > 0) {
aclrtFree(workspaceAddr);
}
aclrtDestroyStream(stream);
aclrtResetDevice(deviceId);
aclFinalize();
return 0;
}aclnnInplaceIndexFillTensor Example:
#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_index_fill_tensor.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 for 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 data from the host to the device 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;
}
int main() {
// 1. (Boilerplate) Initialize the device/stream. See the ACL API manual.
// Specify the deviceId based on your actual device.
int32_t deviceId = 0;
aclrtStream stream;
auto ret = Init(deviceId, &stream);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret);
// 2. Construct the input and output. Customize the construction based on the API interface.
std::vector<int64_t> selfShape = {3, 3};
void* selfDeviceAddr = nullptr;
aclTensor* self = nullptr;
aclScalar* value = nullptr;
aclIntArray* index = nullptr;
std::vector<float> selfHostData = {0, 1, 2, 3, 4, 5, 6, 7, 8};
int64_t dim = 1;
float fillVal = 10;
int64_t indexVal = 0;
// Create the self aclTensor.
ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self);
CHECK_RET(ret == ACL_SUCCESS, return ret);
// Create the value aclScalar.
value = aclCreateScalar(&fillVal, aclDataType::ACL_FLOAT);
CHECK_RET(value != nullptr, return ret);
// Create the index aclIntArray.
index = aclCreateIntArray(&indexVal, 1);
CHECK_RET(index != nullptr, return ret);
// 3. Call the CANN operator library API. Replace with the specific API name.
uint64_t workspaceSize = 0;
aclOpExecutor* executor;
// Call the first-phase API of aclnnInplaceIndexFillTensor.
ret = aclnnInplaceIndexFillTensorGetWorkspaceSize(self, dim, index, value, &workspaceSize, &executor);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnInplaceIndexFillTensorGetWorkspaceSize failed. ERROR: %d\n", ret); return ret);
// Apply for device memory based on the workspaceSize calculated by the first-phase API.
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);
}
// Call the second-phase API of aclnnInplaceIndexFillTensor.
ret = aclnnInplaceIndexFillTensor(workspaceAddr, workspaceSize, executor, stream);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnInplaceIndexFillTensor failed. ERROR: %d\n", ret); return ret);
// 4. (Boilerplate) Synchronously wait for task execution to complete.
ret = aclrtSynchronizeStream(stream);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSynchronizeStream failed. ERROR: %d\n", ret); return ret);
// 5. Obtain the output value and copy the result from the device memory to the host. Modify based on the specific API definition.
auto size = GetShapeSize(selfShape);
std::vector<float> resultData(size, 0);
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: %f\n", i, resultData[i]);
}
// 6. Release the allocated variables. Modify based on the specific API definition.
aclDestroyTensor(self);
aclDestroyScalar(value);
aclDestroyIntArray(index);
// 7. Release device resources. Modify based on the specific API definition.
aclrtFree(selfDeviceAddr);
if (workspaceSize > 0) {
aclrtFree(workspaceAddr);
}
aclrtDestroyStream(stream);
aclrtResetDevice(deviceId);
aclFinalize();
return 0;
}