_ak_memory_mgr_module_8h

Wwise SDK 2024.1.0

 /*******************************************************************************
 The content of this file includes portions of the AUDIOKINETIC Wwise Technology
 released in source code form as part of the SDK installer package.
  
 Commercial License Usage
  
 Licensees holding valid commercial licenses to the AUDIOKINETIC Wwise Technology
 may use this file in accordance with the end user license agreement provided
 with the software or, alternatively, in accordance with the terms contained in a
 written agreement between you and Audiokinetic Inc.
  
 Apache License Usage
  
 Alternatively, this file may be used under the Apache License, Version 2.0 (the
 "Apache License"); you may not use this file except in compliance with the
 Apache License. You may obtain a copy of the Apache License at
 http://www.apache.org/licenses/LICENSE-2.0.
  
 Unless required by applicable law or agreed to in writing, software distributed
 under the Apache License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES
 OR CONDITIONS OF ANY KIND, either express or implied. See the Apache License for
 the specific language governing permissions and limitations under the License.
  
   Copyright (c) 2024 Audiokinetic Inc.
 *******************************************************************************/
  
 /// \file
 /// Audiokinetic's definitions and factory of overridable Memory Manager module.
  
 #pragma once
  
 #include <AK/SoundEngine/Common/AkMemoryMgr.h>
 #include <AK/SoundEngine/Common/AkTempAllocDefs.h>
 #include <AK/SoundEngine/Common/AkMemoryArenaTypes.h>
 #include <AK/SoundEngine/Common/AkTypes.h>
  
 /// \name Audiokinetic Memory Manager's implementation-specific definitions.
 //@{
  
 typedef void ( AKSOUNDENGINE_CALL *AkMemInitForThread ) (
     );
  
 typedef void ( AKSOUNDENGINE_CALL *AkMemTermForThread ) (
     );
  
 typedef void ( AKSOUNDENGINE_CALL *AkMemTrimForThread ) (
     );
  
 typedef void* ( AKSOUNDENGINE_CALL *AkMemMalloc ) (
     AkMemPoolId poolId,
     size_t uSize
     );
  
 typedef void* ( AKSOUNDENGINE_CALL *AkMemMalign ) (
     AkMemPoolId poolId,
     size_t uSize,
     AkUInt32 uAlignment
     );
  
 typedef void* ( AKSOUNDENGINE_CALL *AkMemRealloc ) (
     AkMemPoolId poolId,
     void* pAddress,
     size_t uSize
     );
  
  
 typedef void* ( AKSOUNDENGINE_CALL *AkMemReallocAligned ) (
     AkMemPoolId poolId,
     void* pAddress,
     size_t uSize,
     AkUInt32 uAlignment
     );
  
 typedef void ( AKSOUNDENGINE_CALL *AkMemFree ) (
     AkMemPoolId poolId,
     void* pAddress
     );
  
 typedef size_t ( AKSOUNDENGINE_CALL *AkMemTotalReservedMemorySize ) (
     );
  
 typedef size_t ( AKSOUNDENGINE_CALL *AkMemSizeOfMemory ) (
     AkMemPoolId poolId,
     void* pAddress
     );
  
 typedef void ( AKSOUNDENGINE_CALL *AkMemDebugMalloc ) (
     AkMemPoolId poolId,
     size_t uSize,
     void* pAddress,
     char const* pszFile,
     AkUInt32 uLine
     );
  
 typedef void ( AKSOUNDENGINE_CALL *AkMemDebugMalign ) (
     AkMemPoolId poolId,
     size_t uSize,
     AkUInt32 uAlignment,
     void* pAddress,
     char const* pszFile,
     AkUInt32 uLine
     );
  
 typedef void ( AKSOUNDENGINE_CALL *AkMemDebugRealloc ) (
     AkMemPoolId poolId,
     void* pOldAddress,
     size_t uSize,
     void* pNewAddress,
     char const* pszFile,
     AkUInt32 uLine
     );
  
 typedef void ( AKSOUNDENGINE_CALL *AkMemDebugReallocAligned ) (
     AkMemPoolId poolId,
     void* pOldAddress,
     size_t uSize,
     AkUInt32 uAlignment,
     void* pNewAddress,
     char const* pszFile,
     AkUInt32 uLine
     );
  
 typedef void ( AKSOUNDENGINE_CALL *AkMemDebugFree ) (
     AkMemPoolId poolId,
     void* pAddress
     );
  
 // Listing of every memory arena used by the AkMemoryMgr, when using default AkMemoryMgr systems in Wwise
 enum AkMemoryMgrArena
 {
     AkMemoryMgrArena_Primary = 0,
     AkMemoryMgrArena_Media,
     AkMemoryMgrArena_Profiler, // "Profiler" arena will not be available in AK_OPTIMIZED (e.g. "Release") builds
     AkMemoryMgrArena_Device, // "Device" arena will only be available on platforms that use device memory for voice decoding
     AkMemoryMgrArena_NUM,
 };
  
 namespace AK
 {
     namespace MemoryArena
     {
         struct AkMemoryArena;
     }
 }
  
 /// Initialization settings for the default implementation of the Memory Manager. For more details, see \ref memorymanager_init.
 /// \sa AK::MemoryMgr
 struct AkMemSettings
 {
     /// @name High-level memory allocation hooks. When not NULL, redirect allocations normally forwarded to internal memory systems.
     //@{
     AkMemInitForThread                         pfInitForThread;                ///< (Optional) Thread-specific allocator initialization hook.
     AkMemTermForThread                         pfTermForThread;                ///< (Optional) Thread-specific allocator termination hook.
     AkMemTrimForThread                         pfTrimForThread;                ///< (Optional) Thread-specific allocator "trimming" hook. Used to relinquish memory resources when threads enter a period of inactivity.
     AkMemMalloc                                pfMalloc;                       ///< (Optional) Memory allocation hook.
     AkMemMalign                                pfMalign;                       ///< (Optional) Memory allocation hook.
     AkMemRealloc                               pfRealloc;                      ///< (Optional) Memory allocation hook.
     AkMemReallocAligned                        pfReallocAligned;               ///< (Optional) Memory allocation hook.
     AkMemFree                                  pfFree;                         ///< (Optional) Memory allocation hook.
     AkMemTotalReservedMemorySize               pfTotalReservedMemorySize;      ///< (Optional) Memory allocation statistics hook.
     AkMemSizeOfMemory                          pfSizeOfMemory;                 ///< (Optional) Memory allocation statistics hook.
     //@}
  
     /// @name Configuration.
     //@{
     AK::MemoryArena::AkMemoryArenaSettings     memoryArenaSettings[AkMemoryMgrArena_NUM]; ///< Configuration of memory arenas for default memory allocator. For more information, see \ref goingfurther_optimizingmempools_memoryarena.
     AK::TempAlloc::InitSettings                tempAllocSettings[AK::TempAlloc::Type_NUM]; ///< Configuration of behavior for the temporary-memory pools. For more information, see \ref goingfurther_optimizingmempools_tempallocs.
     AK::BookmarkAlloc::InitSettings            bookmarkAllocSettings;          ///< Configuration of behavior for the bookmark-allocated memory. For more information, see \ref goingfurther_optimizingmempools_bookmarkalloc.
     //@}
  
     /// @name Memory allocation debugging.
     //@{
     AkMemDebugMalloc                           pfDebugMalloc;                  ///< (Optional) Memory allocation debugging hook. Used for tracking calls to pfMalloc.
     AkMemDebugMalign                           pfDebugMalign;                  ///< (Optional) Memory allocation debugging hook. Used for tracking calls to pfMalign.
     AkMemDebugRealloc                          pfDebugRealloc;                 ///< (Optional) Memory allocation debugging hook. Used for tracking calls to pfRealloc.
     AkMemDebugReallocAligned                   pfDebugReallocAligned;          ///< (Optional) Memory allocation debugging hook. Used for tracking calls to pfReallocAligned.
     AkMemDebugFree                             pfDebugFree;                    ///< (Optional) Memory allocation debugging hook. Used for tracking calls to pfFree.
     AkUInt32                                   uMemoryDebugLevel;              ///< Default 0 disabled. 1 debug enabled. 2 stomp allocator enabled. 3 stomp allocator and debug enabled. User implementations may use multiple non-zero values to offer different features.
     //@}
 };
 //@}
  
 namespace AK
 {
  
 namespace MemoryMgr
 {
  
 /// Initialize the default implementation of the Memory Manager.
 /// \sa AK::MemoryMgr
 AK_EXTERNAPIFUNC( AKRESULT, Init ) (
     AkMemSettings * in_pSettings        ///< Memory manager initialization settings.
     );
  
 /// Obtain the default initialization settings for the default implementation of the Memory Manager.
 AK_EXTERNAPIFUNC( void, GetDefaultSettings ) (
     AkMemSettings & out_pMemSettings    ///< Memory manager default initialization settings.
     );
  
  
 /// Verify the integrity of the book-keeping data of the AkMemoryArena allocator.
 /// If corruption in the book-keeping data is detected, an assertion failure occurs.
 /// This function is a no-op if AK_ENABLE_ASSERTS is not defined or if AkMemoryArena has been overridden by custom memory allocations hooks.
 AK_EXTERNAPIFUNC(void, VerifyMemoryArenaIntegrity) (
     AkMemoryMgrArena in_eArena /// Which arena to verify
     );
  
 /// Helper to fetch each the arena. Should only be used for debug purposes, e.g. profiling, stats, integrity checks. Returns null in AK_OPTIMIZED builds
 AK_EXTERNAPIFUNC(AK::MemoryArena::AkMemoryArena*, GetMemoryArena) (
     AkMemoryMgrArena in_eArena /// Which arena to verify
     );
  
 }
  
 }
  
 #if defined AK_WIN || defined AK_LINUX || defined AK_SONY || defined AK_XBOX || defined AK_APPLE || defined AK_EMSCRIPTEN
 #define AK_CRT_ALLOCATOR_SUPPORTED
 #endif
  
 #ifdef AK_CRT_ALLOCATOR_SUPPORTED
 namespace AK
 {
  
 namespace MemoryMgr
 {
  
 /// @name C runtime allocator functions for the default implementation of the Memory Manager.
 //@{
  
 AK_EXTERNAPIFUNC( void, AkCrtAllocatorInitForThread )();
  
 AK_EXTERNAPIFUNC( void, AkCrtAllocatorTermForThread )();
  
 AK_EXTERNAPIFUNC( void, AkCrtAllocatorTrimForThread )();
  
 AK_EXTERNAPIFUNC( void*, AkCrtAllocatorMalloc )(
     AkMemPoolId poolId,
     size_t uSize
     );
  
 AK_EXTERNAPIFUNC( void*, AkCrtAllocatorMalign )(
     AkMemPoolId poolId,
     size_t uSize,
     AkUInt32 uAlignment
     );
  
 AK_EXTERNAPIFUNC( void*, AkCrtAllocatorRealloc )(
     AkMemPoolId poolId,
     void* pAddress,
     size_t uSize
     );
  
 AK_EXTERNAPIFUNC( void*, AkCrtAllocatorReallocAligned )(
     AkMemPoolId poolId,
     void* pAddress,
     size_t uSize,
     AkUInt32 uAlignment
     );
  
 AK_EXTERNAPIFUNC( void, AkCrtAllocatorFree )(
     AkMemPoolId poolId,
     void* pAddress
     );
  
 AK_EXTERNAPIFUNC( size_t, AkCrtAllocatorTotalReservedMemorySize )();
  
 AK_EXTERNAPIFUNC( size_t, AkCrtAllocatorSizeOfMemory )(
     AkMemPoolId poolID,
     void* pAddress
     );
  
 //@}
  
 }
  
 }
  
 #endif // AK_CRT_ALLOCATOR_SUPPORTED
  
 #if !defined AK_EMSCRIPTEN
 #define AK_STOMP_ALLOCATOR_SUPPORTED
 #endif
  
 #ifdef AK_STOMP_ALLOCATOR_SUPPORTED
  
 namespace AK
 {
  
 namespace MemoryMgr
 {
  
 /// @name Stomp allocator functions for the default implementation of the Memory Manager.
 //@{
  
 AK_EXTERNAPIFUNC( void, AkStompAllocatorInitForThread )();
  
 AK_EXTERNAPIFUNC( void, AkStompAllocatorTermForThread )();
  
 AK_EXTERNAPIFUNC( void, AkStompAllocatorTrimForThread )();
  
 AK_EXTERNAPIFUNC( void*, AkStompAllocatorMalloc )(
     AkMemPoolId poolId,
     size_t uSize
     );
  
 AK_EXTERNAPIFUNC( void*, AkStompAllocatorMalign )(
     AkMemPoolId poolId,
     size_t uSize,
     AkUInt32 uAlignment
     );
  
 AK_EXTERNAPIFUNC( void*, AkStompAllocatorRealloc )(
     AkMemPoolId poolId,
     void* pAddress,
     size_t uSize
     );
  
 AK_EXTERNAPIFUNC( void*, AkStompAllocatorReallocAligned )(
     AkMemPoolId poolId,
     void* pAddress,
     size_t uSize,
     AkUInt32 uAlignment
     );
  
 AK_EXTERNAPIFUNC( void, AkStompAllocatorFree )(
     AkMemPoolId poolId,
     void* pAddress
     );
  
 AK_EXTERNAPIFUNC( size_t, AkStompAllocatorTotalReservedMemorySize )();
  
 AK_EXTERNAPIFUNC( size_t, AkStompAllocatorSizeOfMemory )(
     AkMemPoolId poolID,
     void* pAddress
     );
  
 //@}
  
 }
  
 }
 #endif // AK_STOMP_ALLOCATOR_SUPPORTED
  
 namespace AK
 {
  
 namespace MemoryMgr
 {
  
 /// @name Debug tool hooks for the default implementation of the Memory Manager.
 //@{
  
 AK_EXTERNAPIFUNC( AKRESULT, AkMemDebugToolInit )();
  
 AK_EXTERNAPIFUNC( void, AkMemDebugToolTerm )();
  
 AK_EXTERNAPIFUNC( void, AkMemDebugToolMalloc ) (
     AkMemPoolId poolId,
     size_t uSize,
     void* pAddress,
     char const* pszFile,
     AkUInt32 uLine
     );
  
 AK_EXTERNAPIFUNC( void, AkMemDebugToolMalign ) (
     AkMemPoolId poolId,
     size_t uSize,
     AkUInt32 uAlignment,
     void* pAddress,
     char const* pszFile,
     AkUInt32 uLine
     );
  
 AK_EXTERNAPIFUNC( void, AkMemDebugToolRealloc ) (
     AkMemPoolId poolId,
     void* pOldAddress,
     size_t uSize,
     void* pNewAddress,
     char const* pszFile,
     AkUInt32 uLine
     );
  
 AK_EXTERNAPIFUNC( void, AkMemDebugToolReallocAligned ) (
     AkMemPoolId poolId,
     void* pOldAddress,
     size_t uSize,
     AkUInt32 uAlignment,
     void* pNewAddress,
     char const* pszFile,
     AkUInt32 uLine
     );
  
 AK_EXTERNAPIFUNC( void, AkMemDebugToolFree ) (
     AkMemPoolId poolId,
     void* pAddress
     );
  
 //@}
  
 }
  
 }

