Function: reserve_mem_address

Applicability

Product

Supported

Atlas 350 Accelerator Card

Atlas A3 training product/Atlas A3 inference product

Atlas A2 training product/Atlas A2 inference product

Atlas training product

Atlas inference product

Atlas 200I/500 A2 inference product

Description

Reserves virtual memory.

This API needs to work with other APIs to allocate virtual memory with consecutive addresses and maximize the use of physical memory.
  1. Call acl.rt.reserve_mem_address to allocate virtual memory.
  2. Call acl.rt.malloc_physical to allocate physical memory.
  3. Call acl.rt.map_mem to map the virtual memory to the physical memory.
  4. Call specific task APIs to execute tasks.
  5. Call acl.rt.unmap_mem to unmap the virtual memory from the physical memory.
  6. Call acl.rt.free_physical to free the physical memory.
  7. Call acl.rt.release_mem_address to free the virtual memory.

Prototype

  • C Prototype
    1
    aclError aclrtReserveMemAddress(void **virPtr, size_t size, size_t alignment, void *expectPtr, uint64_t flags)
    
  • Python Function
    1
    vir_ptr, ret = acl.rt.reserve_mem_address(size, alignment, expect_ptr, flags)
    

Parameters

Parameter

Description

size

Int, size of the virtual address space, in bytes. Must not be 0.

alignment

Int, alignment value of the virtual address. This parameter is reserved and can only be set to 0.

expectPtr

Int, start address of the virtual address space to be returned. This parameter is reserved and can only be set to 0.

flags

Int, huge page/common page flag. This parameter is reserved. The recommended value is 0.

Return Value

Return Value

Description

virPtr

Int, pointing to the address of the allocated virtual address space.

ret

Int, error code. 0 on success; else, failure.

Restrictions

  • Ascend RC does not support this API.

    Currently, the following models support the Ascend RC form:

    • Atlas 200I/500 A2 inference product
  • To use the virtual memory reserved by this API, only memcpy_async can be called to copy data between two devices in the single-process scenario.