* Copyright (c) 2026 Huawei Technologies Co., Ltd.
* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
* CANN Open Software License Agreement Version 2.0 (the "License").
* Please refer to the License for details. You may not use this file except in compliance with the License.
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
* See LICENSE in the root of the software repository for the full text of the License.
*/
#ifndef INC_EXTERNAL_ACL_ACL_RT_API_H_
#define INC_EXTERNAL_ACL_ACL_RT_API_H_
#include "acl_rt.h"
#ifdef __cplusplus
static inline aclError aclrtSynchronizeDevice(int32_t timeout)
{
return ::aclrtSynchronizeDeviceWithTimeout(timeout);
}
static inline aclError aclrtSynchronizeStream(aclrtStream stream, int32_t timeout)
{
return ::aclrtSynchronizeStreamWithTimeout(stream, timeout);
}
static inline aclError aclrtSynchronizeEvent(aclrtEvent event, int32_t timeout)
{
return ::aclrtSynchronizeEventWithTimeout(event, timeout);
}
static inline aclError aclrtStreamWaitEvent(aclrtStream stream, aclrtEvent event, int32_t timeout)
{
return ::aclrtStreamWaitEventWithTimeout(stream, event, timeout);
}
static inline aclError aclrtCreateStream(aclrtStream *stream, uint32_t priority, uint32_t flag)
{
return ::aclrtCreateStreamWithConfig(stream, priority, flag);
}
static inline aclError aclrtSetOpExecuteTimeOut(uint64_t timeout, uint64_t *actualTimeout)
{
return ::aclrtSetOpExecuteTimeOutV2(timeout, actualTimeout);
}
static inline aclError aclrtCreateEvent(aclrtEvent *event, uint32_t flag)
{
return ::aclrtCreateEventExWithFlag(event, flag);
}
template <typename T>
static inline aclError aclrtMalloc(T **devPtr, size_t size, aclrtMallocConfig *cfg = nullptr)
{
return ::aclrtMallocWithCfg(reinterpret_cast<void **>(devPtr), size, ACL_MEM_MALLOC_HUGE_FIRST, cfg);
}
template <typename T>
static inline aclError aclrtMalloc(T **devPtr, size_t size, aclrtMemMallocPolicy policy, aclrtMallocConfig *cfg = nullptr)
{
return ::aclrtMallocWithCfg(reinterpret_cast<void **>(devPtr), size, policy, cfg);
}
template <typename T>
static inline aclError aclrtMallocHost(T **hostPtr, size_t size, aclrtMallocConfig *cfg = nullptr)
{
return ::aclrtMallocHostWithCfg(reinterpret_cast<void **>(hostPtr), static_cast<uint64_t>(size), cfg);
}
template <typename T, typename U>
static inline aclError aclrtMemcpy(T *dst, size_t destMax, const U *src, size_t count, aclrtMemcpyKind kind)
{
return ::aclrtMemcpy(static_cast<void *>(dst), destMax, static_cast<const void *>(src), count, kind);
}
template <typename T, typename U>
static inline aclError aclrtMemcpyAsync(T *dst, size_t destMax, const U *src, size_t count,
aclrtMemcpyKind kind, aclrtStream stream)
{
return ::aclrtMemcpyAsync(static_cast<void *>(dst), destMax, static_cast<const void *>(src), count, kind, stream);
}
template <typename T, typename U>
static inline aclError aclrtMemcpy2d(T *dst, size_t dpitch, const U *src, size_t spitch,
size_t width, size_t height, aclrtMemcpyKind kind)
{
return ::aclrtMemcpy2d(static_cast<void *>(dst), dpitch, static_cast<const void *>(src),
spitch, width, height, kind);
}
template <typename T, typename U>
static inline aclError aclrtMemcpy2dAsync(T *dst, size_t dpitch, const U *src, size_t spitch,
size_t width, size_t height, aclrtMemcpyKind kind, aclrtStream stream)
{
return ::aclrtMemcpy2dAsync(static_cast<void *>(dst), dpitch, static_cast<const void *>(src),
spitch, width, height, kind, stream);
}
template <typename T, typename U>
static inline aclError aclrtMemcpyBatch(T **dsts, size_t *destMaxs, U **srcs, size_t *sizes,
size_t numBatches, aclrtMemcpyBatchAttr attr, size_t *failIndex = nullptr)
{
(void)failIndex;
aclrtMemcpyBatchAttr attrs[1] = {attr};
size_t attrsIndexes[1] = {0};
return ::aclrtMemcpyBatchV2(reinterpret_cast<void **>(dsts), destMaxs, reinterpret_cast<void **>(srcs),
sizes, numBatches, attrs, attrsIndexes, 1);
}
template <typename T, typename U>
static inline aclError aclrtMemcpyBatch(T **dsts, size_t *destMaxs, U **srcs, size_t *sizes,
size_t numBatches, aclrtMemcpyBatchAttr *attrs,
size_t *attrsIndexes, size_t numAttrs, size_t *failIndex = nullptr)
{
(void)failIndex;
return ::aclrtMemcpyBatchV2(reinterpret_cast<void **>(dsts), destMaxs, reinterpret_cast<void **>(srcs),
sizes, numBatches, attrs, attrsIndexes, numAttrs);
}
template <typename T, typename U>
static inline aclError aclrtMemcpyBatchAsync(T **dsts, size_t *destMaxs, U **srcs, size_t *sizes,
size_t numBatches, aclrtMemcpyBatchAttr attr, aclrtStream stream)
{
aclrtMemcpyBatchAttr attrs[1] = {attr};
size_t attrsIndexes[1] = {0};
return ::aclrtMemcpyBatchAsyncV2(reinterpret_cast<void **>(dsts), destMaxs, reinterpret_cast<void **>(srcs),
sizes, numBatches, attrs, attrsIndexes, 1, stream);
}
template <typename T, typename U>
static inline aclError aclrtMemcpyBatchAsync(T **dsts, size_t *destMaxs, U **srcs, size_t *sizes,
size_t numBatches, aclrtMemcpyBatchAttr *attrs,
size_t *attrsIndexes, size_t numAttrs, aclrtStream stream)
{
return ::aclrtMemcpyBatchAsyncV2(reinterpret_cast<void **>(dsts), destMaxs, reinterpret_cast<void **>(srcs),
sizes, numBatches, attrs, attrsIndexes, numAttrs, stream);
}
template <typename T, typename U>
static inline aclError aclrtMemcpyBatchAsync(T **dsts, size_t *destMaxs, U **srcs, size_t *sizes,
size_t numBatches, aclrtMemcpyBatchAttr attr,
size_t *failIndex, aclrtStream stream)
{
aclrtMemcpyBatchAttr attrs[1] = {attr};
size_t attrsIndexes[1] = {0};
return ::aclrtMemcpyBatchAsync(reinterpret_cast<void **>(dsts), destMaxs, reinterpret_cast<void **>(srcs),
sizes, numBatches, attrs, attrsIndexes, 1, failIndex, stream);
}
template <typename T, typename U>
static inline aclError aclrtMemcpyBatchAsync(T **dsts, size_t *destMaxs, U **srcs, size_t *sizes,
size_t numBatches, aclrtMemcpyBatchAttr *attrs,
size_t *attrsIndexes, size_t numAttrs, size_t *failIndex, aclrtStream stream)
{
return ::aclrtMemcpyBatchAsync(reinterpret_cast<void **>(dsts), destMaxs, reinterpret_cast<void **>(srcs),
sizes, numBatches, attrs, attrsIndexes, numAttrs, failIndex, stream);
}
template <typename T>
static inline aclError aclrtPointerGetAttributes(const T *ptr, aclrtPtrAttributes *attributes)
{
return ::aclrtPointerGetAttributes(static_cast<const void *>(ptr), attributes);
}
template <typename T>
static inline aclError aclrtHostRegister(T *ptr, uint64_t size, aclrtHostRegisterType type, T **devPtr)
{
return ::aclrtHostRegister(static_cast<void *>(ptr), size, type, reinterpret_cast<void **>(devPtr));
}
template <typename T>
static inline aclError aclrtHostRegister(T *ptr, uint64_t size, uint32_t flag)
{
return ::aclrtHostRegisterV2(static_cast<void *>(ptr), size, flag);
}
template <typename T>
static inline aclError aclrtHostGetDevicePointer(T *pHost, T **pDevice, uint32_t flag)
{
return ::aclrtHostGetDevicePointer(static_cast<void *>(pHost), reinterpret_cast<void **>(pDevice), flag);
}
template <typename T>
static inline aclError aclrtHostUnregister(T *ptr)
{
return ::aclrtHostUnregister(static_cast<void *>(ptr));
}
template <typename T>
static inline aclError aclrtMemAllocManaged(T **devPtr, size_t size, uint32_t flags = ACL_RT_MEM_ATTACH_GLOBAL)
{
return ::aclrtMemAllocManaged(reinterpret_cast<void **>(devPtr), static_cast<uint64_t>(size), flags);
}
template <typename T>
static inline aclError aclrtMemManagedPrefetchAsync(const T *ptr, size_t size,
aclrtMemManagedLocation location, uint32_t flags, aclrtStream stream)
{
return ::aclrtMemManagedPrefetchAsync(static_cast<const void *>(ptr), size, location, flags, stream);
}
template <typename T>
static inline aclError aclrtMemManagedPrefetchBatchAsync(const T **ptrs, size_t *sizes, size_t count,
aclrtMemManagedLocation prefetchLoc,
uint64_t flags, aclrtStream stream)
{
aclrtMemManagedLocation prefetchLocs[1] = {prefetchLoc};
size_t prefetchLocIdxs[1] = {0};
return ::aclrtMemManagedPrefetchBatchAsync(reinterpret_cast<const void **>(ptrs), sizes, count,
prefetchLocs, prefetchLocIdxs, 1, flags, stream);
}
template <typename T>
static inline aclError aclrtMemManagedPrefetchBatchAsync(const T **ptrs, size_t *sizes, size_t count,
aclrtMemManagedLocation *prefetchLocs,
size_t *prefetchLocIdxs, size_t numPrefetchLocs,
uint64_t flags, aclrtStream stream)
{
return ::aclrtMemManagedPrefetchBatchAsync(reinterpret_cast<const void **>(ptrs), sizes, count,
prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream);
}
template <typename T>
static inline aclError aclrtGetSymbolAddress(const T &symbol, void **devPtr)
{
return ::aclrtGetSymbolAddress(static_cast<const void*>(&symbol), devPtr);
}
template <typename T>
static inline aclError aclrtGetSymbolSize(const T &symbol, size_t *size)
{
return ::aclrtGetSymbolSize(static_cast<const void*>(&symbol), size);
}
template <typename T>
static inline aclError aclrtMemcpyFromSymbol(void *dst, size_t dstMax, const T &symbol,
size_t count, size_t offset, aclrtMemcpyKind kind)
{
return ::aclrtMemcpyFromSymbol(dst, dstMax, static_cast<const void*>(&symbol), count, offset, kind);
}
template <typename T>
static inline aclError aclrtMemcpyFromSymbolAsync(void *dst, size_t dstMax, const T &symbol,
size_t count, size_t offset, aclrtMemcpyKind kind,
aclrtStream stream)
{
return ::aclrtMemcpyFromSymbolAsync(dst, dstMax, static_cast<const void*>(&symbol), count, offset, kind, stream);
}
template <typename T>
static inline aclError aclrtMemcpyToSymbol(const T &symbol, const void *src,
size_t count, size_t offset, aclrtMemcpyKind kind)
{
return ::aclrtMemcpyToSymbol(static_cast<const void*>(&symbol), src, count, offset, kind);
}
template <typename T>
static inline aclError aclrtMemcpyToSymbolAsync(const T &symbol, const void *src,
size_t count, size_t offset, aclrtMemcpyKind kind,
aclrtStream stream)
{
return ::aclrtMemcpyToSymbolAsync(static_cast<const void*>(&symbol), src, count, offset, kind, stream);
}
#endif
#endif
