static void event_free(ACL_EVENT *eventp) { const char *myname = "event_free"; EVENT_SELECT_THR *event_thr = (EVENT_SELECT_THR *) eventp; if (eventp == NULL) acl_msg_fatal("%s, %s(%d): eventp null", __FILE__, myname, __LINE__); acl_pthread_mutex_destroy(&event_thr->event.tm_mutex); acl_pthread_mutex_destroy(&event_thr->event.tb_mutex); acl_myfree(eventp); }
rpc_request::~rpc_request() { acl_pthread_mutex_destroy(lock_); acl_myfree(lock_); acl_pthread_cond_destroy(cond_); acl_myfree(cond_); }
thread_mutex::~thread_mutex(void) { #ifndef ACL_WINDOWS (void) pthread_mutexattr_destroy(&mutex_attr_); #endif (void) acl_pthread_mutex_destroy(mutex_); acl_myfree(mutex_); }
void acl_atomic_free(ACL_ATOMIC *self) { self->value = NULL; #ifndef HAS_ATOMIC acl_pthread_mutex_destroy(&self->lock); acl_myfree(self); #endif }
void acl_mbox_free(ACL_MBOX *mbox, void (*free_fn)(void*)) { acl_vstream_close(mbox->in); acl_vstream_close(mbox->out); acl_ypipe_free(mbox->ypipe, free_fn); acl_pthread_mutex_destroy(mbox->lock); acl_myfree(mbox); }
static void mempool_bench_test2(const char *label, int use_pool, int mutex, int loop, int size) { char *buf; time_t begin, end; int i; static int __pool_inited = 0; if (use_pool) { if (__pool_inited == 0) { acl_mempool_open(__max_size, mutex); __pool_inited = 1; } else { acl_mempool_ctl(ACL_MEMPOOL_CTL_MUTEX, mutex, ACL_MEMPOOL_CTL_END); } i = 0; time(&begin); while (i++ < loop) { buf = MALLOC(size); FREE(buf); } time(&end); } else { acl_pthread_mutex_t lock; if (mutex) acl_pthread_mutex_init(&lock, NULL); if (__pool_inited) { acl_mempool_ctl(ACL_MEMPOOL_CTL_DISABLE, 1, ACL_MEMPOOL_CTL_END); } i = 0; time(&begin); while (i++ < loop) { buf = MALLOC(size); FREE(buf); } time(&end); if (mutex) acl_pthread_mutex_destroy(&lock); } if (use_pool) printf("%s: time cost is %ld seconds, count is %d, total pool alloc %d\r\n", label, (long int) end - begin, loop, acl_mempool_total_allocated()); else printf("%s: time cost is %ld seconds, count is %d\r\n", label, (long int) end - begin, loop); }
int acl_pthread_cond_destroy(acl_pthread_cond_t *cond) { if (cond == NULL) return -1; if (cond->wait_sem) acl_sem_destroy(cond->wait_sem); if (cond->wait_done) acl_sem_destroy(cond->wait_done); if ( cond->lock ) acl_pthread_mutex_destroy(cond->lock); if (cond->dynamic) acl_myfree(cond); return 0; }
static void test_thread_pool(void) { acl_pthread_pool_t *thr_pool; ACL_VSTREAM *fp = acl_vstream_fopen("test.log", O_WRONLY | O_CREAT, 0600, 4096); int i; acl_pthread_mutex_init(&__mutex, NULL); thr_pool = acl_thread_pool_create(10, 10); for (i = 0; i < 1000000; i++) { RUN_CTX *ctx = (RUN_CTX*) acl_mymalloc(sizeof(RUN_CTX)); ctx->fp = fp; ctx->i = i; acl_pthread_pool_add(thr_pool, run_thread, ctx); } acl_pthread_pool_destroy(thr_pool); acl_pthread_mutex_destroy(&__mutex); acl_vstream_close(fp); }
/*----------------------------------------------------------------------------*/ static void __dbpool_mysql_destroy(ACL_DB_POOL *db_pool) { ACL_DB_POOL_MYSQL *mysql_pool; ACL_DB_HANDLE_MYSQL *mysql_handle; int i, n; mysql_pool = (ACL_DB_POOL_MYSQL *) db_pool; n = acl_array_size(mysql_pool->handles); for (i = 0; i < n; i++) { mysql_handle = (ACL_DB_HANDLE_MYSQL *) acl_array_index(mysql_pool->handles, i); if (mysql_handle == NULL) continue; __close_mysql_handle(mysql_handle); acl_myfree(mysql_handle); } acl_pthread_mutex_destroy(&mysql_pool->mutex); acl_array_destroy(mysql_pool->handles, NULL); acl_myfree(mysql_pool); mysql_library_end(); }
locker::~locker() { if (pFile_) acl_myfree(pFile_); if (myFHandle_ && fHandle_ != ACL_FILE_INVALID) acl_file_close(fHandle_); if (mutex_) { #ifndef ACL_WINDOWS (void) pthread_mutexattr_destroy(&mutex_attr_); #endif (void) acl_pthread_mutex_destroy(mutex_); acl_myfree(mutex_); } #ifdef ACL_HAS_SPINLOCK if (spinlock_) { pthread_spin_destroy(spinlock_); acl_myfree_fn((void*) spinlock_); } #endif }
void acl_pthread_end(void) { static int __thread_ended = 0; int i; tls_value_list_free(); if (__thread_ended) return; __thread_ended = 1; acl_pthread_mutex_destroy(&__thread_lock); for (i = 0; i < ACL_PTHREAD_KEYS_MAX; i++) { if (__tls_key_list[i].key >= 0 && __tls_key_list[i].key < ACL_PTHREAD_KEYS_MAX) { TlsFree(__tls_key_list[i].key); __tls_key_list[i].key = ACL_TLS_OUT_OF_INDEXES; } __tls_key_list[i].destructor = NULL; } }
static void mempool_bench_test(const char *label, int mutex, int loop, acl_mem_type type, int size) { int i = 0; time_t begin = 0, end = 0; void *buf; #ifdef MUTEX_INIT acl_pthread_mutex_t lock; #elif defined(WIN32) acl_pthread_mutex_t lock; #define MUTEX_INIT #else acl_pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; #endif if (mutex) { #ifdef MUTEX_INIT acl_pthread_mutex_init(&lock, NULL); #endif time(&begin); while (i++ < loop) { acl_pthread_mutex_lock(&lock); acl_pthread_mutex_unlock(&lock); } time(&end); printf("lock and unkock, loop %d, time cost is %ld\r\n", loop, (long int) end - begin); i = 0; if (type > ACL_MEM_TYPE_NONE && type < ACL_MEM_TYPE_MAX) { time(&begin); while (i++ < loop) { acl_pthread_mutex_lock(&lock); buf = acl_allocator_mem_alloc(__var_allocator, type); acl_pthread_mutex_unlock(&lock); acl_pthread_mutex_lock(&lock); acl_allocator_mem_free(__var_allocator, type, buf); acl_pthread_mutex_unlock(&lock); } time(&end); } else if (type == MEM_TYPE_GROSS) { acl_pthread_mutex_lock(&lock); buf = acl_allocator_membuf_alloc(__FILE__, __LINE__, __var_allocator, size); acl_pthread_mutex_unlock(&lock); acl_pthread_mutex_lock(&lock); acl_allocator_membuf_free(__FILE__, __LINE__, __var_allocator, buf); acl_pthread_mutex_unlock(&lock); } else { time(&begin); while (i++ < loop) { acl_pthread_mutex_lock(&lock); buf = MALLOC(size); acl_pthread_mutex_unlock(&lock); acl_pthread_mutex_lock(&lock); FREE(buf); acl_pthread_mutex_unlock(&lock); } time(&end); } #ifdef MUTEX_INIT acl_pthread_mutex_destroy(&lock); #endif } else { if (type > ACL_MEM_TYPE_NONE && type < ACL_MEM_TYPE_MAX) { time(&begin); while (i++ < loop) { buf = acl_allocator_mem_alloc(__var_allocator, type); acl_allocator_mem_free(__var_allocator, type, buf); } time(&end); } else if (type == MEM_TYPE_GROSS) { buf = acl_allocator_membuf_alloc(__FILE__, __LINE__, __var_allocator, size); acl_allocator_membuf_free(__FILE__, __LINE__, __var_allocator, buf); } else { time(&begin); while (i++ < loop) { buf = MALLOC(size); FREE(buf); } time(&end); } } printf("%s: time cost is %ld seconds, count is %d\r\n", label, (long int) end - begin, loop); }