AkMemRealloc

void *(* AkMemRealloc)(AkMemPoolId poolId, void *pAddress, size_t uSize)

Definition: AkMemoryMgrModule.h:60

AkMemTermForThread

void(* AkMemTermForThread)()

Definition: AkMemoryMgrModule.h:43

AK::MemoryMgr::AkMemDebugToolInit

AKSOUNDENGINE_API AKRESULT AkMemDebugToolInit()

AkMemSettings::memoryArenaSettings

AK::MemoryArena::AkMemoryArenaSettings memoryArenaSettings[AkMemoryMgrArena_NUM]

Configuration of memory arenas for default memory allocator. For more information,...

Definition: AkMemoryMgrModule.h:166

Definition of data structures for AkAudioObject.

Definition: AkWwiseSDKVersion.cs:31

AkMemSettings::pfTermForThread

AkMemTermForThread pfTermForThread

(Optional) Thread-specific allocator termination hook.

Definition: AkMemoryMgrModule.h:153

AK::MemoryMgr::AkMemDebugToolMalloc

AKSOUNDENGINE_API void AkMemDebugToolMalloc(AkMemPoolId poolId, size_t uSize, void *pAddress, char const *pszFile, AkUInt32 uLine)

AkMemSettings::pfInitForThread

AkMemInitForThread pfInitForThread

