Actual source code: run-alloc.c

  1: #include "petscconf.h"
  2: #if defined(PETSC_HAVE_STDLIB_H)
  3: #include <stdlib.h>
  4: #endif
  5: #if defined(PETSC_HAVE_MALLOC_H) && !defined(__cplusplus)
  6: #include <malloc.h>
  7: #endif

  9: #include "adic/run-alloc.h"

 11: #if defined(__cplusplus)
 12: extern "C" {
 13: #endif
 14: 
 15: #define DEFAULT_BUCKET_SIZE                1000
 16: #define DEFAULT_DERIV_SIZE                sizeof(void*)
 17: 
 18: static int bucket_size = 0;
 19: static int deriv_size = 0;

 21: typedef struct genlist {
 22:   struct genlist *next;
 23:   struct genlist *prev;
 24:   char data[1];
 25: } genlist_t;
 26: static genlist_t* freeList = 0;
 27: static genlist_t* bucketList = 0;
 28: static genlist_t* curBucket = 0;
 29: static int nCount = 0;



 33: void* ad_adic_deriv_init(int dsize, int bsize)
 34: {
 35:   if (dsize == 0) {
 36:     deriv_size = DEFAULT_DERIV_SIZE;
 37:   }
 38:   else {
 39:     deriv_size = dsize;
 40:   }
 41:   if (bsize == 0) {
 42:     bucket_size = DEFAULT_BUCKET_SIZE;
 43:   }
 44:   else {
 45:     bucket_size = bsize;
 46:   }
 47: 
 48:   curBucket = (genlist_t*)malloc(deriv_size * bucket_size);
 49:   curBucket->next = 0;
 50:   curBucket->prev = 0;
 51: 
 52:   freeList = 0;
 53:   bucketList = curBucket;
 54:   nCount = 0;
 55:   return(bucketList);
 56: }

 58: void ad_adic_deriv_final(void)
 59: {
 60:   if (bucketList) {
 61:     genlist_t* block = bucketList;
 62:     genlist_t* tmp;
 63:     while ((tmp = block->next)) {
 64:       free(block);
 65:       block = tmp;
 66:     }
 67:     free(block);
 68:     bucketList = 0;
 69:   }
 70: }

 72: void* ad_adic_deriv_alloc(void)
 73: {
 74: 
 75: #if defined(DEBUG)
 76:   static         count = 0;
 77:   if (++count >= gdebug.nTokens) {
 78:     msg("Allocated %d-th deriv obj", count);
 79:     count = 0;
 80:   }
 81: #endif
 82: 
 83:   if (freeList) {
 84:     void* pobj = freeList;
 85:     freeList = freeList->next;
 86:     return pobj;
 87:   }
 88:   else if (nCount >= bucket_size) {
 89:     curBucket = (genlist_t*)malloc(deriv_size * bucket_size);
 90:     curBucket->next = bucketList;
 91:     bucketList->prev = curBucket;
 92:     bucketList = curBucket;
 93:     nCount = 1;
 94:     return curBucket->data;
 95:   }
 96:   else {
 97:     return curBucket->data + (deriv_size * nCount++);
 98:   }
 99: }

101: void ad_adic_deriv_free(void* ptr)
102: {
103: #if defined(DEBUG)
104:   static         count = 0;
105:   if (++count >= gdebug.nTokens) {
106:     msg("Freed %d tokens", count);
107:     count = 0;
108:   }
109: #endif
110: 
111:   genlist_t*        list = freeList;
112:   freeList = (genlist_t*)ptr;
113:   freeList->next = list;
114: }

116: #if defined(__cplusplus)
117: }
118: #endif