comparison: src/basic_mempool.c
src/basic_mempool.c
- changeset 572
- f0f99dd06d9f
- parent 571
- f83583a0bbac
- child 648
- 77021e06b1a8
equal
deleted
inserted
replaced
| 571:f83583a0bbac | 572:f0f99dd06d9f |
|---|---|
| 78 if (newcap < pool->size || cx_basic_mempool_chcap(pool, newcap)) { | 78 if (newcap < pool->size || cx_basic_mempool_chcap(pool, newcap)) { |
| 79 return NULL; | 79 return NULL; |
| 80 } | 80 } |
| 81 } | 81 } |
| 82 | 82 |
| 83 cx_basic_mempool_memory *mem = cxMalloc(pool->allocator, | 83 cx_basic_mempool_memory *mem = malloc(sizeof(cx_destructor_func) + n); |
| 84 sizeof(cx_destructor_func) + n); | |
| 85 if (mem == NULL) { | 84 if (mem == NULL) { |
| 86 return NULL; | 85 return NULL; |
| 87 } | 86 } |
| 88 | 87 |
| 89 mem->destructor = NULL; | 88 mem->destructor = NULL; |
| 117 ) { | 116 ) { |
| 118 of_chk_(n); | 117 of_chk_(n); |
| 119 struct cx_basic_mempool_s *pool = data; | 118 struct cx_basic_mempool_s *pool = data; |
| 120 | 119 |
| 121 char *mem = ((char *) ptr) - sizeof(cx_destructor_func); | 120 char *mem = ((char *) ptr) - sizeof(cx_destructor_func); |
| 122 char *newm = (char *) cxRealloc(pool->allocator, mem, | 121 char *newm = (char *) realloc(mem, n + sizeof(cx_destructor_func)); |
| 123 n + sizeof(cx_destructor_func)); | |
| 124 if (newm == NULL) { | 122 if (newm == NULL) { |
| 125 return NULL; | 123 return NULL; |
| 126 } | 124 } |
| 127 if (mem != newm) { | 125 if (mem != newm) { |
| 128 cx_for_n(i, pool->ndata) { | 126 cx_for_n(i, pool->ndata) { |
| 148 cx_for_n(i, pool->ndata) { | 146 cx_for_n(i, pool->ndata) { |
| 149 if (mem == pool->data[i]) { | 147 if (mem == pool->data[i]) { |
| 150 if (mem->destructor != NULL) { | 148 if (mem->destructor != NULL) { |
| 151 mem->destructor(&(mem->c)); | 149 mem->destructor(&(mem->c)); |
| 152 } | 150 } |
| 153 cxFree(pool->allocator, mem); | 151 free(mem); |
| 154 size_t last_index = pool->ndata - 1; | 152 size_t last_index = pool->ndata - 1; |
| 155 if (i != last_index) { | 153 if (i != last_index) { |
| 156 pool->data[i] = pool->data[last_index]; | 154 pool->data[i] = pool->data[last_index]; |
| 157 pool->data[last_index] = NULL; | 155 pool->data[last_index] = NULL; |
| 158 } | 156 } |
| 170 mem = (cx_basic_mempool_memory *) pool->data[i]; | 168 mem = (cx_basic_mempool_memory *) pool->data[i]; |
| 171 if (mem) { | 169 if (mem) { |
| 172 if (mem->destructor) { | 170 if (mem->destructor) { |
| 173 mem->destructor(&(mem->c)); | 171 mem->destructor(&(mem->c)); |
| 174 } | 172 } |
| 175 cxFree(pool->allocator, mem); | 173 free(mem); |
| 176 } | 174 } |
| 177 } | 175 } |
| 178 free(pool->data); | 176 free(pool->data); |
| 179 free((void *) p->allocator); | 177 free((void *) p->allocator); |
| 180 free(pool); | 178 free(pool); |
| 198 static cx_mempool_class cx_basic_mempool_class = { | 196 static cx_mempool_class cx_basic_mempool_class = { |
| 199 cx_basic_mempool_destroy, | 197 cx_basic_mempool_destroy, |
| 200 cx_basic_mempool_set_destr, | 198 cx_basic_mempool_set_destr, |
| 201 }; | 199 }; |
| 202 | 200 |
| 203 CxMempool *cxBasicMempoolCreate( | 201 CxMempool *cxBasicMempoolCreate(size_t capacity) { |
| 204 size_t capacity, | |
| 205 CxAllocator *allocator | |
| 206 ) { | |
| 207 size_t poolsize; | 202 size_t poolsize; |
| 208 if (cx_szmul(capacity, sizeof(void *), &poolsize)) { | 203 if (cx_szmul(capacity, sizeof(void *), &poolsize)) { |
| 209 return NULL; | 204 return NULL; |
| 210 } | 205 } |
| 211 | 206 |
| 234 return NULL; | 229 return NULL; |
| 235 } | 230 } |
| 236 | 231 |
| 237 pool->ndata = 0; | 232 pool->ndata = 0; |
| 238 pool->size = capacity; | 233 pool->size = capacity; |
| 239 pool->allocator = allocator; | |
| 240 | 234 |
| 241 return (CxMempool *) pool; | 235 return (CxMempool *) pool; |
| 242 } | 236 } |