(Optional) Thread-specific allocator initialization hook.

Definition: AkMemoryMgrModule.h:152

AkMemSettings::pfFree

AkMemFree pfFree

(Optional) Memory allocation hook.

Definition: AkMemoryMgrModule.h:159

AkMemSettings::bookmarkAllocSettings

AK::BookmarkAlloc::InitSettings bookmarkAllocSettings

Configuration of behavior for the bookmark-allocated memory. For more information,...

Definition: AkMemoryMgrModule.h:168

AkMemSettings::pfMalign

AkMemMalign pfMalign

(Optional) Memory allocation hook.

Definition: AkMemoryMgrModule.h:156

AK::MemoryMgr::Init

AKSOUNDENGINE_API AKRESULT Init(AkMemSettings *in_pSettings)

AK::MemoryMgr::AkCrtAllocatorInitForThread

AKSOUNDENGINE_API void AkCrtAllocatorInitForThread()

AkMemoryMgrArena

Definition: AkMemoryMgrModule.h:130

AK_EXTERNAPIFUNC

#define AK_EXTERNAPIFUNC(_type, _name)

Definition: AkSoundEngineExport.h:81

AkMemSettings::pfRealloc

AkMemRealloc pfRealloc

(Optional) Memory allocation hook.

Definition: AkMemoryMgrModule.h:157

