rtxMemory.h

Go to the documentation of this file.
00001 /*
00002  * Copyright (c) 2003-2009 Objective Systems, Inc.
00003  *
00004  * This software is furnished under a license and may be used and copied
00005  * only in accordance with the terms of such license and with the
00006  * inclusion of the above copyright notice. This software or any other
00007  * copies thereof may not be provided or otherwise made available to any
00008  * other person. No title to and ownership of the software is hereby
00009  * transferred.
00010  *
00011  * The information in this software is subject to change without notice
00012  * and should not be construed as a commitment by Objective Systems, Inc.
00013  *
00014  * PROPRIETARY NOTICE
00015  *
00016  * This software is an unpublished work subject to a confidentiality agreement
00017  * and is protected by copyright and trade secret law.  Unauthorized copying,
00018  * redistribution or other use of this work is prohibited.
00019  *
00020  * The above notice of copyright on this source code product does not indicate
00021  * any actual or intended publication of such source code.
00022  *
00023  *****************************************************************************/
00028 #ifndef __RTXMEMORY_H__
00029 #define __RTXMEMORY_H__
00030 
00031 #include "rtxsrc/rtxContext.h"
00032 
00039 /*#define _MEMCOMPACT*/
00040 
00041 #define RT_MH_DONTKEEPFREE 0x1
00042 #define RT_MH_VALIDATEPTR  0x2
00043 #define RT_MH_CHECKHEAP    0x4
00044 
00045 #define OSRTMH_PROPID_DEFBLKSIZE   1
00046 #define OSRTMH_PROPID_SETFLAGS     2
00047 #define OSRTMH_PROPID_CLEARFLAGS   3
00048 #define OSRTMH_PROPID_KEEPFREEUNITS 4
00049 
00050 #define OSRTMH_PROPID_USER         10
00051 
00052 #define OSRTXM_K_MEMBLKSIZ         (4*1024)
00053 
00067 #define OSRTALLOCTYPE(pctxt,type) \
00068 (type*) rtxMemHeapAlloc (&(pctxt)->pMemHeap, sizeof(type))
00069 
00076 #define OSRTALLOCTYPEZ(pctxt,type) \
00077 (type*) rtxMemHeapAllocZ (&(pctxt)->pMemHeap, sizeof(type))
00078 
00079 /*
00080  * Reallocate an array. This macro reallocates an array (either expands or
00081  * contracts) to hold the given number of elements. The number of elements is
00082  * specified in the <i>n</i> member variable of the pseqof argument.
00083  *
00084  * @param pctxt        - Pointer to a context block
00085  * @param pseqof       - Pointer to a generated SEQUENCE OF array structure.
00086  *                       The <i>n</i> member variable must be set to the number
00087  *                       of records to allocate.
00088  * @param type         - Data type of an array record
00089  */
00090 #define OSRTREALLOCARRAY(pctxt,pseqof,type) do {\
00091 if (sizeof(type)*(pseqof)->n < (pseqof)->n) return RTERR_NOMEM; \
00092 if (((pseqof)->elem = (type*) rtxMemHeapRealloc \
00093 (&(pctxt)->pMemHeap, (pseqof)->elem, sizeof(type)*(pseqof)->n)) == 0) \
00094 return RTERR_NOMEM; \
00095 } while (0)
00096 
00097 #ifndef _NO_MALLOC
00098 #define OSCRTMALLOC0(nbytes)       malloc(nbytes)
00099 #define OSCRTFREE0(ptr)            free(ptr)
00100 #else
00101 
00102 #ifdef _NO_THREADS
00103 extern EXTERNRT OSCTXT g_ctxt;
00104 
00105 #define OSCRTMALLOC0(nbytes)       rtxMemAlloc(&g_ctxt,(nbytes))
00106 #define OSCRTFREE0(ptr)            rtxMemFreePtr(&g_ctxt,(ptr))
00107 #else
00108 #define OSCRTMALLOC0(nbytes)       (void*)0
00109 #define OSCRTFREE0(ptr)            (void*)0
00110 
00111 #endif /* _NO_THREADS */
00112 #endif /* _NO_MALLOC */
00113 
00114 #define OSCRTMALLOC rtxMemAlloc
00115 #define OSCRTFREE   rtxMemFreePtr
00116 
00117 struct OSRTDList;
00118 
00119 #ifdef __cplusplus
00120 extern "C" {
00121 #endif
00122 
00123 /* Alias for __cdecl modifier; if __cdecl keyword is not supported, 
00124  * redefine it as empty macro. */
00125 
00126 #if !defined(OSCDECL)
00127 #if defined(_MSC_VER) || defined(__BORLANDC__)
00128 #define OSCDECL __cdecl
00129 #else
00130 #define OSCDECL
00131 #endif
00132 #endif /* OSCDECL */
00133 
00134 /* Pointers to C Run-Time memory allocation functions *
00135  * (See rtxMemSetAllocFuncs)                          */
00136 
00137 typedef void *(OSCDECL *OSMallocFunc ) (size_t size);
00138 typedef void *(OSCDECL *OSReallocFunc) (void *ptr, size_t size);
00139 typedef void  (OSCDECL *OSFreeFunc   ) (void *ptr);
00140 
00141 EXTERNRT void  rtxMemHeapAddRef (void** ppvMemHeap);
00142 EXTERNRT void* rtxMemHeapAlloc (void** ppvMemHeap, size_t nbytes);
00143 EXTERNRT void* rtxMemHeapAllocZ (void** ppvMemHeap, size_t nbytes);
00144 EXTERNRT int   rtxMemHeapCheckPtr (void** ppvMemHeap, const void* mem_p);
00145 EXTERNRT int   rtxMemHeapCreate (void** ppvMemHeap);
00146 
00147 EXTERNRT int   rtxMemHeapCreateExt (void** ppvMemHeap,
00148                                      OSMallocFunc malloc_func,
00149                                      OSReallocFunc realloc_func,
00150                                      OSFreeFunc free_func);
00151 
00152 EXTERNRT void  rtxMemHeapFreeAll (void** ppvMemHeap);
00153 EXTERNRT void  rtxMemHeapFreePtr (void** ppvMemHeap, void* mem_p);
00154 EXTERNRT void* rtxMemHeapMarkSaved (void** ppvMemHeap, 
00155                                      const void* mem_p, 
00156                                      OSBOOL saved);
00157 EXTERNRT void* rtxMemHeapRealloc (void** ppvMemHeap, 
00158                                    void* mem_p, size_t nbytes_);
00159 EXTERNRT void  rtxMemHeapRelease (void** ppvMemHeap);
00160 EXTERNRT void  rtxMemHeapReset (void** ppvMemHeap);
00161 EXTERNRT void  rtxMemHeapSetProperty (void** ppvMemHeap, 
00162                                        OSUINT32 propId, void* pProp);
00163 
00164 EXTERNRT void* rtxMemNewArray (size_t nbytes);
00165 EXTERNRT void* rtxMemNewArrayZ (size_t nbytes);
00166 EXTERNRT void rtxMemDeleteArray (void* mem_p);
00167 
00168 EXTERNRT void* rtxMemHeapAutoPtrRef (void** ppvMemHeap, void* ptr);
00169 EXTERNRT int rtxMemHeapAutoPtrUnref (void** ppvMemHeap, void* ptr);
00170 EXTERNRT int rtxMemHeapAutoPtrGetRefCount (void** ppvMemHeap, void* mem_p);
00171 
00172 EXTERNRT void rtxMemHeapInvalidPtrHook (void** ppvMemHeap, const void* mem_p); 
00173 
00174 EXTERNRT void rtxMemHeapCheck (void** ppvMemHeap, const char* file, int line); 
00175 EXTERNRT void rtxMemHeapPrint (void** ppvMemHeap); 
00176 
00177 #if !defined(_ARMTCC) && !defined(__SYMBIAN32__)
00178 
00193 #ifndef _RT_ALLOC_FUNC_WITH_CONTEXT
00194 
00195 EXTERNRT void rtxMemSetAllocFuncs (OSMallocFunc malloc_func,
00196                                     OSReallocFunc realloc_func,
00197                                     OSFreeFunc free_func);
00198 
00199 #else /* _RT_ALLOC_FUNC_WITH_CONTEXT */
00200 
00201 EXTERNRT void rtxMemSetAllocCtxtFuncs (OSMallocCtxtFunc malloc_func,
00202                                         OSReallocCtxtFunc realloc_func,
00203                                         OSFreeCtxtFunc free_func);
00204 
00205 #endif /* _RT_ALLOC_FUNC_WITH_CONTEXT */
00206 #endif /* __SYMBIAN32__ */
00207 
00208 EXTERNRT void rtxMemFreeOpenSeqExt 
00209 (OSCTXT* pctxt, struct OSRTDList *pElemList);
00210 
00211 /*
00212  * This function returns the actual granularity of memory blocks in the 
00213  * context.
00214  *
00215  * @param pctxt        Pointer to a context block.
00216  */
00217 EXTERNRT OSUINT32 rtxMemHeapGetDefBlkSize (OSCTXT* pctxt);
00218 
00219 #ifndef __SYMBIAN32__
00220 
00227 EXTERNRT void rtxMemSetDefBlkSize (OSUINT32 blkSize);
00228 #endif
00229 
00236 EXTERNRT OSUINT32 rtxMemGetDefBlkSize ();
00237 
00246 EXTERNRT OSBOOL rtxMemIsZero (const void* pmem, size_t memsiz);
00247 
00248 #ifdef _STATIC_HEAP
00249 EXTERNRT void rtxMemSetStaticBuf (void* memHeapBuf, OSUINT32 blkSize);
00250 #endif
00251 
00252 /*
00253  * Allocate memory.  This macro allocates the given number of bytes.  It is 
00254  * similar to the C \c malloc run-time function.
00255  * 
00256  * @param pctxt - Pointer to a context block
00257  * @param nbytes - Number of bytes of memory to allocate
00258  * @return - Void pointer to allocated memory or NULL if insufficient memory 
00259  *   was available to fulfill the request.
00260  */
00261 #define rtxMemAlloc(pctxt,nbytes) \
00262 rtxMemHeapAlloc(&(pctxt)->pMemHeap,nbytes)
00263 
00264 /*
00265  * Allocate and zero memory.  This macro allocates the given number of bytes
00266  * and then initializes the memory block to zero.
00267  * 
00268  * @param pctxt - Pointer to a context block
00269  * @param nbytes - Number of bytes of memory to allocate
00270  * @return - Void pointer to allocated memory or NULL if insufficient memory 
00271  *   was available to fulfill the request.
00272  */
00273 #define rtxMemAllocZ(pctxt,nbytes) \
00274 rtxMemHeapAllocZ(&(pctxt)->pMemHeap,nbytes)
00275 
00276 /*
00277  * Reallocate memory.  This macro reallocates a memory block (either 
00278  * expands or contracts) to the given number of bytes.  It is 
00279  * similar to the C \c realloc run-time function.
00280  * 
00281  * @param pctxt - Pointer to a context block
00282  * @param mem_p - Pointer to memory block to reallocate.  This must have been 
00283  *   allocated using the rtxMemAlloc macro or the rtxMemHeapAlloc function.
00284  * @param nbytes - Number of bytes of memory to which the block is to be 
00285  *   resized.
00286  * @return - Void pointer to allocated memory or NULL if insufficient memory 
00287  *   was available to fulfill the request.  This may be the same as the pmem 
00288  *   pointer that was passed in if the block did not need to be relocated.
00289  */
00290 #define rtxMemRealloc(pctxt,mem_p,nbytes) \
00291 rtxMemHeapRealloc(&(pctxt)->pMemHeap, (void*)mem_p, nbytes)
00292 
00293 /*
00294  * Free memory pointer.  This macro frees memory at the given pointer.  
00295  * The memory must have been allocated using the rtxMemAlloc (or similar) 
00296  * macros or the rtxMem memory allocation macros.  This macro is 
00297  * similar to the C \c free function.
00298  * 
00299  * @param pctxt - Pointer to a context block
00300  * @param mem_p - Pointer to memory block to free.  This must have 
00301  *   been allocated using the rtxMemAlloc or rtxMemAlloc macro or the 
00302  *   rtxMemHeapAlloc function.
00303  */
00304 #define rtxMemFreePtr(pctxt,mem_p) \
00305 rtxMemHeapFreePtr(&(pctxt)->pMemHeap, (void*)mem_p)
00306 
00307 /*
00308  * Free memory associated with a context.  This macro frees all memory 
00309  * held within a context.  This is all memory allocated using the 
00310  * rtxMemAlloc (and similar macros) and the rtxMem memory allocation 
00311  * functions using the given context variable.
00312  * 
00313  * @param pctxt - Pointer to a context block
00314  */
00315 #define rtxMemFree(pctxt) \
00316 rtxMemHeapFreeAll(&(pctxt)->pMemHeap)
00317 
00318 /*
00319  * Reset memory associated with a context.  This macro resets all memory 
00320  * held within a context.  This is all memory allocated using the rtxMemAlloc 
00321  * (and similar macros) and the rtxMem memory allocation functions using the 
00322  * given context variable.
00323  *
00324  * <p>The difference between this and the OSMEMFREE macro is that the 
00325  * memory blocks held within the context are not actually freed.  Internal 
00326  * pointers are reset so the existing blocks can be reused.  This can 
00327  * provide a performace improvement for repetitive tasks such as decoding 
00328  * messages in a loop.
00329  * 
00330  * @param pctxt - Pointer to a context block
00331  */
00332 #define rtxMemReset(pctxt) \
00333 rtxMemHeapReset(&(pctxt)->pMemHeap)
00334 
00344 #define rtxMemAllocType(pctxt,ctype) \
00345 (ctype*)rtxMemHeapAlloc(&(pctxt)->pMemHeap,sizeof(ctype))
00346 
00356 #define rtxMemAllocTypeZ(pctxt,ctype) \
00357 (ctype*)rtxMemHeapAllocZ(&(pctxt)->pMemHeap,sizeof(ctype))
00358 
00359 /*
00360  * Free memory pointer.  This macro frees memory at the given pointer.  
00361  * The memory must have been allocated using the rtxMemAlloc (or similar) 
00362  * macros or the rtxMem memory allocation macros.  This macro is 
00363  * similar to the C \c free function.
00364  * 
00365  * @param pctxt - Pointer to a context block
00366  * @param mem_p - Pointer to memory block to free.  This must have 
00367  *   been allocated using the rtxMemAlloc or rtxMemAlloc macro or the 
00368  *   rtxMemHeapAlloc function.
00369  */
00370 #define rtxMemFreeType(pctxt,mem_p) \
00371 rtxMemHeapFreePtr(&(pctxt)->pMemHeap, (void*)mem_p)
00372 
00382 #define rtxMemAllocArray(pctxt,n,type) \
00383 (type*)rtxMemHeapAlloc (&(pctxt)->pMemHeap, sizeof(type)*n)
00384 
00385 #define rtxMemAllocArrayZ(pctxt,n,type) \
00386 (type*)rtxMemHeapAllocZ (&(pctxt)->pMemHeap, sizeof(type)*n)
00387 
00388 /*
00389  * Free memory pointer.  This macro frees memory at the given pointer.  
00390  * The memory must have been allocated using the rtxMemAlloc (or similar) 
00391  * macros or the rtxMem memory allocation macros.  This macro is 
00392  * similar to the C \c free function.
00393  * 
00394  * @param pctxt - Pointer to a context block
00395  * @param mem_p - Pointer to memory block to free.  This must have 
00396  *   been allocated using the rtxMemAlloc or rtxMemAlloc macro or the 
00397  *   rtxMemHeapAlloc function.
00398  */
00399 #define rtxMemFreeArray(pctxt,mem_p) \
00400 rtxMemHeapFreePtr(&(pctxt)->pMemHeap, (void*)mem_p)
00401 
00402 /*
00403  * Reallocate memory.  This macro reallocates a memory block (either 
00404  * expands or contracts) to the given number of bytes.  It is 
00405  * similar to the C \c realloc run-time function.
00406  * 
00407  * @param pctxt - Pointer to a context block
00408  * @param mem_p - Pointer to memory block to reallocate.  This must have been 
00409  *   allocated using the rtxMemAlloc macro or the rtxMemHeapAlloc function.
00410  * @param nbytes - Number of bytes of memory to which the block is to be 
00411  *   resized.
00412  * @return - Void pointer to allocated memory or NULL if insufficient memory 
00413  *   was available to fulfill the request.  This may be the same as the pmem 
00414  *   pointer that was passed in if the block did not need to be relocated.
00415  */
00416 #define rtxMemReallocArray(pctxt,mem_p,n,type) \
00417 (type*)rtxMemHeapRealloc(&(pctxt)->pMemHeap, (void*)mem_p, sizeof(type)*n)
00418 
00419 /* Auto-pointer functions */
00432 #define rtxMemNewAutoPtr(pctxt,nbytes) \
00433 rtxMemHeapAlloc(&(pctxt)->pMemHeap, nbytes)
00434 
00443 #define rtxMemAutoPtrRef(pctxt,ptr) \
00444 rtxMemHeapAutoPtrRef(&(pctxt)->pMemHeap, (void*)(ptr))
00445 
00456 #define rtxMemAutoPtrUnref(pctxt,ptr) \
00457 rtxMemHeapAutoPtrUnref(&(pctxt)->pMemHeap, (void*)(ptr))
00458 
00467 #define rtxMemAutoPtrGetRefCount(pctxt,ptr) \
00468 rtxMemHeapAutoPtrGetRefCount(&(pctxt)->pMemHeap, (void*)(ptr))
00469 
00470 /*
00471  * Check memory pointer.  This macro check pointer on presence in heap.  
00472  * 
00473  * @param pctxt - Pointer to a context block
00474  * @param mem_p - Pointer to memory block.
00475  * @return        1 - pointer refer to memory block in heap;
00476  *                0 - poiter refer not memory heap block.
00477  */
00478 #define rtxMemCheckPtr(pctxt,mem_p) \
00479 rtxMemHeapCheckPtr(&(pctxt)->pMemHeap, (void*)mem_p)
00480 
00481 /*
00482  * Check memory heap.  
00483  * 
00484  * @param pctxt - Pointer to a context block
00485  */
00486 #define rtxMemCheck(pctxt) \
00487 rtxMemHeapCheck(&(pctxt)->pMemHeap, __FILE__, __LINE__)
00488 
00489 /*
00490  * Print memory heap structure to stderr.  
00491  * 
00492  * @param pctxt - Pointer to a context block
00493  */
00494 #define rtxMemPrint(pctxt) \
00495 rtxMemHeapPrint(&(pctxt)->pMemHeap)
00496 
00497 /*
00498  * Set memory heap property. 
00499  * 
00500  * @param pctxt -  Pointer to a context block
00501  * @param propId - Property Id.
00502  * @param pProp -  Pointer to property value.
00503  */
00504 #define rtxMemSetProperty(pctxt,propId,pProp) \
00505 rtxMemHeapSetProperty (&(pctxt)->pMemHeap, propId, pProp)
00506 
00507 
00508 #ifdef __cplusplus
00509 }
00510 #endif
00511 
00514 #endif /*__RTXMEMORY_H__*/