00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087 #include <stdio.h>
00088 #include <stdlib.h>
00089 #include <string.h>
00090 #include <assert.h>
00091 #include <stdarg.h>
00092
00093 #ifdef _MSC_VER
00094 #pragma warning (disable: 4996)
00095 #endif
00096
00097 #include "ckd_alloc.h"
00098 #include "err.h"
00099
00105 static jmp_buf *ckd_target;
00106 static int jmp_abort;
00107
00108 jmp_buf *
00109 ckd_set_jump(jmp_buf *env, int abort)
00110 {
00111 jmp_buf *old;
00112
00113 if (abort)
00114 jmp_abort = 1;
00115
00116 old = ckd_target;
00117 ckd_target = env;
00118 return old;
00119 }
00120
00121 void
00122 ckd_fail(char *format, ...)
00123 {
00124 va_list args;
00125
00126 va_start(args, format);
00127 vfprintf(stderr, format, args);
00128 va_end(args);
00129
00130 if (jmp_abort)
00131 abort();
00132 else if (ckd_target)
00133 longjmp(*ckd_target, 1);
00134 else
00135 exit(-1);
00136 }
00137
00138 void *
00139 __ckd_calloc__(size_t n_elem, size_t elem_size,
00140 const char *caller_file, int caller_line)
00141 {
00142 void *mem;
00143
00144 #if defined(__ADSPBLACKFIN__) && !defined(__linux__)
00145 if ((mem = heap_calloc(heap_lookup(1),n_elem, elem_size)) == NULL)
00146 if ((mem = heap_calloc(heap_lookup(0),n_elem, elem_size)) == NULL)
00147 {
00148 ckd_fail("calloc(%d,%d) failed from %s(%d), free space: %d\n", n_elem,
00149 elem_size, caller_file, caller_line,space_unused());
00150 }
00151 #else
00152 if ((mem = calloc(n_elem, elem_size)) == NULL) {
00153 ckd_fail("calloc(%d,%d) failed from %s(%d)\n", n_elem,
00154 elem_size, caller_file, caller_line);
00155 }
00156 #endif
00157
00158
00159 return mem;
00160 }
00161
00162
00163 void *
00164 __ckd_malloc__(size_t size, const char *caller_file, int caller_line)
00165 {
00166 void *mem;
00167
00168 #if defined(__ADSPBLACKFIN__) && !defined(__linux__)
00169 if ((mem = heap_malloc(heap_lookup(0),size)) == NULL)
00170 if ((mem = heap_malloc(heap_lookup(1),size)) == NULL)
00171 #else
00172 if ((mem = malloc(size)) == NULL)
00173 #endif
00174 ckd_fail("malloc(%d) failed from %s(%d)\n", size,
00175 caller_file, caller_line);
00176
00177 return mem;
00178 }
00179
00180
00181 void *
00182 __ckd_realloc__(void *ptr, size_t new_size,
00183 const char *caller_file, int caller_line)
00184 {
00185 void *mem;
00186 #if defined(__ADSPBLACKFIN__) && !defined(__linux__)
00187 if ((mem = heap_realloc(heap_lookup(0),ptr, new_size)) == NULL) {
00188 #else
00189 if ((mem = realloc(ptr, new_size)) == NULL) {
00190 #endif
00191 ckd_fail("malloc(%d) failed from %s(%d)\n", new_size,
00192 caller_file, caller_line);
00193 }
00194
00195 return mem;
00196 }
00197
00198
00199 char *
00200 __ckd_salloc__(const char *orig, const char *caller_file,
00201 int caller_line)
00202 {
00203 size_t len;
00204 char *buf;
00205
00206 len = strlen(orig) + 1;
00207 buf = (char *) __ckd_malloc__(len, caller_file, caller_line);
00208
00209 strcpy(buf, orig);
00210 return (buf);
00211 }
00212
00213
00214 void *
00215 __ckd_calloc_2d__(size_t d1, size_t d2, size_t elemsize,
00216 const char *caller_file, int caller_line)
00217 {
00218 char **ref, *mem;
00219 size_t i, offset;
00220
00221 mem =
00222 (char *) __ckd_calloc__(d1 * d2, elemsize, caller_file,
00223 caller_line);
00224 ref =
00225 (char **) __ckd_malloc__(d1 * sizeof(void *), caller_file,
00226 caller_line);
00227
00228 for (i = 0, offset = 0; i < d1; i++, offset += d2 * elemsize)
00229 ref[i] = mem + offset;
00230
00231 return ref;
00232 }
00233
00234
00235 void
00236 ckd_free(void *ptr)
00237 {
00238 if (ptr)
00239 #if defined(__ADSPBLACKFIN__) && !defined(__linux__)
00240 heap_free(0,ptr);
00241 #else
00242 free(ptr);
00243 #endif
00244 }
00245
00246 void
00247 ckd_free_2d(void *tmpptr)
00248 {
00249 void **ptr = (void **)tmpptr;
00250 if (ptr)
00251 ckd_free(ptr[0]);
00252 ckd_free(ptr);
00253 }
00254
00255
00256 void *
00257 __ckd_calloc_3d__(size_t d1, size_t d2, size_t d3, size_t elemsize,
00258 const char *caller_file, int caller_line)
00259 {
00260 char ***ref1, **ref2, *mem;
00261 size_t i, j, offset;
00262
00263 mem =
00264 (char *) __ckd_calloc__(d1 * d2 * d3, elemsize, caller_file,
00265 caller_line);
00266 ref1 =
00267 (char ***) __ckd_malloc__(d1 * sizeof(void **), caller_file,
00268 caller_line);
00269 ref2 =
00270 (char **) __ckd_malloc__(d1 * d2 * sizeof(void *), caller_file,
00271 caller_line);
00272
00273 for (i = 0, offset = 0; i < d1; i++, offset += d2)
00274 ref1[i] = ref2 + offset;
00275
00276 offset = 0;
00277 for (i = 0; i < d1; i++) {
00278 for (j = 0; j < d2; j++) {
00279 ref1[i][j] = mem + offset;
00280 offset += d3 * elemsize;
00281 }
00282 }
00283
00284 return ref1;
00285 }
00286
00287
00288 void
00289 ckd_free_3d(void *inptr)
00290 {
00291 void ***ptr = (void ***)inptr;
00292
00293 if (ptr && ptr[0])
00294 ckd_free(ptr[0][0]);
00295 if (ptr)
00296 ckd_free(ptr[0]);
00297 ckd_free(ptr);
00298 }
00299
00300
00301 void *
00302 __ckd_alloc_3d_ptr(size_t d1,
00303 size_t d2,
00304 size_t d3,
00305 void *store,
00306 size_t elem_size,
00307 char *file,
00308 int line)
00309 {
00310 void **tmp1;
00311 void ***out;
00312 size_t i, j;
00313
00314 tmp1 = __ckd_calloc__(d1 * d2, sizeof(void *), file, line);
00315
00316 out = __ckd_calloc__(d1, sizeof(void **), file, line);
00317
00318 for (i = 0, j = 0; i < d1*d2; i++, j += d3) {
00319 tmp1[i] = &((char *)store)[j*elem_size];
00320 }
00321
00322 for (i = 0, j = 0; i < d1; i++, j += d2) {
00323 out[i] = &tmp1[j];
00324 }
00325
00326 return out;
00327 }
00328
00329 void *
00330 __ckd_alloc_2d_ptr(size_t d1,
00331 size_t d2,
00332 void *store,
00333 size_t elem_size,
00334 char *file,
00335 int line)
00336 {
00337 void **out;
00338 size_t i, j;
00339
00340 out = __ckd_calloc__(d1, sizeof(void *), file, line);
00341
00342 for (i = 0, j = 0; i < d1; i++, j += d2) {
00343 out[i] = &((char *)store)[j*elem_size];
00344 }
00345
00346 return out;
00347 }