_ak_module_8h

Wwise SDK 2022.1.18

 /*******************************************************************************
 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/AkTypes.h>
 #include <AK/SoundEngine/Common/AkMemoryMgr.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
     );
  
 typedef void* ( *AkMemAllocVM ) (
     size_t size,
     size_t* extra
     );
  
 typedef void ( *AkMemFreeVM ) (
     void* address,
     size_t size,
     size_t extra,
     size_t release
     );
  
 enum AkSpanCount
 {
     // Span count attempts to be as low as possible. Offers lowest memory usage, but reduces CPU performance due to increased calls to pfAllocVM and other memory allocation hooks.
     AkSpanCount_Small = 0,
  
     // Span count attempts to match 512KiB mappings. Offers moderate balance between memory and CPU usage.
     AkSpanCount_Medium,
  
     // Span count attempts to match 2MiB, or AK_VM_HUGE_PAGE_SIZE, mappings. Offers best overall CPU performance due to use of 2MiB page mappings, but increased memory usage.
     AkSpanCount_Huge,
  
     AkSpanCount_END,
 };
  
 /// 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 rpmalloc.
     //@{
     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.
     //@{
     AkUInt64                        uMemAllocationSizeLimit;        ///< When non-zero, limits the total amount of virtual and device memory allocated by AK::MemoryMgr.
     bool                            bUseDeviceMemAlways;            ///< Use device memory for all allocations (on applicable platforms).
     //@}
  
     /// @name Page allocation hooks, used by rpmalloc. Default to AKPLATFORM::AllocVM et al.
     //@{
     AkMemAllocVM                    pfAllocVM;                      ///< Virtual page allocation hook.
     AkMemFreeVM                     pfFreeVM;                       ///< Virtual page allocation hook.
     AkMemAllocVM                    pfAllocDevice;                  ///< Device page allocation hook.
     AkMemFreeVM                     pfFreeDevice;                   ///< Device page allocation hook.
     AkUInt32                        uVMPageSize;                    ///< Virtual memory page size. Defaults to 0 which means auto-detect.
     AkUInt32                        uDevicePageSize;                ///< Device memory page size. Defaults to 0 which means auto-detect.
     AkUInt32                        uMaxThreadLocalHeapAllocSize;   ///< All memory allocations of sizes larger than this value will go to a global heap shared across all threads. Defaults to 0 which means all allocations go to a global heap. 
     //@}
  
     /// @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.
     //@}
  
     // Moved to end-of-struct to maintain stability across 2022.1 modules.
     AkMemTrimForThread              pfTrimForThread;                ///< (Optional) Thread-specific allocator "trimming" hook.
     AkSpanCount                     uVMSpanCount;                   ///< Virtual memory span count for each map operation in rpmalloc. Defaults to AkSpanCount_Huge. For more information, refer to \ref goingfurther_optimizingmempools_spancount.
     AkSpanCount                     uDeviceSpanCount;               ///< Device memory span count for each map operation in rpmalloc. Defaults to AkSpanCount_Huge. For more information, refer to \ref goingfurther_optimizingmempools_spancount.
 };
 //@}
  
 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.
     );
  
 }
  
 }
  
 #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
     );
  
 //@}
  
 }
  
 }

AkMemDebugMalloc

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

Definition: AkModule.h:85

AK::MemoryMgr::AkMemDebugToolInit

AKSOUNDENGINE_API AKRESULT AkMemDebugToolInit()

Audiokinetic namespace

Definition: AkWwiseSDKVersion.cs:31

AkMemSettings::pfTermForThread

AkMemTermForThread pfTermForThread

(Optional) Thread-specific allocator termination hook.

Definition: AkModule.h:159

AkMemInitForThread

void(* AkMemInitForThread)()

Definition: AkModule.h:38

AkSpanCount_Medium

@ AkSpanCount_Medium

Definition: AkModule.h:144

AK::MemoryMgr::AkMemDebugToolMalloc

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

AkMemSettings::uMaxThreadLocalHeapAllocSize

AkUInt32 uMaxThreadLocalHeapAllocSize

All memory allocations of sizes larger than this value will go to a global heap shared across all thr...

Definition: AkModule.h:184

AkMemSettings::pfInitForThread

AkMemInitForThread pfInitForThread

(Optional) Thread-specific allocator initialization hook.

Definition: AkModule.h:158

AkMemSettings::pfFree

AkMemFree pfFree

(Optional) Memory allocation hook.

Definition: AkModule.h:165

AkMemSettings::pfMalign

AkMemMalign pfMalign

(Optional) Memory allocation hook.

Definition: AkModule.h:162

AK::MemoryMgr::Init

AKSOUNDENGINE_API AKRESULT Init(AkMemSettings *in_pSettings)

AkSpanCount

Definition: AkModule.h:139

AK::MemoryMgr::AkStompAllocatorFree

AKSOUNDENGINE_API void AkStompAllocatorFree(AkMemPoolId poolId, void *pAddress)

AK::MemoryMgr::AkCrtAllocatorInitForThread

AKSOUNDENGINE_API void AkCrtAllocatorInitForThread()

AkMemSettings::uVMSpanCount

AkSpanCount uVMSpanCount

Virtual memory span count for each map operation in rpmalloc. Defaults to AkSpanCount_Huge....

Definition: AkModule.h:199

AK::MemoryMgr::AkStompAllocatorMalloc

AKSOUNDENGINE_API void * AkStompAllocatorMalloc(AkMemPoolId poolId, size_t uSize)

AK_EXTERNAPIFUNC

#define AK_EXTERNAPIFUNC(_type, _name)

Definition: AkSoundEngineExport.h:81

AkMemSettings::pfRealloc

AkMemRealloc pfRealloc

(Optional) Memory allocation hook.

Definition: AkModule.h:163

AkMemSettings::pfFreeVM

AkMemFreeVM pfFreeVM

Virtual page allocation hook.

Definition: AkModule.h:179

AKRESULT

Standard function call result.

Definition: AkTypes.h:199

AkMemRealloc

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

Definition: AkModule.h:58

AK::MemoryMgr::AkMemDebugToolFree

AKSOUNDENGINE_API void AkMemDebugToolFree(AkMemPoolId poolId, void *pAddress)

AkSpanCount_Huge

@ AkSpanCount_Huge

Definition: AkModule.h:147

AkMemPoolId

AkInt32 AkMemPoolId

Memory pool ID

Definition: AkTypes.h:130

AkMemSettings::pfDebugRealloc

AkMemDebugRealloc pfDebugRealloc

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

Definition: AkModule.h:191

AkMemDebugRealloc

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

Definition: AkModule.h:102

AkMemAllocVM

void *(* AkMemAllocVM)(size_t size, size_t *extra)

Definition: AkModule.h:126

AkMemSettings::pfDebugReallocAligned

AkMemDebugReallocAligned pfDebugReallocAligned

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

Definition: AkModule.h:192

AkMemReallocAligned

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

Definition: AkModule.h:65

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.

Definition: AkModule.h:198

AK::MemoryMgr::AkMemDebugToolMalign

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

AkMemMalloc

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

Definition: AkModule.h:47

AK::MemoryMgr::AkStompAllocatorTermForThread

AKSOUNDENGINE_API void AkStompAllocatorTermForThread()

AK::MemoryMgr::AkCrtAllocatorFree

AKSOUNDENGINE_API void AkCrtAllocatorFree(AkMemPoolId poolId, void *pAddress)

AkMemSettings::pfReallocAligned

AkMemReallocAligned pfReallocAligned

(Optional) Memory allocation hook.

Definition: AkModule.h:164

AkMemSettings::pfFreeDevice

AkMemFreeVM pfFreeDevice

Device page allocation hook.

Definition: AkModule.h:181

AkMemTotalReservedMemorySize

size_t(* AkMemTotalReservedMemorySize)()

Definition: AkModule.h:77

AK::MemoryMgr::AkStompAllocatorRealloc

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

AkMemSettings::pfAllocVM

AkMemAllocVM pfAllocVM

Virtual page allocation hook.

Definition: AkModule.h:178

AK::MemoryMgr::AkCrtAllocatorRealloc

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

AkMemTermForThread

void(* AkMemTermForThread)()

Definition: AkModule.h:41

AkMemSettings::uMemAllocationSizeLimit

AkUInt64 uMemAllocationSizeLimit

When non-zero, limits the total amount of virtual and device memory allocated by AK::MemoryMgr.

Definition: AkModule.h:172

AkMemDebugReallocAligned

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

Definition: AkModule.h:111

AK::MemoryMgr::AkStompAllocatorInitForThread

AKSOUNDENGINE_API void AkStompAllocatorInitForThread()

AK::MemoryMgr::AkCrtAllocatorSizeOfMemory

AKSOUNDENGINE_API size_t AkCrtAllocatorSizeOfMemory(AkMemPoolId poolID, void *pAddress)

AkMemTrimForThread

void(* AkMemTrimForThread)()

Definition: AkModule.h:44

AkMemFree

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

Definition: AkModule.h:72

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: AkModule.h:155

AK::MemoryMgr::GetDefaultSettings

AKSOUNDENGINE_API void GetDefaultSettings(AkMemSettings &out_pMemSettings)

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

AkMemMalign

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

Definition: AkModule.h:52

AkMemSettings::uMemoryDebugLevel

AkUInt32 uMemoryDebugLevel

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

Definition: AkModule.h:194

AkMemSettings::uDeviceSpanCount

AkSpanCount uDeviceSpanCount

Device memory span count for each map operation in rpmalloc. Defaults to AkSpanCount_Huge....

Definition: AkModule.h:200

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:118

AkMemoryMgr.h

AkMemSettings::uDevicePageSize

AkUInt32 uDevicePageSize

Device memory page size. Defaults to 0 which means auto-detect.

Definition: AkModule.h:183

AkMemSettings::pfTotalReservedMemorySize

AkMemTotalReservedMemorySize pfTotalReservedMemorySize

(Optional) Memory allocation statistics hook.

Definition: AkModule.h:166

AK::MemoryMgr::AkStompAllocatorReallocAligned

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

AkMemSettings::pfMalloc

AkMemMalloc pfMalloc

(Optional) Memory allocation hook.

Definition: AkModule.h:161

AkSpanCount_Small

@ AkSpanCount_Small

Definition: AkModule.h:141

AK::MemoryMgr::AkCrtAllocatorTermForThread

AKSOUNDENGINE_API void AkCrtAllocatorTermForThread()

AK::MemoryMgr::AkStompAllocatorMalign

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

AkUInt64

uint64_t AkUInt64

Unsigned 64-bit integer

Definition: AkNumeralTypes.h:39

AkTypes.h

AkMemFreeVM

void(* AkMemFreeVM)(void *address, size_t size, size_t extra, size_t release)

Definition: AkModule.h:131

AK::MemoryMgr::AkStompAllocatorTrimForThread

AKSOUNDENGINE_API void AkStompAllocatorTrimForThread()

AkMemSettings::pfDebugMalloc

AkMemDebugMalloc pfDebugMalloc

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

Definition: AkModule.h:189

AK::MemoryMgr::AkStompAllocatorTotalReservedMemorySize

AKSOUNDENGINE_API size_t AkStompAllocatorTotalReservedMemorySize()

AkSpanCount_END

@ AkSpanCount_END

Definition: AkModule.h:149

AkUInt32

uint32_t AkUInt32

Unsigned 32-bit integer

Definition: AkNumeralTypes.h:38

AkMemSizeOfMemory

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

Definition: AkModule.h:80

AkMemSettings::uVMPageSize

AkUInt32 uVMPageSize

Virtual memory page size. Defaults to 0 which means auto-detect.

Definition: AkModule.h:182

AkMemDebugMalign

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

Definition: AkModule.h:93

AK::MemoryMgr::AkCrtAllocatorTotalReservedMemorySize

AKSOUNDENGINE_API size_t AkCrtAllocatorTotalReservedMemorySize()

AK::MemoryMgr::AkCrtAllocatorTrimForThread

AKSOUNDENGINE_API void AkCrtAllocatorTrimForThread()

AkMemDebugFree

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

Definition: AkModule.h:121

AkMemSettings::pfDebugFree

AkMemDebugFree pfDebugFree

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

Definition: AkModule.h:193

AkMemSettings::pfSizeOfMemory

AkMemSizeOfMemory pfSizeOfMemory

(Optional) Memory allocation statistics hook.

Definition: AkModule.h:167

AkMemSettings::pfDebugMalign

AkMemDebugMalign pfDebugMalign

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

Definition: AkModule.h:190

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)

AK::MemoryMgr::AkStompAllocatorSizeOfMemory

AKSOUNDENGINE_API size_t AkStompAllocatorSizeOfMemory(AkMemPoolId poolID, void *pAddress)

AkMemSettings::pfAllocDevice

AkMemAllocVM pfAllocDevice

Device page allocation hook.

Definition: AkModule.h:180

AkMemSettings::bUseDeviceMemAlways

bool bUseDeviceMemAlways

Use device memory for all allocations (on applicable platforms).

Definition: AkModule.h:173