AKRESULT

Standard function call result.

Definition: AkTypes.h:134

AkMemInitForThread

void(* AkMemInitForThread)()

Definition: AkMemoryMgrModule.h:40

AK::MemoryMgr::AkMemDebugToolFree

AKSOUNDENGINE_API void AkMemDebugToolFree(AkMemPoolId poolId, void *pAddress)

AK::MemoryArena::AkMemoryArenaSettings

Definition: AkMemoryArenaTypes.h:61

AkMemSizeOfMemory

size_t(* AkMemSizeOfMemory)(AkMemPoolId poolId, void *pAddress)

Definition: AkMemoryMgrModule.h:82

AkMemPoolId

AkInt32 AkMemPoolId

Memory pool ID.

Definition: AkTypes.h:62

AkMemSettings::pfDebugRealloc

AkMemDebugRealloc pfDebugRealloc

(Optional) Memory allocation debugging hook. Used for tracking calls to pfRealloc.

Definition: AkMemoryMgrModule.h:175

AkMemSettings::pfDebugReallocAligned

AkMemDebugReallocAligned pfDebugReallocAligned

(Optional) Memory allocation debugging hook. Used for tracking calls to pfReallocAligned.

Definition: AkMemoryMgrModule.h:176

AK::MemoryMgr::AkMemDebugToolTerm

