aclnnInplaceUniform
Applicable Products
| Product | Supported |
|---|---|
| โ | |
| โ | |
| โ | |
| ร | |
| โ | |
| โ |
Function
Generate random numbers with discrete uniform distribution in the [from, to) interval and fill them into the selfRef tensor. (The BOOL type of this interface has been deprecated. If needed, it is recommended to use the aclnnBernoulli or aclnnInplaceBernoulli interface instead.)
Function Prototype
Each operator consists of a two-phase API. The "aclnnInplaceUniformGetWorkspaceSize" API must be called first to obtain the workspace size required for computation and the executor that encapsulates the operator computation flow. Then, the "aclnnInplaceUniform" API is called to perform the computation.
aclnnStatus aclnnInplaceUniformGetWorkspaceSize(
const aclTensor* selfRef,
double from,
double to,
uint64_t seed,
uint64_t offset,
uint64_t* workspaceSize,
aclOpExecutor** executor)aclnnStatus aclnnInplaceUniform(
void* workspace,
uint64_t workspace_size,
aclOpExecutor* executor,
const aclrtStream stream)aclnnInplaceUniformGetWorkspaceSize
Parameters:
Parameter Input/Output Description Instruction Data Type Data Format Dimension (Shape) Non-Contiguous Tensor selfRef (aclTensor*) Input/Output Input/output tensor. - FLOAT32, INT32, INT64, BFLOAT16, FLOAT16, INT16, INT8, UINT8, DOUBLE ND - โ from (double) Input Left boundary for discrete uniform distribution sampling. The value of from must be within the data type range of selfRef, and the value of from must be less than to. DOUBLE - - - to (double) Input. Specifies the right boundary for discrete uniform distribution values. The value of to must be within the value range of the data type of selfRef. DOUBLE - - - seed (uint64_t) Input Seed of the random number generator, which affects the generated random number sequence. - UINT64 - - - offset (uint64_t) Input Offset of the random number generator, which affects the position of the generated random number sequence. After the offset is set, the generated random number sequence starts from the specified position. - UINT64 - - - workspaceSize (uint64_t*) Output Size of the workspace to be requested on the Device side. - - - - - executor (aclOpExecutor**) Output Returns the op executor, which includes the operator computation flow. - - - - - Atlas training products : The 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 The passed selfRef is a null pointer. ACLNN_ERR_PARAM_INVALID 161002 The data type of selfRef is not within the supported range. The shape of selfRef exceeds 8 dimensions. from is greater than to.
aclnnInplaceUniform
Parameters:
Parameter Input/Output Description workspace Input Specifies the workspace memory address applied on the Device side. workspaceSize Input Size of the workspace applied for on the Device side, obtained through the first-phase API aclnnInplaceUniformGetWorkspaceSize. executor Input Operator executor, which contains the operator computation process. stream Input Specifies the stream on which the task is executed. Return value:
aclnnStatus: return code. For details, see aclnn Return Codes.
Constraints
Deterministic computation:
- aclnnInplaceUniform 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.
#include "acl/acl.h"
#include "aclnnop/aclnn_uniform.h"
#include <iostream>
#include <vector>
#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 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);
// Copy host data to device memory using 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 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];
}
// Create an aclTensor by calling aclCreateTensor.
*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 for device/stream initialization. See the acl API manual.
// Fill in the deviceId based on the actual device.
int32_t deviceId = 0;
aclrtStream stream;
auto ret = Init(deviceId, &stream);
// Check as needed.
CHECK_RET(ret == 0, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret);
// 2. Construct the input and output based on the API definition.
std::vector<int64_t> selfRefShape = {4, 2};
void* selfRefDeviceAddr = nullptr;
aclTensor* selfRef = nullptr;
std::vector<float> selfRefHostData = {0, 1, 2, 3, 4, 5, 6, 7};
// Create selfRef aclTensor.
ret = CreateAclTensor(selfRefHostData, selfRefShape, &selfRefDeviceAddr, aclDataType::ACL_FLOAT, &selfRef);
CHECK_RET(ret == ACL_SUCCESS, return ret);
double from = 2.4;
double to = 4.4;
uint64_t seed = 0;
uint64_t offset = 0;
// 3. Call the CANN operator library API. Replace with the specific API.
uint64_t workspaceSize = 0;
aclOpExecutor* executor;
// Call the first-phase API of aclnnInplaceUniform.
ret = aclnnInplaceUniformGetWorkspaceSize(selfRef, from, to, seed, offset, &workspaceSize, &executor);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnInplaceUniformGetWorkspaceSize failed. ERROR: %d\n", ret); return ret);
// Apply for device memory based on the workspaceSize computed 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 aclnnInplaceUniform.
ret = aclnnInplaceUniform(workspaceAddr, workspaceSize, executor, stream);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnInplaceUniform failed. ERROR: %d\n", ret); return ret);
// 4. Boilerplate: synchronize and wait for the 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 memory. Modify based on the specific API definition.
auto size = GetShapeSize(selfRefShape);
std::vector<float> resultData(size, 0);
ret = aclrtMemcpy(resultData.data(), resultData.size() * sizeof(resultData[0]), selfRefDeviceAddr, size * sizeof(float),
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 aclTensor and aclScalar. Modify based on the specific API definition.
aclDestroyTensor(selfRef);
// 7. Release device resources. Modify based on the specific API definition.
aclrtFree(selfRefDeviceAddr);
if (workspaceSize > 0) {
aclrtFree(workspaceAddr);
}
aclrtDestroyStream(stream);
aclrtResetDevice(deviceId);
aclFinalize();
return 0;
}