le_mem.h

Go to the documentation of this file.

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------

#ifndef LEGATO_MEM_INCLUDE_GUARD
#define LEGATO_MEM_INCLUDE_GUARD

#ifndef LEGATO_COMPONENT
#define LEGATO_COMPONENT
#endif


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef struct le_mem_Pool* le_mem_PoolRef_t;


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef void (*le_mem_Destructor_t)
(
    void* objPtr    
);


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef struct
{
    size_t      numBlocksInUse;     
    size_t      maxNumBlocksUsed;   
    size_t      numOverflows;       
    uint64_t    numAllocs;          
    size_t      numFree;            
}
le_mem_PoolStats_t;


#ifdef LE_MEM_TRACE
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    le_mem_PoolRef_t _le_mem_GetBlockPool
    (
        void*   objPtr  
    );

    typedef void* (*_le_mem_AllocFunc_t)(le_mem_PoolRef_t pool);

    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    void* _le_mem_AllocTracer
    (
        le_mem_PoolRef_t     pool,             
        _le_mem_AllocFunc_t  funcPtr,          
        const char*          poolFunction,     
        const char*          file,             
        const char*          callingfunction,  
        size_t               line              
    );

    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    void _le_mem_Trace
    (
        le_mem_PoolRef_t    pool,             
        const char*         file,             
        const char*         callingfunction,  
        size_t              line,             
        const char*         poolFunction,     
        void*               blockPtr          
    );
#endif


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
le_mem_PoolRef_t _le_mem_CreatePool
(
    const char* componentName,  
    const char* name,           
    size_t      objSize 
);


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
static inline le_mem_PoolRef_t le_mem_CreatePool
(
    const char* name,   
    size_t      objSize 
)
{
    return _le_mem_CreatePool(STRINGIZE(LEGATO_COMPONENT), name, objSize);
}


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
le_mem_PoolRef_t le_mem_ExpandPool
(
    le_mem_PoolRef_t    pool,       
    size_t              numObjects  
);



#ifndef LE_MEM_TRACE
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    void* le_mem_TryAlloc
    (
        le_mem_PoolRef_t    pool    
    );
#else
    void* _le_mem_TryAlloc(le_mem_PoolRef_t pool);

    #define le_mem_TryAlloc(pool)                                                                   \
        _le_mem_AllocTracer(pool,                                                                   \
                            _le_mem_TryAlloc,                                                       \
                            "le_mem_TryAlloc",                                                      \
                            __FILE__,                                                               \
                            __FUNCTION__,                                                           \
                            __LINE__)

#endif


#ifndef LE_MEM_TRACE
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    void* le_mem_AssertAlloc
    (
        le_mem_PoolRef_t    pool    
    );
#else
    void* _le_mem_AssertAlloc(le_mem_PoolRef_t pool);

    #define le_mem_AssertAlloc(pool)                                                                \
        _le_mem_AllocTracer(pool,                                                                   \
                            _le_mem_AssertAlloc,                                                    \
                            "le_mem_AssertAlloc",                                                   \
                            __FILE__,                                                               \
                            __FUNCTION__,                                                           \
                            __LINE__)
#endif


#ifndef LE_MEM_TRACE
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    void* le_mem_ForceAlloc
    (
        le_mem_PoolRef_t    pool    
    );
#else
    void* _le_mem_ForceAlloc(le_mem_PoolRef_t pool);

    #define le_mem_ForceAlloc(pool)                                                                 \
        _le_mem_AllocTracer(pool,                                                                   \
                            _le_mem_ForceAlloc,                                                     \
                            "le_mem_ForceAlloc",                                                    \
                            __FILE__,                                                               \
                            __FUNCTION__,                                                           \
                            __LINE__)
#endif


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
void le_mem_SetNumObjsToForce
(
    le_mem_PoolRef_t    pool,       
    size_t              numObjects  
);


#ifndef LE_MEM_TRACE
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    void le_mem_Release
    (
        void*   objPtr  
    );
#else
    void _le_mem_Release(void* objPtr);

    #define le_mem_Release(objPtr)                                                                  \
            _le_mem_Trace(_le_mem_GetBlockPool(objPtr),                                             \
                          __FILE__,                                                                 \
                          __FUNCTION__,                                                             \
                          __LINE__,                                                                 \
                          "le_mem_Release",                                                         \
                          (objPtr));                                                                \
            _le_mem_Release(objPtr);
#endif


#ifndef LE_MEM_TRACE
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    void le_mem_AddRef
    (
        void*   objPtr  
    );
#else
    void _le_mem_AddRef(void* objPtr);

    #define le_mem_AddRef(objPtr)                                                                   \
        _le_mem_Trace(_le_mem_GetBlockPool(objPtr),                                                 \
                      __FILE__,                                                                     \
                      __FUNCTION__,                                                                 \
                      __LINE__,                                                                     \
                      "le_mem_AddRef",                                                              \
                      (objPtr));                                                                    \
        _le_mem_AddRef(objPtr);
#endif


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
void le_mem_SetDestructor
(
    le_mem_PoolRef_t    pool,       
    le_mem_Destructor_t destructor  
);


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
void le_mem_GetStats
(
    le_mem_PoolRef_t    pool,       
    le_mem_PoolStats_t* statsPtr    
);


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
void le_mem_ResetStats
(
    le_mem_PoolRef_t    pool        
);


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
le_result_t le_mem_GetName
(
    le_mem_PoolRef_t    pool,       
    char*               namePtr,    
    size_t              bufSize     
);


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
const bool le_mem_IsSubPool
(
    le_mem_PoolRef_t    pool        
);


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
size_t le_mem_GetObjectCount
(
    le_mem_PoolRef_t    pool        
);


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
size_t le_mem_GetObjectSize
(
    le_mem_PoolRef_t    pool        
);


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
size_t le_mem_GetObjectFullSize
(
    le_mem_PoolRef_t    pool        
);


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
le_mem_PoolRef_t _le_mem_FindPool
(
    const char* componentName,  
    const char* name            
);


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
static inline le_mem_PoolRef_t le_mem_FindPool
(
    const char* name    
)
{
    return _le_mem_FindPool(STRINGIZE(LEGATO_COMPONENT), name);
}


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
le_mem_PoolRef_t _le_mem_CreateSubPool
(
    le_mem_PoolRef_t    superPool,  
    const char*     componentName,  
    const char*         name,       
    size_t              numObjects  
);


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
static inline le_mem_PoolRef_t le_mem_CreateSubPool
(
    le_mem_PoolRef_t    superPool,  
    const char*         name,       
    size_t              numObjects  
)
{
    return _le_mem_CreateSubPool(superPool, STRINGIZE(LEGATO_COMPONENT), name, numObjects);
}


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
void le_mem_DeleteSubPool
(
    le_mem_PoolRef_t    subPool     
);


#endif // LEGATO_MEM_INCLUDE_GUARD