AKSOUNDENGINE_API void AkMemDebugToolTerm()

AK::MemoryMgr::AkCrtAllocatorMalign

AKSOUNDENGINE_API void * AkCrtAllocatorMalign(AkMemPoolId poolId, size_t uSize, AkUInt32 uAlignment)

AkMemSettings::pfTrimForThread

AkMemTrimForThread pfTrimForThread

(Optional) Thread-specific allocator "trimming" hook. Used to relinquish memory resources when thread...

Definition: AkMemoryMgrModule.h:154

AK::MemoryMgr::AkMemDebugToolMalign

AKSOUNDENGINE_API void AkMemDebugToolMalign(AkMemPoolId poolId, size_t uSize, AkUInt32 uAlignment, void *pAddress, char const *pszFile, AkUInt32 uLine)

AK::MemoryMgr::GetMemoryArena

AKSOUNDENGINE_API AK::MemoryArena::AkMemoryArena * GetMemoryArena(AkMemoryMgrArena in_eArena)

Helper to fetch each the arena. Should only be used for debug purposes, e.g. profiling,...

AkMemDebugRealloc

void(* AkMemDebugRealloc)(AkMemPoolId poolId, void *pOldAddress, size_t uSize, void *pNewAddress, char const *pszFile, AkUInt32 uLine)

