InitBuffer

Applicability

Product	Supported
Atlas A3 training products / Atlas A3 inference products	√
Atlas A2 training products / Atlas A2 inference products	√
Atlas 200I/500 A2 inference products	√
Atlas inference product 's AI Core	√
Atlas inference product 's Vector Core	x
Atlas training products	√

Function

Allocates memory to TBuf and queues such as TQue.

Prototype

Memory allocation for queues such as TQue

        
             template <class T>
__aicore__ inline bool InitBuffer(T& que, uint8_t num, uint32_t len)

// Allocate memory to queues such as TQue. You can customize the memory address information, including the start address and length.
template <class T, class U, class V, class... Addrs>
__aicore__ inline bool InitBuffer(T& que, const Std::tuple<U, V>& addr0, const Addrs&... addrs)

Memory allocation for TBuf

        
             template <TPosition bufPos>
__aicore__ inline bool InitBuffer(TBuf<bufPos>& buf, uint32_t len)

Parameters

**Table 1** Parameters in the bool InitBuffer(T& que, uint8_t num, uint32_t len) prototype definition template
Parameter	Description
T	Parameter of the queue type. The value can be TQue, TQueBind.

**Table 2** Parameters in bool InitBuffer(T& que, uint8_t num, uint32_t len) prototype definition
Parameter	Input/Output	Description
que	Input	Objects such as TQue that require memory allocation.
num	Input	Number of allocated buffers. This parameter is used to enable the double buffer function. If num is set to 1, the double buffer function is disabled. If num is set to 2, the double buffer function is enabled.
len	Input	Size of each buffer. The unit is byte. If the passed len does not meet the 32-byte alignment requirement, the API automatically pads up to 32-byte aligned. Non-alignment processing is involved in subsequent data movement. For details, see Non-Alignment Scenario.

**Table 3** bool InitBuffer(T& que, const Std::tuple<U, V>& addr0, const Addrs&... Parameters in the addrs) prototype definition template
Parameter	Description
T	Parameter of the queue type. The value can be TQue or TQueBind.
U	Parameter of the start address type. The value is an integer.
V	Parameter of the length type. The value is an integer.
Addrs...	Address information in tuple format, including the start address and length.

**Table 4** bool InitBuffer(T& que, const Std::tuple<U, V>& addr0, const Addrs&... Parameters in addrs) prototype definition
Parameter	Input/Output	Description
que	Input	Objects such as TQue that require memory allocation.
addr0	Input	Address information of the allocated buffer, including the start address and length.
addrs	Input	Address information list in tuple format. The number of elements in a tuple must be 2, that is, the start address and length.

**Table 5** Parameters in the InitBuffer(TBuf<bufPos>& buf, uint32_t len) prototype definition template
Parameter	Description
bufPos	Logical position of the TBuf, which is of the TPosition type.

**Table 6** Parameters in InitBuffer(TBuf<bufPos>& buf, uint32_t len) prototype definition
Parameter	Input/Output	Description
buf	Input	TBuf object that requires memory allocation
len	Input	Size of the memory allocated to TBuf, in bytes. If the passed len does not meet the 32-byte alignment requirement, the API automatically pads up to 32-byte aligned. Non-alignment processing is involved in subsequent data movement. For details, see Non-Alignment Scenario.

Restrictions

The memory allocated by InitBuffer is automatically released through the destructor when the TPipe object is destroyed.
If you need to reallocate the memory allocated by InitBuffer, call Reset before InitBuffer is called.
The total number of buffers used in a kernel cannot exceed 64.
It is not recommended that the custom address allocation mode of InitBuffer be used together with the mode where no address is specified. Otherwise, memory conflicts may occur.

Returns

Buffer initialization result.

Example

      
           // Allocate two 128-byte buffers for TQue.
AscendC::TPipe pipe; // Pipe memory management object
AscendC::TQue<AscendC::TPosition::VECOUT, 2> que; // Output the data queue management object, with TPosition set to VECOUT.
uint8_t num = 2;
uint32_t len = 128;
pipe.InitBuffer(que, num, len);

// Allocate memory for TQue. The custom memory addresses are [0, 1024], [2048, 4096], and [8192, 12288].
AscendC::TPipe pipe; // Pipe memory management object
AscendC::TQue<AscendC::TPosition::VECOUT, 1> que; // Output the data queue management object, with TPosition set to VECOUT.
auto addr0 = Std::make_tuple(0, 1024);
auto addr1 = Std::make_tuple(2048, 2048);
auto addr2 = Std::make_tuple(8192, 4096);
pipe.InitBuffer(que, addr0, addr1, addr2);

// Allocate 128-byte memory for TBuf.
AscendC::TPipe pipe;
AscendC::TBuf<AscendC::TPosition::A1> buf; // Output the data management object, with TPosition set to A1.
uint32_t len = 128;
pipe.InitBuffer(buf, len);

Parent topic: TPipe