Actual source code: run-map.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)
  6: #include <malloc.h>
  7: #endif

  9: #include "adic/run-map.h"
 10: 
 11: #if defined(__cplusplus)
 13: #endif

 15: void* ad_map_init(int dsize, int msize, int bsize, int asize)
 16: {
 17:   int         i;
 18:   MapEntry*        entry;
 19:   char*        pblock;
 20: 
 21:   desc_size = dsize;
 22:   entry_size = dsize + sizeof(Pair) - sizeof(double);
 23:   if (!asize) {
 24:     buckets_per_block = DEFAULT_BUCKETS_PER_BLOCK;
 25:   } else {
 26:     buckets_per_block = asize;
 27:   }
 28: 
 29:   if (!msize) {
 30:       map_size = DEFAULT_MAP_SIZE;
 31:   } else {
 32:     map_size = msize;
 33:   }
 34:   if (!bsize) {
 35:     entries_per_bucket = DEFAULT_BUCKET_SIZE;
 36:   } else {
 37:     entries_per_bucket = bsize;
 38:   }
 39:   bucket_size = entries_per_bucket*entry_size;
 40:   if (map_def) {
 41:     free(map_def);
 42:   }
 43:   map_def = (MapEntry*)calloc(map_size, sizeof(MapEntry) + bucket_size);
 44:   entry = map_def;
 45:   pblock = (char*)(map_def + map_size);
 46:   for (i = 0; i < map_size; i++) {
 47:     entry->next = (Pair*)pblock;
 48:     pblock += bucket_size;
 49:     entry++;
 50:   }
 51: 
 52:   freeList = 0;
 53:   blockList = 0;
 54:   curBlock = 0;
 55:   return(map_def);
 56: }
 57: 
 58: void ad_map_cleanup()
 59: {
 60:   if (blockList) {
 61:     genlist_t* block = blockList;
 62:     genlist_t* tmp;
 63:     while ((tmp = block->next)) {
 64:       free(block);
 65:       block = tmp;
 66:     }
 67:     free(block);
 68:     blockList = 0;
 69:   }
 70: 
 71:   free(map_def);
 72:   map_def = 0;
 73: }

 75: /*
 76: void* ad_map_reg_array_d(double* base, int size)
 77: {
 78:   assert(!array.base);
 79:   array.base = base;
 80:   array.top = base + size;
 81:   array.desc = calloc(size, desc_size);
 82:   array.isSingle = 0;
 83: }
 84: */

 86: /*
 87: void* ad_map_reg_array_s(float* base, int size)
 88: {
 89:   assert(!array.base);
 90:   array.base = base;
 91:   array.top = base + size/2;
 92:   array.desc = calloc(size, desc_size);
 93:   array.isSingle = 1;
 94: }
 95: */


 98: void* ad_map_get(void* key)
 99: {
100:   Pair *pa;
101:   /*
102:   if (key < array.top && key >= array.base) {
103:     if (array.isSingle) {
104:       return array.desc + ((single*)key - (single*)array.base);
105:     }
106:     else {
107:       return array.desc + ((double*)key - array.base);
108:     }
109:   }
110:   */
111:   MapEntry*        entry = map_def + (((long)key>>3) % map_size);
112:   if (entry->cache && entry->cache->key == key) {
113:     return entry->cache->val;
114:   }
115:   while (1) {
116:     int         i = 0;
117:     pa = entry->next;
118:     while (++i < entries_per_bucket) {
119: 
120:       if (pa->key == key) {
121:         entry->cache = pa;
122:         return pa->val;
123:       }
124:       else if (!pa->key) {
125:         pa->key = key;
126:         entry->cache = pa;
127:         return pa->val;
128:       }
129:       else {
130:         pa = (Pair*)((char*)pa + entry_size);
131:       }
132:     }
133:     if (pa->key) {
134:       pa = (Pair*)pa->key;
135:     }
136:     else {
137:       Pair* tmp = (Pair*)ad_map_alloc_bucket();
138:       pa->key = tmp;
139:       tmp->key = key;
140:       entry->cache = tmp;
141:       return tmp->val;
142:     }
143:   }
144: }


147: static void* ad_map_alloc_bucket(void)
148: {
149: #if defined(DEBUG)
150:   static         count = 0;
151:   if (++count >= gdebug.nTokens) {
152:     msg("Allocated %d tokens", count);
153:     count = 0;
154:   }
155: #endif
156:   static int        nBlocks;
157:   static int        nCurBucket;
158: 
159:   if (!curBlock || nCurBucket >= buckets_per_block) {
160:     if (freeList) {
161:       curBlock = freeList;
162:       freeList = freeList->next;
163:     }
164:     else {
165:       curBlock = (genlist_t*)calloc(sizeof(genlist_t) - sizeof(double) +
166:                                     buckets_per_block * bucket_size, 1);
167:       curBlock->next = blockList;
168:       blockList = curBlock;
169:       nBlocks++;
170:     }
171:     nCurBucket = 0;
172:   }
173:   return (char*)curBlock->data + (nCurBucket++)*bucket_size;
174: }


177: void* ad_map_free_bucket(void* ptr)
178: {
179: #if defined(DEBUG)
180:   static         count = 0;
181:   if (++count >= gdebug.nTokens) {
182:     msg("Freed %d tokens", count);
183:     count = 0;
184:   }
185: #endif
186: 
187:   genlist_t*        list = freeList;
188:   freeList = (genlist_t*)ptr;
189:   freeList->next = list;
190:   return(freeList);
191: }

193: void* ad_map_free(void* key)
194: {
195:   void** p = (void**)ad_map_get(key);
196:   *(p-1) = (void*)1;
197:   return(*p);
198: }


201: #if defined(__cplusplus)
202: }
203: #endif