Definition: AkMemoryMgrModule.h:104

AK::MemoryMgr::VerifyMemoryArenaIntegrity

AKSOUNDENGINE_API void VerifyMemoryArenaIntegrity(AkMemoryMgrArena in_eArena)

AK::MemoryMgr::AkCrtAllocatorFree

AKSOUNDENGINE_API void AkCrtAllocatorFree(AkMemPoolId poolId, void *pAddress)

AkMemSettings::pfReallocAligned

AkMemReallocAligned pfReallocAligned

(Optional) Memory allocation hook.

Definition: AkMemoryMgrModule.h:158

AK::MemoryMgr::AkCrtAllocatorRealloc

AKSOUNDENGINE_API void * AkCrtAllocatorRealloc(AkMemPoolId poolId, void *pAddress, size_t uSize)

AkMemTotalReservedMemorySize

size_t(* AkMemTotalReservedMemorySize)()

Definition: AkMemoryMgrModule.h:79

AK::MemoryMgr::AkCrtAllocatorSizeOfMemory

AKSOUNDENGINE_API size_t AkCrtAllocatorSizeOfMemory(AkMemPoolId poolID, void *pAddress)

AkMemSettings::tempAllocSettings

AK::TempAlloc::InitSettings tempAllocSettings[AK::TempAlloc::Type_NUM]

Configuration of behavior for the temporary-memory pools. For more information, see Tuning "Temp Allo...

Definition: AkMemoryMgrModule.h:167

AK::MemoryMgr::AkMemDebugToolReallocAligned

AKSOUNDENGINE_API void AkMemDebugToolReallocAligned(AkMemPoolId poolId, void *pOldAddress, size_t uSize, AkUInt32 uAlignment, void *pNewAddress, char const *pszFile, AkUInt32 uLine)

AkMemSettings

Definition: AkMemoryMgrModule.h:149

AK::MemoryMgr::GetDefaultSettings

AKSOUNDENGINE_API void GetDefaultSettings(AkMemSettings &out_pMemSettings)

Obtain the default initialization settings for the default implementation of the Memory Manager.

AkMemoryArenaTypes.h

AkMemoryMgrArena_Primary

@ AkMemoryMgrArena_Primary

Definition: AkMemoryMgrModule.h:131

AkMemDebugMalign

void(* AkMemDebugMalign)(AkMemPoolId poolId, size_t uSize, AkUInt32 uAlignment, void *pAddress, char const *pszFile, AkUInt32 uLine)

Definition: AkMemoryMgrModule.h:95

AkMemSettings::uMemoryDebugLevel

AkUInt32 uMemoryDebugLevel

Default 0 disabled. 1 debug enabled. 2 stomp allocator enabled. 3 stomp allocator and debug enabled....

Definition: AkMemoryMgrModule.h:178

AK::MemoryMgr::AkCrtAllocatorMalloc

AKSOUNDENGINE_API void * AkCrtAllocatorMalloc(AkMemPoolId poolId, size_t uSize)

AKSOUNDENGINE_CALL

#define AKSOUNDENGINE_CALL

Calling convention for the Wwise API.

Definition: AkTypes.h:102

AK::BookmarkAlloc::InitSettings

Definition: AkTempAllocDefs.h:134

AkMemoryMgr.h

AkMemSettings::pfTotalReservedMemorySize

AkMemTotalReservedMemorySize pfTotalReservedMemorySize

(Optional) Memory allocation statistics hook.

Definition: AkMemoryMgrModule.h:160

AkMemSettings::pfMalloc

AkMemMalloc pfMalloc

(Optional) Memory allocation hook.

Definition: AkMemoryMgrModule.h:155

AkMemTrimForThread

void(* AkMemTrimForThread)()

Definition: AkMemoryMgrModule.h:46

AK::TempAlloc::Type_NUM

@ Type_NUM

Definition: AkTempAllocDefs.h:65

AK::MemoryMgr::AkCrtAllocatorTermForThread

AKSOUNDENGINE_API void AkCrtAllocatorTermForThread()

