565 lines
18 KiB
C
565 lines
18 KiB
C
/****************************************************************************
|
|
*
|
|
* The MIT License (MIT)
|
|
*
|
|
* Copyright (c) 2014 Vivante Corporation
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
* DEALINGS IN THE SOFTWARE.
|
|
*
|
|
*****************************************************************************
|
|
*
|
|
* The GPL License (GPL)
|
|
*
|
|
* Copyright (C) 2014 Vivante Corporation
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*
|
|
*****************************************************************************
|
|
*
|
|
* Note: This software is released under dual MIT and GPL licenses. A
|
|
* recipient may use this file under the terms of either the MIT license or
|
|
* GPL License. If you wish to use only one license not the other, you can
|
|
* indicate your decision by deleting one of the above license notices in your
|
|
* version of this file.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
|
|
/*
|
|
** Include file for the local memory management.
|
|
*/
|
|
|
|
#ifndef __gc_hal_mem_h_
|
|
#define __gc_hal_mem_h_
|
|
#if (gcdENABLE_3D || gcdENABLE_VG)
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/*******************************************************************************
|
|
** Usage:
|
|
|
|
The macros to declare MemPool type and functions are
|
|
gcmMEM_DeclareFSMemPool (Type, TypeName, Prefix)
|
|
gcmMEM_DeclareVSMemPool (Type, TypeName, Prefix)
|
|
gcmMEM_DeclareAFSMemPool(Type, TypeName, Prefix)
|
|
|
|
The data structures for MemPool are
|
|
typedef struct _gcsMEM_FS_MEM_POOL * gcsMEM_FS_MEM_POOL;
|
|
typedef struct _gcsMEM_VS_MEM_POOL * gcsMEM_VS_MEM_POOL;
|
|
typedef struct _gcsMEM_AFS_MEM_POOL * gcsMEM_AFS_MEM_POOL;
|
|
|
|
The MemPool constructor and destructor functions are
|
|
gcfMEM_InitFSMemPool(gcsMEM_FS_MEM_POOL *, gcoOS, gctUINT, gctUINT);
|
|
gcfMEM_FreeFSMemPool(gcsMEM_FS_MEM_POOL *);
|
|
gcfMEM_InitVSMemPool(gcsMEM_VS_MEM_POOL *, gcoOS, gctUINT, gctBOOL);
|
|
gcfMEM_FreeVSMemPool(gcsMEM_VS_MEM_POOL *);
|
|
gcfMEM_InitAFSMemPool(gcsMEM_AFS_MEM_POOL *, gcoOS, gctUINT);
|
|
gcfMEM_FreeAFSMemPool(gcsMEM_AFS_MEM_POOL *);
|
|
|
|
FS: for Fixed-Size data structures
|
|
VS: for Variable-size data structures
|
|
AFS: for Array of Fixed-Size data structures
|
|
|
|
|
|
// Example 1: For a fixed-size data structure, struct gcsNode.
|
|
// It is used locally in a file, so the functions are static without prefix.
|
|
// At top level, declear allocate and free functions.
|
|
// The first argument is the data type.
|
|
// The second armument is the short name used in the fuctions.
|
|
gcmMEM_DeclareFSMemPool(struct gcsNode, Node, );
|
|
|
|
// The previous macro creates two inline functions,
|
|
// _AllocateNode and _FreeNode.
|
|
|
|
// In function or struct
|
|
gcsMEM_FS_MEM_POOL nodeMemPool;
|
|
|
|
// In function,
|
|
struct gcsNode * node;
|
|
gceSTATUS status;
|
|
|
|
// Before using the memory pool, initialize it.
|
|
// The second argument is the gcoOS object.
|
|
// The third argument is the number of data structures to allocate for each chunk.
|
|
status = gcfMEM_InitFSMemPool(&nodeMemPool, os, 100, sizeof(struct gcsNode));
|
|
...
|
|
|
|
// Allocate a node.
|
|
status = _AllocateNode(nodeMemPool, &node);
|
|
...
|
|
// Free a node.
|
|
_FreeNode(nodeMemPool, node);
|
|
|
|
// After using the memory pool, free it.
|
|
gcfMEM_FreeFSMemPool(&nodeMemPool);
|
|
|
|
|
|
// Example 2: For array of fixed-size data structures, struct gcsNode.
|
|
// It is used in several files, so the functions are extern with prefix.
|
|
// At top level, declear allocate and free functions.
|
|
// The first argument is the data type, and the second one is the short name
|
|
// used in the fuctions.
|
|
gcmMEM_DeclareAFSMemPool(struct gcsNode, NodeArray, gcfOpt);
|
|
|
|
// The previous macro creates two inline functions,
|
|
// gcfOpt_AllocateNodeArray and gcfOpt_FreeNodeArray.
|
|
|
|
// In function or struct
|
|
gcsMEM_AFS_MEM_POOL nodeArrayMemPool;
|
|
|
|
// In function,
|
|
struct gcsNode * nodeArray;
|
|
gceSTATUS status;
|
|
|
|
// Before using the array memory pool, initialize it.
|
|
// The second argument is the gcoOS object, the third is the number of data
|
|
// structures to allocate for each chunk.
|
|
status = gcfMEM_InitAFSMemPool(&nodeArrayMemPool, os, sizeof(struct gcsNode));
|
|
...
|
|
|
|
// Allocate a node array of size 100.
|
|
status = gcfOpt_AllocateNodeArray(nodeArrayMemPool, &nodeArray, 100);
|
|
...
|
|
// Free a node array.
|
|
gcfOpt_FreeNodeArray(&nodeArrayMemPool, nodeArray);
|
|
|
|
// After using the array memory pool, free it.
|
|
gcfMEM_FreeAFSMemPool(&nodeArrayMemPool);
|
|
|
|
*******************************************************************************/
|
|
|
|
/*******************************************************************************
|
|
** To switch back to use gcoOS_Allocate and gcoOS_Free, add
|
|
** #define USE_LOCAL_MEMORY_POOL 0
|
|
** before including this file.
|
|
*******************************************************************************/
|
|
#ifndef USE_LOCAL_MEMORY_POOL
|
|
/*
|
|
USE_LOCAL_MEMORY_POOL
|
|
|
|
This define enables the local memory management to improve performance.
|
|
*/
|
|
#define USE_LOCAL_MEMORY_POOL 1
|
|
#endif
|
|
|
|
/*******************************************************************************
|
|
** Memory Pool Data Structures
|
|
*******************************************************************************/
|
|
#if USE_LOCAL_MEMORY_POOL
|
|
typedef struct _gcsMEM_FS_MEM_POOL * gcsMEM_FS_MEM_POOL;
|
|
typedef struct _gcsMEM_VS_MEM_POOL * gcsMEM_VS_MEM_POOL;
|
|
typedef struct _gcsMEM_AFS_MEM_POOL * gcsMEM_AFS_MEM_POOL;
|
|
#else
|
|
typedef gcoOS gcsMEM_FS_MEM_POOL;
|
|
typedef gcoOS gcsMEM_VS_MEM_POOL;
|
|
typedef gcoOS gcsMEM_AFS_MEM_POOL;
|
|
#endif
|
|
|
|
/*******************************************************************************
|
|
** Memory Pool Macros
|
|
*******************************************************************************/
|
|
#if USE_LOCAL_MEMORY_POOL
|
|
#define gcmMEM_DeclareFSMemPool(Type, TypeName, Prefix) \
|
|
gceSTATUS \
|
|
Prefix##_Allocate##TypeName( \
|
|
gcsMEM_FS_MEM_POOL MemPool, \
|
|
Type ** Pointer \
|
|
) \
|
|
{ \
|
|
return(gcfMEM_FSMemPoolGetANode(MemPool, (gctPOINTER *) Pointer)); \
|
|
} \
|
|
\
|
|
gceSTATUS \
|
|
Prefix##_CAllocate##TypeName( \
|
|
gcsMEM_FS_MEM_POOL MemPool, \
|
|
Type ** Pointer \
|
|
) \
|
|
{ \
|
|
gceSTATUS status; \
|
|
gcmHEADER_ARG("MemPool=0x%x Pointer=0x%x", MemPool, Pointer); \
|
|
gcmERR_RETURN(gcfMEM_FSMemPoolGetANode(MemPool, (gctPOINTER *) Pointer)); \
|
|
gcoOS_ZeroMemory(*(gctPOINTER *) Pointer, gcmSIZEOF(Type)); \
|
|
gcmFOOTER(); \
|
|
return gcvSTATUS_OK; \
|
|
} \
|
|
\
|
|
gceSTATUS \
|
|
Prefix##_Free##TypeName( \
|
|
gcsMEM_FS_MEM_POOL MemPool, \
|
|
Type * Pointer \
|
|
) \
|
|
{ \
|
|
gceSTATUS status; \
|
|
gcmHEADER_ARG("MemPool=0x%x Pointer=0x%x", MemPool, Pointer); \
|
|
status = gcfMEM_FSMemPoolFreeANode(MemPool, (gctPOINTER) Pointer); \
|
|
gcmFOOTER(); \
|
|
return status; \
|
|
} \
|
|
\
|
|
gceSTATUS \
|
|
Prefix##_Free##TypeName##List( \
|
|
gcsMEM_FS_MEM_POOL MemPool, \
|
|
Type * FirstPointer, \
|
|
Type * LastPointer \
|
|
) \
|
|
{ \
|
|
gceSTATUS status; \
|
|
gcmHEADER_ARG("MemPool=0x%x FirstPointer=0x%x LastPointer=0x%x", MemPool, FirstPointer, LastPointer); \
|
|
status = gcfMEM_FSMemPoolFreeAList(MemPool, (gctPOINTER) FirstPointer, (gctPOINTER) LastPointer); \
|
|
gcmFOOTER(); \
|
|
return status; \
|
|
}
|
|
|
|
#define gcmMEM_DeclareVSMemPool(Type, TypeName, Prefix) \
|
|
gceSTATUS \
|
|
Prefix##_Allocate##TypeName( \
|
|
gcsMEM_FS_MEM_POOL MemPool, \
|
|
Type ** Pointer, \
|
|
gctUINT Size \
|
|
) \
|
|
{ \
|
|
gceSTATUS status;\
|
|
gcmHEADER_ARG("MemPool=0x%x Pointer=0x%x Size=%u", MemPool, Pointer, Size); \
|
|
status = gcfMEM_VSMemPoolGetANode(MemPool, Size, (gctPOINTER *) Pointer); \
|
|
gcmFOOTER(); \
|
|
return status; \
|
|
} \
|
|
\
|
|
gceSTATUS \
|
|
Prefix##_CAllocate##TypeName( \
|
|
gcsMEM_FS_MEM_POOL MemPool, \
|
|
Type ** Pointer, \
|
|
gctUINT Size \
|
|
) \
|
|
{ \
|
|
gceSTATUS status; \
|
|
gcmHEADER_ARG("MemPool=0x%x Pointer=0x%x Size=%u", MemPool, Pointer, Size); \
|
|
gcmERR_RETURN(gcfMEM_VSMemPoolGetANode(MemPool, Size, (gctPOINTER *) Pointer)); \
|
|
gcoOS_ZeroMemory(*(gctPOINTER *) Pointer, size); \
|
|
gcmFOOTER(); \
|
|
return gcvSTATUS_OK; \
|
|
} \
|
|
\
|
|
gceSTATUS \
|
|
Prefix##_Free##TypeName( \
|
|
gcsMEM_FS_MEM_POOL MemPool, \
|
|
Type * Pointer \
|
|
) \
|
|
{ \
|
|
gceSTATUS status; \
|
|
gcmHEADER_ARG("MemPool=0x%x Pointer=0x%x", MemPool, Pinter); \
|
|
status = gcfMEM_VSMemPoolFreeANode(MemPool, (gctPOINTER) Pointer); \
|
|
gcmFOOTER(); \
|
|
return status; \
|
|
}
|
|
|
|
#define gcmMEM_DeclareAFSMemPool(Type, TypeName, Prefix) \
|
|
gceSTATUS \
|
|
Prefix##_Allocate##TypeName( \
|
|
gcsMEM_AFS_MEM_POOL MemPool, \
|
|
Type ** Pointer, \
|
|
gctUINT Count \
|
|
) \
|
|
{ \
|
|
gceSTATUS status; \
|
|
gcmHEADER_ARG("MemPool=0x%x Pointer=0x%x Count=%u", MemPool, Pointer, Count); \
|
|
status = gcfMEM_AFSMemPoolGetANode(MemPool, Count, (gctPOINTER *) Pointer); \
|
|
gcmFOOTER(); \
|
|
return status; \
|
|
} \
|
|
\
|
|
gceSTATUS \
|
|
Prefix##_CAllocate##TypeName( \
|
|
gcsMEM_AFS_MEM_POOL MemPool, \
|
|
Type ** Pointer, \
|
|
gctUINT Count \
|
|
) \
|
|
{ \
|
|
gceSTATUS status; \
|
|
gcmHEADER_ARG("MemPool=0x%x Pointer=0x%x Count=%u", MemPool, Pointer, Count); \
|
|
gcmERR_RETURN(gcfMEM_AFSMemPoolGetANode(MemPool, Count, (gctPOINTER *) Pointer)); \
|
|
gcoOS_ZeroMemory(*(gctPOINTER *) Pointer, Count * gcmSIZEOF(Type)); \
|
|
gcmFOOTER(); \
|
|
return gcvSTATUS_OK; \
|
|
} \
|
|
\
|
|
gceSTATUS \
|
|
Prefix##_Free##TypeName( \
|
|
gcsMEM_AFS_MEM_POOL MemPool, \
|
|
Type * Pointer \
|
|
) \
|
|
{ \
|
|
gceSTATUS status; \
|
|
gcmHEADER_ARG("MemPool=0x%x Pointer=0x%x", MemPool, Pointer); \
|
|
status = gcfMEM_AFSMemPoolFreeANode(MemPool, (gctPOINTER) Pointer); \
|
|
gcmFOOTER(); \
|
|
return status; \
|
|
}
|
|
|
|
#else
|
|
|
|
#define gcmMEM_DeclareFSMemPool(Type, TypeName, Prefix) \
|
|
gceSTATUS \
|
|
Prefix##_Allocate##TypeName( \
|
|
gcsMEM_FS_MEM_POOL MemPool, \
|
|
Type ** Pointer \
|
|
) \
|
|
{ \
|
|
gceSTATUS status; \
|
|
gcmHEADER_ARG("MemPool=0x%x Pointer=0x%x", MemPool, Pointer); \
|
|
status = gcoOS_Allocate(MemPool, \
|
|
gcmSIZEOF(Type), \
|
|
(gctPOINTER *) Pointer); \
|
|
gcmFOOTER(); \
|
|
return status; \
|
|
} \
|
|
\
|
|
gceSTATUS \
|
|
Prefix##_CAllocate##TypeName( \
|
|
gcsMEM_FS_MEM_POOL MemPool, \
|
|
Type ** Pointer \
|
|
) \
|
|
{ \
|
|
gceSTATUS status; \
|
|
gcmHEADER_ARG("MemPool=0x%x Pointer=0x%x", MemPool, Pointer); \
|
|
gcmERR_RETURN(gcoOS_Allocate(MemPool, \
|
|
gcmSIZEOF(Type), \
|
|
(gctPOINTER *) Pointer)); \
|
|
gcoOS_ZeroMemory(*(gctPOINTER *) Pointer, gcmSIZEOF(Type)); \
|
|
gcmFOOTER(); \
|
|
return gcvSTATUS_OK; \
|
|
} \
|
|
\
|
|
gceSTATUS \
|
|
Prefix##_Free##TypeName( \
|
|
gcsMEM_FS_MEM_POOL MemPool, \
|
|
Type * Pointer \
|
|
) \
|
|
{ \
|
|
gceSTATUS status; \
|
|
gcmHEADER_ARG("MemPool=0x%x Pointer=0x%x", MemPool, Pointer); \
|
|
status = gcmOS_SAFE_FREE(MemPool, Pointer); \
|
|
gcmFOOTER(); \
|
|
return status; \
|
|
}
|
|
|
|
#define gcmMEM_DeclareVSMemPool(Type, TypeName, Prefix) \
|
|
gceSTATUS \
|
|
Prefix##_Allocate##TypeName( \
|
|
gcsMEM_VS_MEM_POOL MemPool, \
|
|
Type ** Pointer, \
|
|
gctUINT Size \
|
|
) \
|
|
{ \
|
|
gceSTATUS status; \
|
|
gcmHEADER_ARG("MemPool=0x%x Pointer=0x%x Size=%u", MemPool, Pointer, Size); \
|
|
status = gcoOS_Allocate(MemPool, \
|
|
Size, \
|
|
(gctPOINTER *) Pointer); \
|
|
gcmFOOTER(); \
|
|
return status; \
|
|
} \
|
|
\
|
|
gceSTATUS \
|
|
Prefix##_CAllocate##TypeName( \
|
|
gcsMEM_VS_MEM_POOL MemPool, \
|
|
Type ** Pointer, \
|
|
gctUINT Size \
|
|
) \
|
|
{ \
|
|
gceSTATUS status; \
|
|
gcmHEADER_ARG("MemPool=0x%x Pointer=0x%x Size=%u", MemPool, Pointer, Size); \
|
|
gcmERR_RETURN(gcoOS_Allocate(MemPool, \
|
|
Size, \
|
|
(gctPOINTER *) Pointer)); \
|
|
gcoOS_ZeroMemory(*(gctPOINTER *) Pointer, Size); \
|
|
gcmFOOTER(); \
|
|
return gcvSTATUS_OK; \
|
|
} \
|
|
\
|
|
gceSTATUS \
|
|
Prefix##_Free##TypeName( \
|
|
gcsMEM_VS_MEM_POOL MemPool, \
|
|
Type * Pointer \
|
|
) \
|
|
{ \
|
|
gceSTATUS status; \
|
|
gcmHEADER_ARG("MemPool=0x%x Pointer=0x%x", MemPool, Pointer); \
|
|
status = gcmOS_SAFE_FREE(MemPool, Pointer); \
|
|
gcmFOOTER(); \
|
|
return status; \
|
|
}
|
|
|
|
#define gcmMEM_DeclareAFSMemPool(Type, TypeName, Prefix) \
|
|
gceSTATUS \
|
|
Prefix##_Allocate##TypeName( \
|
|
gcsMEM_AFS_MEM_POOL MemPool, \
|
|
Type ** Pointer, \
|
|
gctUINT Count \
|
|
) \
|
|
{ \
|
|
gceSTATUS status; \
|
|
gcmHEADER_ARG("MemPool=0x%x Pointer=0x%x Count=%u", MemPool, Pointer, Count); \
|
|
status = gcoOS_Allocate(MemPool, \
|
|
Count * gcmSIZEOF(Type), \
|
|
(gctPOINTER *) Pointer); \
|
|
gcmFOOTER(); \
|
|
return status; \
|
|
} \
|
|
\
|
|
gceSTATUS \
|
|
Prefix##_CAllocate##TypeName( \
|
|
gcsMEM_AFS_MEM_POOL MemPool, \
|
|
Type ** Pointer, \
|
|
gctUINT Count \
|
|
) \
|
|
{ \
|
|
gceSTATUS status; \
|
|
gcmHEADER_ARG("MemPool=0x%x Pointer=0x%x Count=%u", MemPool, Pointer, Count); \
|
|
gcmERR_RETURN(gcoOS_Allocate(MemPool, \
|
|
Count * gcmSIZEOF(Type), \
|
|
(gctPOINTER *) Pointer)); \
|
|
gcoOS_ZeroMemory(*(gctPOINTER *) Pointer, Count * gcmSIZEOF(Type)); \
|
|
gcmFOOTER(); \
|
|
return gcvSTATUS_OK; \
|
|
} \
|
|
\
|
|
gceSTATUS \
|
|
Prefix##_Free##TypeName( \
|
|
gcsMEM_AFS_MEM_POOL MemPool, \
|
|
Type * Pointer \
|
|
) \
|
|
{ \
|
|
gceSTATUS status; \
|
|
gcmHEADER_ARG("MemPool=0x%x Pointer=0x%x", MemPool, Pointer); \
|
|
status = gcmOS_SAFE_FREE(MemPool, Pointer); \
|
|
gcmFOOTER(); \
|
|
return status; \
|
|
}
|
|
#endif
|
|
|
|
/*******************************************************************************
|
|
** Memory Pool Data Functions
|
|
*******************************************************************************/
|
|
gceSTATUS
|
|
gcfMEM_InitFSMemPool(
|
|
IN gcsMEM_FS_MEM_POOL * MemPool,
|
|
IN gcoOS OS,
|
|
IN gctUINT NodeCount,
|
|
IN gctUINT NodeSize
|
|
);
|
|
|
|
gceSTATUS
|
|
gcfMEM_FreeFSMemPool(
|
|
IN gcsMEM_FS_MEM_POOL * MemPool
|
|
);
|
|
|
|
gceSTATUS
|
|
gcfMEM_FSMemPoolGetANode(
|
|
IN gcsMEM_FS_MEM_POOL MemPool,
|
|
OUT gctPOINTER * Node
|
|
);
|
|
|
|
gceSTATUS
|
|
gcfMEM_FSMemPoolFreeANode(
|
|
IN gcsMEM_FS_MEM_POOL MemPool,
|
|
IN gctPOINTER Node
|
|
);
|
|
|
|
gceSTATUS
|
|
gcfMEM_FSMemPoolFreeAList(
|
|
IN gcsMEM_FS_MEM_POOL MemPool,
|
|
IN gctPOINTER FirstNode,
|
|
IN gctPOINTER LastNode
|
|
);
|
|
|
|
gceSTATUS
|
|
gcfMEM_InitVSMemPool(
|
|
IN gcsMEM_VS_MEM_POOL * MemPool,
|
|
IN gcoOS OS,
|
|
IN gctUINT BlockSize,
|
|
IN gctBOOL RecycleFreeNode
|
|
);
|
|
|
|
gceSTATUS
|
|
gcfMEM_FreeVSMemPool(
|
|
IN gcsMEM_VS_MEM_POOL * MemPool
|
|
);
|
|
|
|
gceSTATUS
|
|
gcfMEM_VSMemPoolGetANode(
|
|
IN gcsMEM_VS_MEM_POOL MemPool,
|
|
IN gctUINT Size,
|
|
IN gctUINT Alignment,
|
|
OUT gctPOINTER * Node
|
|
);
|
|
|
|
gceSTATUS
|
|
gcfMEM_VSMemPoolFreeANode(
|
|
IN gcsMEM_VS_MEM_POOL MemPool,
|
|
IN gctPOINTER Node
|
|
);
|
|
|
|
gceSTATUS
|
|
gcfMEM_InitAFSMemPool(
|
|
IN gcsMEM_AFS_MEM_POOL *MemPool,
|
|
IN gcoOS OS,
|
|
IN gctUINT NodeCount,
|
|
IN gctUINT NodeSize
|
|
);
|
|
|
|
gceSTATUS
|
|
gcfMEM_FreeAFSMemPool(
|
|
IN gcsMEM_AFS_MEM_POOL *MemPool
|
|
);
|
|
|
|
gceSTATUS
|
|
gcfMEM_AFSMemPoolGetANode(
|
|
IN gcsMEM_AFS_MEM_POOL MemPool,
|
|
IN gctUINT Count,
|
|
OUT gctPOINTER * Node
|
|
);
|
|
|
|
gceSTATUS
|
|
gcfMEM_AFSMemPoolFreeANode(
|
|
IN gcsMEM_AFS_MEM_POOL MemPool,
|
|
IN gctPOINTER Node
|
|
);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* (gcdENABLE_3D || gcdENABLE_VG) */
|
|
#endif /* __gc_hal_mem_h_ */
|