_ak_module_8h

Wwise SDK 2023.1.9

 /*******************************************************************************
 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                            bEnableSeparateDeviceHeap;      ///< Enable use of device memory heap for all allocations (on applicable platforms).
     AK::TempAlloc::InitSettings     tempAllocSettings[AK::TempAlloc::Type_NUM]; ///< Configuration of behavior for the temporary-memory pools. For more information, see \ref goingfurther_optimizingmempools_tempallocs.
     //@}
  
     /// @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.
     //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.
     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 2023.1 modules.
     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:187

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

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

AKRESULT

Standard function call result.

Definition: AkTypes.h:131

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

AkMemSettings::pfDebugRealloc

AkMemDebugRealloc pfDebugRealloc

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

Definition: AkModule.h:194

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

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. Used to relinquish memory resources when thread...

Definition: AkModule.h:160

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

AkMemTotalReservedMemorySize

size_t(* AkMemTotalReservedMemorySize)()

Definition: AkModule.h:77

AkMemSettings::pfAllocVM

AkMemAllocVM pfAllocVM

Virtual page allocation hook.

Definition: AkModule.h:179

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

AKSOUNDENGINE_API size_t AkCrtAllocatorSizeOfMemory(AkMemPoolId poolID, void *pAddress)

AkMemTrimForThread

void(* AkMemTrimForThread)()

Definition: AkModule.h:44

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

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.

AkMemSettings::bEnableSeparateDeviceHeap

bool bEnableSeparateDeviceHeap

Enable use of device memory heap for all allocations (on applicable platforms).

Definition: AkModule.h:173

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

AkMemSettings::uDeviceSpanCount

AkSpanCount uDeviceSpanCount

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

Definition: AkModule.h:202

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

AkMemoryMgr.h

AkMemSettings::uDevicePageSize

AkUInt32 uDevicePageSize

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

Definition: AkModule.h:184

AkMemSettings::pfTotalReservedMemorySize

AkMemTotalReservedMemorySize pfTotalReservedMemorySize

(Optional) Memory allocation statistics hook.

Definition: AkModule.h:166

AkMemSettings::pfMalloc

AkMemMalloc pfMalloc

(Optional) Memory allocation hook.

Definition: AkModule.h:161

AK::TempAlloc::Type_NUM

@ Type_NUM

Definition: AkMemoryMgr.h:338

AkSpanCount_Small

@ AkSpanCount_Small

Definition: AkModule.h:141

AK::MemoryMgr::AkCrtAllocatorTermForThread

AKSOUNDENGINE_API void AkCrtAllocatorTermForThread()

AK::TempAlloc::InitSettings

Initialization settings for temporary-memory pools. Separate settings are specified for each temporar...

Definition: AkMemoryMgr.h:343

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

AkMemSettings::pfDebugMalloc

AkMemDebugMalloc pfDebugMalloc

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

Definition: AkModule.h:192

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

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

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

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)

AkMemSettings::pfAllocDevice

AkMemAllocVM pfAllocDevice

Device page allocation hook.

Definition: AkModule.h:181

此页面对您是否有帮助？

需要技术支持？

仍有疑问？或者问题？需要更多信息？欢迎联系我们，我们可以提供帮助！

查看我们的“技术支持”页面

介绍一下自己的项目。我们会竭力为您提供帮助。

来注册自己的项目，我们帮您快速入门，不带任何附加条件！

开始 Wwise 之旅

Wwise SDK

_ak_module_8h_source

此页面对您是否有帮助？

需要技术支持？

介绍一下自己的项目。我们会竭力为您提供帮助。