AK::TempAlloc::InitSettings

Definition: AkTempAllocDefs.h:79

AkMemoryMgrArena_Profiler

@ AkMemoryMgrArena_Profiler

Definition: AkMemoryMgrModule.h:133

AkMemoryMgrArena_NUM

@ AkMemoryMgrArena_NUM

Definition: AkMemoryMgrModule.h:135

AkMemFree

void(* AkMemFree)(AkMemPoolId poolId, void *pAddress)

Definition: AkMemoryMgrModule.h:74

AkMemDebugReallocAligned

void(* AkMemDebugReallocAligned)(AkMemPoolId poolId, void *pOldAddress, size_t uSize, AkUInt32 uAlignment, void *pNewAddress, char const *pszFile, AkUInt32 uLine)

Definition: AkMemoryMgrModule.h:113

AkTypes.h

AkMemSettings::pfDebugMalloc

AkMemDebugMalloc pfDebugMalloc

(Optional) Memory allocation debugging hook. Used for tracking calls to pfMalloc.

Definition: AkMemoryMgrModule.h:173

AkMemoryMgrArena_Media

@ AkMemoryMgrArena_Media

Definition: AkMemoryMgrModule.h:132

AkUInt32

uint32_t AkUInt32

Unsigned 32-bit integer.

Definition: AkNumeralTypes.h:38

AkMemReallocAligned

void *(* AkMemReallocAligned)(AkMemPoolId poolId, void *pAddress, size_t uSize, AkUInt32 uAlignment)

Definition: AkMemoryMgrModule.h:67

AkMemoryMgrArena_Device

@ AkMemoryMgrArena_Device

Definition: AkMemoryMgrModule.h:134

AK::MemoryMgr::AkCrtAllocatorTotalReservedMemorySize

AKSOUNDENGINE_API size_t AkCrtAllocatorTotalReservedMemorySize()

AkTempAllocDefs.h

AK::MemoryMgr::AkCrtAllocatorTrimForThread

AKSOUNDENGINE_API void AkCrtAllocatorTrimForThread()

AkMemDebugFree

void(* AkMemDebugFree)(AkMemPoolId poolId, void *pAddress)

Definition: AkMemoryMgrModule.h:123

AkMemDebugMalloc

void(* AkMemDebugMalloc)(AkMemPoolId poolId, size_t uSize, void *pAddress, char const *pszFile, AkUInt32 uLine)

Definition: AkMemoryMgrModule.h:87

AkMemMalign

void *(* AkMemMalign)(AkMemPoolId poolId, size_t uSize, AkUInt32 uAlignment)

Definition: AkMemoryMgrModule.h:54

AkMemSettings::pfDebugFree

AkMemDebugFree pfDebugFree

(Optional) Memory allocation debugging hook. Used for tracking calls to pfFree.

Definition: AkMemoryMgrModule.h:177

AkMemSettings::pfSizeOfMemory

AkMemSizeOfMemory pfSizeOfMemory

(Optional) Memory allocation statistics hook.

Definition: AkMemoryMgrModule.h:161

AkMemSettings::pfDebugMalign

AkMemDebugMalign pfDebugMalign

(Optional) Memory allocation debugging hook. Used for tracking calls to pfMalign.

Definition: AkMemoryMgrModule.h:174

AK::MemoryMgr::AkMemDebugToolRealloc

AKSOUNDENGINE_API void AkMemDebugToolRealloc(AkMemPoolId poolId, void *pOldAddress, size_t uSize, void *pNewAddress, char const *pszFile, AkUInt32 uLine)

AK::MemoryMgr::AkCrtAllocatorReallocAligned

AKSOUNDENGINE_API void * AkCrtAllocatorReallocAligned(AkMemPoolId poolId, void *pAddress, size_t uSize, AkUInt32 uAlignment)

AkMemMalloc

void *(* AkMemMalloc)(AkMemPoolId poolId, size_t uSize)

Definition: AkMemoryMgrModule.h:49

Was this page helpful?

Need Support?

Questions? Problems? Need more info? Contact us, and we can help!

Visit our Support page

Tell us about your project. We're here to help.

Get started with Wwise

Wwise SDK