cache管理
/** * Definition of the structure to keep track of the internal details of * the cache allocator. Touching any of these variables results in * undefined behavior. */ typedef struct { /** Mutex to protect access to the structure */ pthread_mutex_t mutex; /** Name of the cache objects in this cache (provided by the caller) */ char *name; /** List of pointers to available buffers in this cache */ void **ptr; /** The size of each element in this cache */ size_t bufsize; /** The capacity of the list of elements */ int freetotal; /** The current number of free elements */ int freecurr; /** The constructor to be called each time we allocate more memory */ cache_constructor_t* constructor; /** The destructor to be called each time before we release memory */ cache_destructor_t* destructor; } cache_t;
/* * cache管理,避免对象的重复创建与释放 * */ #ifndef NDEBUG const uint64_t redzone_pattern = 0xdeadbeefcafebabe; int cache_error = 0; #endif const int initial_pool_size = 64; /* * 创建一个cache结构 * */ cache_t* cache_create(const char *name, size_t bufsize, size_t align, cache_constructor_t* constructor, cache_destructor_t* destructor) { cache_t* ret = calloc(1, sizeof(cache_t)); char* nm = strdup(name); void** ptr = calloc(initial_pool_size, sizeof(void*)); if (ret == NULL || nm == NULL || ptr == NULL || pthread_mutex_init(&ret->mutex, NULL) == -1) { free(ret); free(nm); free(ptr); return NULL; } ret->name = nm; ret->ptr = ptr; ret->freetotal = initial_pool_size; ret->constructor = constructor; ret->destructor = destructor; /* * cache_t初始化时,freecurr = 0 * */ #ifndef NDEBUG //debug模式下,在原内存前后添加两个uint64,来做错误检测,叫做“红色警戒区” ret->bufsize = bufsize + 2 * sizeof(redzone_pattern); #else ret->bufsize = bufsize; #endif return ret; } static inline void* get_object(void *ptr) { #ifndef NDEBUG uint64_t *pre = ptr; return pre + 1; #else return ptr; #endif } void cache_destroy(cache_t *cache) { while (cache->freecurr > 0) { void *ptr = cache->ptr[--cache->freecurr]; if (cache->destructor) { cache->destructor(get_object(ptr), NULL); } free(ptr); } free(cache->name); free(cache->ptr); pthread_mutex_destroy(&cache->mutex); } /* * 从cache中申请一块指定大小的内存,如果池子中有,则直接返回;没有则向底层申请 * */ void* cache_alloc(cache_t *cache) { void *ret; void *object; pthread_mutex_lock(&cache->mutex); if (cache->freecurr > 0) { //如果有可用缓存,则直接返回 ret = cache->ptr[--cache->freecurr]; object = get_object(ret); } else { //如果没有可用缓存,则直接向底层申请 object = ret = malloc(cache->bufsize); if (ret != NULL) { object = get_object(ret); //如果有构造函数,则调用之,对对象进行初始化 if (cache->constructor != NULL && cache->constructor(object, NULL, 0) != 0) { free(ret); object = NULL; } } } pthread_mutex_unlock(&cache->mutex); #ifndef NDEBUG if (object != NULL) { /* add a simple form of buffer-check */ uint64_t *pre = ret; *pre = redzone_pattern; //前面的一个uint64 ret = pre+1; //后面的uint64 memcpy(((char*)ret) + cache->bufsize - (2 * sizeof(redzone_pattern)), &redzone_pattern, sizeof(redzone_pattern)); } #endif return object; } void cache_free(cache_t *cache, void *ptr) { pthread_mutex_lock(&cache->mutex); #ifndef NDEBUG //警戒区校验 /* validate redzone... */ if (memcmp(((char*)ptr) + cache->bufsize - (2 * sizeof(redzone_pattern)), &redzone_pattern, sizeof(redzone_pattern)) != 0) { raise(SIGABRT); cache_error = 1; pthread_mutex_unlock(&cache->mutex); return; } uint64_t *pre = ptr; --pre; if (*pre != redzone_pattern) { raise(SIGABRT); cache_error = -1; pthread_mutex_unlock(&cache->mutex); return; } ptr = pre; #endif //ptr数组用来存放回收的内存指针 if (cache->freecurr < cache->freetotal) { cache->ptr[cache->freecurr++] = ptr; } else { /* try to enlarge free connections array */ size_t newtotal = cache->freetotal * 2; void **new_free = realloc(cache->ptr, sizeof(char *) * newtotal); //*2重新申请内存成功 if (new_free) { cache->freetotal = newtotal; cache->ptr = new_free; cache->ptr[cache->freecurr++] = ptr; } else { //*2申请内存失败,则要真正示释放内存了 if (cache->destructor) { cache->destructor(ptr, NULL); } free(ptr); } } pthread_mutex_unlock(&cache->mutex); }