Changeset 5757:75c9b2e184f3 in roaraudio


Ignore:
Timestamp:
11/16/12 17:58:26 (11 years ago)
Author:
phi
Branch:
default
Phase:
public
Message:

Added support for configureable memmgr backend (Closes: #334)

Files:
3 edited

Legend:

Unmodified
Added
Removed

  • ChangeLog

    r5752 r5757  
    1010        * Provide a more common interface for path config. 
    1111        * Improved env API. 
     12        * Added support for configureable memmgr backend (Closes: #334) 
    1213 
    1314v. 1.0beta7 - Tue Oct 23 2012 23:28 CEST 

  • include/libroar/config.h

    r5753 r5757  
    8080}; 
    8181 
     82struct roar_libroar_memmgrapi { 
     83 void *  (*calloc)   (void * userdata, size_t nmemb, size_t size); 
     84 void *  (*malloc)   (void * userdata, size_t size); 
     85 int     (*free)     (void * userdata, void * ptr); 
     86 void *  (*realloc)  (void * userdata, void * ptr, size_t size); 
     87 int     (*reset)    (void * userdata); 
     88 ssize_t (*sizeofbuf)(void * userdata, void * ptr); 
     89 
     90// TODO: Memmory locking is not yet supported this way. 
     91 int (*mlock)        (void * userdata, const void * addr, size_t len); 
     92 int (*munlock)      (void * userdata, const void * addr, size_t len); 
     93 int (*mlockall)     (void * userdata, int flags); 
     94 int (*munlockall)   (void * userdata); 
     95 
     96 void * userdata; 
     97}; 
     98 
    8299struct roar_libroar_config_codec { 
    83100 uint32_t codec; // Codec ID 
    … …  
    146163 
    147164int    roar_libroar_set_forkapi(struct roar_libroar_forkapi * api); 
     165int    roar_libroar_set_memmgrapi(const struct roar_libroar_memmgrapi * api); // implemented in memmgr.c. 
    148166 
    149167int    roar_libroar_set_connect_internal(struct roar_vio_calls * (*func)(struct roar_connection * con, const char * server, int type, int flags, uint_least32_t timeout)); 

  • libroar/memmgr.c

    r5755 r5757  
    4949#define _err(x) do { roar_err_set((x)); return NULL; } while (0) 
    5050 
     51#ifdef ROAR_HAVE_CALLOC 
     52static void *  __libroar_calloc   (void * userdata, size_t nmemb, size_t size) { 
     53 void * ret; 
     54 roar_err_clear_all(); 
     55 ret  = calloc(nmemb, size); 
     56 roar_err_update(); 
     57 return ret; 
     58} 
     59#endif 
     60#ifdef ROAR_HAVE_MALLOC 
     61static void *  __libroar_malloc   (void * userdata, size_t size) { 
     62 void * ret; 
     63 roar_err_clear_all(); 
     64 ret  = malloc(size); 
     65 roar_err_update(); 
     66 return ret; 
     67} 
     68#endif 
     69#ifdef ROAR_HAVE_FREE 
     70static int     __libroar_free     (void * userdata, void * ptr) { 
     71 free(ptr); 
     72 return 0; 
     73} 
     74#endif 
     75#ifdef ROAR_HAVE_REALLOC 
     76static void *  __libroar_realloc  (void * userdata, void * ptr, size_t size) { 
     77 void * ret; 
     78 roar_err_clear_all(); 
     79 ret  = realloc(ptr, size); 
     80 roar_err_update(); 
     81 return ret; 
     82} 
     83#endif 
     84 
     85static const struct roar_libroar_memmgrapi __memory_default_api = { 
     86#ifdef ROAR_HAVE_CALLOC 
     87 .calloc = __libroar_calloc, 
     88#else 
     89 .calloc = NULL, 
     90#endif 
     91#ifdef ROAR_HAVE_MALLOC 
     92 .malloc = __libroar_malloc, 
     93#else 
     94 .malloc = NULL, 
     95#endif 
     96#ifdef ROAR_HAVE_FREE 
     97 .free = __libroar_free, 
     98#else 
     99 .free = NULL, 
     100#endif 
     101#ifdef ROAR_HAVE_REALLOC 
     102 .realloc = __libroar_realloc, 
     103#else 
     104 .realloc = NULL, 
     105#endif 
     106 .reset = NULL, // not needed 
     107 .sizeofbuf = NULL, // not supported 
     108 
     109 // Not yet supported: 
     110 .mlock = NULL, 
     111 .munlock = NULL, 
     112 .mlockall = NULL, 
     113 .munlockall = NULL, 
     114 
     115 // no need with C API. 
     116 .userdata = NULL 
     117}; 
     118 
     119static const struct roar_libroar_memmgrapi * memory_api = &__memory_default_api; 
     120 
     121int    roar_libroar_set_memmgrapi(const struct roar_libroar_memmgrapi * api) { 
     122 if ( api == NULL ) 
     123  memory_api = &__memory_default_api; 
     124 memory_api = api; 
     125 return 0; 
     126} 
     127 
    51128#ifdef ROAR_USE_MEMMGR 
    52  
    53129int     roar_mm_reset(void) { 
    54130 // currently this does nothing. 
    55131 // we need to free pools and such here later. 
     132 
     133 if ( memory_api->reset != NULL ) 
     134  return memory_api->reset(memory_api->userdata); 
    56135 return 0; 
    57136} 
    … …  
    66145  return 0; 
    67146 
     147 if ( memory_api->sizeofbuf != NULL ) 
     148  return memory_api->sizeofbuf(memory_api->userdata, buf); 
     149 
    68150 roar_err_set(ROAR_ERROR_NOTSUP); 
    69151 return -1; 
    … …  
    78160 } 
    79161 
    80 #ifdef ROAR_HAVE_CALLOC 
    81  roar_err_clear_all(); 
    82  ret = calloc(nmemb, size); 
    83  
    84  if ( ret == NULL ) 
    85   roar_err_update(); 
    86  
    87  return ret; 
    88 #else 
    89  ret = roar_mm_malloc(nmemb*size); 
    90  if ( ret == NULL ) 
    91   return NULL; 
    92  
    93  memset(ret, 0, nmemb*size); 
    94  
    95  return ret; 
    96 #endif 
     162 if ( memory_api->calloc != NULL ) { 
     163  return memory_api->calloc(memory_api->userdata, nmemb, size); 
     164 } else { 
     165  ret = roar_mm_malloc(nmemb*size); 
     166  if ( ret == NULL ) 
     167   return NULL; 
     168 
     169  memset(ret, 0, nmemb*size); 
     170 
     171  return ret; 
     172 } 
    97173} 
    98174 
    99175void * roar_mm_malloc(size_t size) { 
    100  void * ret; 
    101  
    102176 if ( size == 0 ) { 
    103177  _libroar_null_buffer_check(); 
    … …  
    105179 } 
    106180 
    107 #ifdef ROAR_HAVE_MALLOC 
    108  roar_err_clear_all(); 
    109  ret = malloc(size); 
    110  
    111  if ( ret == NULL ) 
    112   roar_err_update(); 
    113  
    114  return ret; 
    115 #elif defined(ROAR_HAVE_CALLOC) 
    116  return roar_mm_calloc(1, size); 
    117 #elif defined(ROAR_HAVE_REALLOC) 
    118  return roar_mm_realloc(NULL, size); 
    119 #else 
    120  _err(ROAR_ERROR_NOSYS); 
    121 #endif 
     181 if ( memory_api->malloc != NULL ) { 
     182  return memory_api->malloc(memory_api->userdata, size); 
     183 } else if ( memory_api->calloc != NULL ) { 
     184  return roar_mm_calloc(1, size); 
     185 } else if ( memory_api->realloc != NULL ) { 
     186  return roar_mm_realloc(NULL, size); 
     187 } else { 
     188  _err(ROAR_ERROR_NOSYS); 
     189 } 
    122190} 
    123191 
    … …  
    129197 } 
    130198 
    131 #ifdef ROAR_HAVE_FREE 
    132  free(ptr); 
    133  return 0; 
    134 #elif defined(ROAR_HAVE_REALLOC) 
    135  if ( roar_mm_realloc(ptr, 0) != _libroar_null_buffer ) 
    136   return -1; 
    137  return 0; 
    138 #else 
    139  roar_err_set(ROAR_ERROR_NOSYS); 
    140  return -1; 
    141 #endif 
     199 if ( memory_api->free != NULL ) { 
     200  return memory_api->free(memory_api->userdata, ptr); 
     201 } else if ( memory_api->realloc != NULL ) { 
     202  if ( roar_mm_realloc(ptr, 0) != _libroar_null_buffer ) 
     203   return -1; 
     204  return 0; 
     205 } else { 
     206  roar_err_set(ROAR_ERROR_NOSYS); 
     207  return -1; 
     208 } 
    142209} 
    143210 
    144211void * roar_mm_realloc(void *ptr, size_t size) { 
    145212 void * ret; 
    146 #ifndef ROAR_HAVE_REALLOC 
    147213 ssize_t len; 
    148 #endif 
    149214 
    150215 if ( ptr == NULL ) 
    … …  
    157222 } 
    158223 
    159 #ifdef ROAR_HAVE_REALLOC 
    160  roar_err_clear_all(); 
    161  ret = realloc(ptr, size); 
    162  
    163  if ( ret == NULL ) 
    164   roar_err_update(); 
    165  
    166  return ret; 
    167 #else 
    168  len = roar_mm_sizeof(ptr); 
    169  if ( len == -1 ) 
    170   return NULL; 
    171  
    172  ret = roar_mm_malloc(size);  
    173  if ( ret == NULL ) 
    174   return NULL; 
    175  
    176  memcpy(ret, ptr, len > (ssize_t)size ? size : len); 
    177  
    178  return ret; 
    179 #endif 
     224 if ( memory_api->realloc != NULL ) { 
     225  return memory_api->realloc(memory_api->userdata, ptr, size); 
     226 } else { 
     227  len = roar_mm_sizeof(ptr); 
     228  if ( len == -1 ) 
     229   return NULL; 
     230 
     231  ret = roar_mm_malloc(size);  
     232  if ( ret == NULL ) 
     233   return NULL; 
     234 
     235  memcpy(ret, ptr, len > (ssize_t)size ? size : len); 
     236 
     237  return ret; 
     238 } 
    180239} 
    181240#endif 
Note: See TracChangeset for help on using the changeset viewer.