thread_mutex::thread_mutex(bool recursive /* = true */)
{
mutex_ = (acl_pthread_mutex_t*)
acl_mycalloc(1, sizeof(acl_pthread_mutex_t));
#ifdef ACL_UNIX
int ret = pthread_mutexattr_init(&mutex_attr_);
if (ret)
{
SET_ERRNO(ret);
logger_fatal("pthread_mutexattr_init error=%s", last_serror());
}
if (recursive && (ret = pthread_mutexattr_settype(&mutex_attr_,
PTHREAD_MUTEX_RECURSIVE)))
{
SET_ERRNO(ret);
logger_fatal("pthread_mutexattr_settype error=%s", last_serror());
}
ret = acl_pthread_mutex_init(mutex_, &mutex_attr_);
if (ret)
{
SET_ERRNO(ret);
logger_fatal("pthread_mutex_init error=%s", last_serror());
}
#else
(void) recursive;
int ret = acl_pthread_mutex_init(mutex_, NULL);
if (ret)
{
SET_ERRNO(ret);
logger_fatal("pthread_mutex_init error=%s", last_serror());
}
#endif
}
void locker::init_mutex(bool use_spinlock acl_unused)
{
#ifdef ACL_HAS_SPINLOCK
if (use_spinlock)
{
spinlock_ = (pthread_spinlock_t*)
acl_mycalloc(1, sizeof(pthread_spinlock_t));
pthread_spin_init(spinlock_, PTHREAD_PROCESS_PRIVATE);
mutex_= NULL;
return;
}
else
spinlock_ = NULL;
#endif
mutex_ = (acl_pthread_mutex_t*)
acl_mycalloc(1, sizeof(acl_pthread_mutex_t));
#ifdef ACL_WINDOWS
acl_assert(acl_pthread_mutex_init(mutex_, NULL) == 0);
#else
acl_assert(pthread_mutexattr_init(&mutex_attr_) == 0);
acl_assert(pthread_mutexattr_settype(&mutex_attr_,
PTHREAD_MUTEX_RECURSIVE) == 0);
acl_assert(acl_pthread_mutex_init(mutex_, &mutex_attr_) == 0);
#endif
}
static void acl_pthread_init_once(void)
{
const char *myname = "acl_pthread_init_once";
int i;
acl_pthread_mutex_init(&__thread_lock, NULL);
__thread_inited = 1;
for (i = 0; i < ACL_PTHREAD_KEYS_MAX; i++) {
__tls_key_list[i].destructor = NULL;
__tls_key_list[i].key = ACL_TLS_OUT_OF_INDEXES;
}
__tls_value_list_key = TlsAlloc();
if (__tls_value_list_key == ACL_TLS_OUT_OF_INDEXES)
acl_msg_fatal("%s(%d): TlsAlloc error(%s)",
myname, __LINE__, acl_last_serror());
if (__tls_value_list_key < 0 || __tls_value_list_key
>= ACL_PTHREAD_KEYS_MAX)
{
acl_msg_fatal("%s(%d): TlsAlloc error(%s), not in(%d, %d)",
myname, __LINE__, acl_last_serror(),
0, ACL_PTHREAD_KEYS_MAX);
}
__tls_key_list[__tls_value_list_key].destructor = NULL;
__tls_key_list[__tls_value_list_key].key = __tls_value_list_key;
}
ACL_MBOX *acl_mbox_create(void)
{
ACL_MBOX *mbox;
ACL_SOCKET fds[2];
if (acl_sane_socketpair(AF_UNIX, SOCK_STREAM, 0, fds) < 0) {
acl_msg_error("%s(%d), %s: acl_duplex_pipe error %s",
__FILE__, __LINE__, __FUNCTION__, acl_last_serror());
return NULL;
}
mbox = (ACL_MBOX *) acl_mymalloc(sizeof(ACL_MBOX));
mbox->in = acl_vstream_fdopen(fds[0], O_RDONLY, sizeof(__key),
0, ACL_VSTREAM_TYPE_SOCK);
mbox->out = acl_vstream_fdopen(fds[1], O_WRONLY, sizeof(__key),
0, ACL_VSTREAM_TYPE_SOCK);
mbox->nsend = 0;
mbox->nread = 0;
mbox->ypipe = acl_ypipe_new();
mbox->lock = (acl_pthread_mutex_t *)
acl_mycalloc(1, sizeof(acl_pthread_mutex_t));
if (acl_pthread_mutex_init(mbox->lock, NULL) != 0)
acl_msg_fatal("%s(%d), %s: acl_pthread_mutex_init error",
__FILE__, __LINE__, __FUNCTION__);
return mbox;
}
/*----------------------------------------------------------------------------*/
ACL_DB_POOL *acl_dbpool_mysql_create(const ACL_DB_INFO *db_info)
{
char myname[] = "acl_dbpool_mysql_create";
ACL_DB_POOL_MYSQL *mysql_pool;
mysql_pool = (ACL_DB_POOL_MYSQL *) acl_mycalloc(1, sizeof(ACL_DB_POOL_MYSQL));
if (mysql_pool == NULL) {
char tbuf[256];
acl_msg_fatal("%s, %s(%d): calloc error=%s",
__FILE__, myname, __LINE__, acl_last_strerror(tbuf, sizeof(tbuf)));
}
mysql_pool->db_pool.dbh_peek = &__dbpool_mysql_peek;
mysql_pool->db_pool.dbh_check = &__dbpool_mysql_check;
mysql_pool->db_pool.dbh_release = &__dbpool_mysql_release;
mysql_pool->db_pool.dbh_export = &__dbpool_mysql_export;
mysql_pool->db_pool.dbh_close = &__dbpool_mysql_close;
mysql_pool->db_pool.destroy = &__dbpool_mysql_destroy;
mysql_pool->handles = acl_array_create(db_info->db_max);
acl_pthread_mutex_init(&mysql_pool->mutex, NULL);
return ((ACL_DB_POOL *) mysql_pool);
}
ACL_EVENT *event_new_select_thr(void)
{
const char *myname = "event_new_select_thr";
EVENT_SELECT_THR *event_thr;
int status;
char ebuf[256];
event_thr = (EVENT_SELECT_THR*) event_alloc(sizeof(EVENT_SELECT_THR));
snprintf(event_thr->event.event.name, sizeof(event_thr->event.event.name),
"thread events - select");
event_thr->event.event.event_mode = ACL_EVENT_SELECT;
event_thr->event.event.use_thread = 1;
event_thr->event.event.loop_fn = event_loop;
event_thr->event.event.free_fn = event_free;
event_thr->event.event.add_dog_fn = event_add_dog;
event_thr->event.event.enable_read_fn = event_enable_read;
event_thr->event.event.enable_write_fn = event_enable_write;
event_thr->event.event.enable_listen_fn = event_enable_listen;
event_thr->event.event.disable_readwrite_fn = event_disable_readwrite;
event_thr->event.event.isrset_fn = event_isrset;
event_thr->event.event.iswset_fn = event_iswset;
event_thr->event.event.isxset_fn = event_isxset;
event_thr->event.event.timer_request = event_timer_request_thr;
event_thr->event.event.timer_cancel = event_timer_cancel_thr;
event_thr->event.event.timer_keep = event_timer_keep_thr;
event_thr->event.event.timer_ifkeep = event_timer_ifkeep_thr;
FD_ZERO(&event_thr->rmask);
FD_ZERO(&event_thr->wmask);
FD_ZERO(&event_thr->xmask);
status = acl_pthread_mutex_init(&event_thr->event.tm_mutex, NULL);
if (status != 0) {
acl_msg_fatal("%s(%d)->%s: pthread_mutex_init error=%s",
__FILE__, __LINE__, myname, acl_last_strerror(ebuf, sizeof(ebuf)));
}
status = acl_pthread_mutex_init(&event_thr->event.tb_mutex, NULL);
if (status != 0) {
acl_msg_fatal("%s(%d)->%s: pthread_mutex_init error=%s",
__FILE__, __LINE__, myname, acl_last_strerror(ebuf, sizeof(ebuf)));
}
return ((ACL_EVENT *) event_thr);
}
void proctl_service_init()
{
const char *myname = "proctl_service_init";
char ebuf[256];
__services = acl_array_create(10);
__services_wait = acl_fifo_new();
acl_pthread_mutex_init(&__mutex_running_service, NULL);
acl_pthread_mutex_init(&__mutex_waiting_service, NULL);
handles_init();
__sem_handle = CreateSemaphore(NULL, 0, 1024, NULL);
if (__sem_handle == NULL)
acl_msg_fatal("%s(%d): CreateSemaphore error(%s)",
myname, __LINE__, acl_last_strerror(ebuf, sizeof(ebuf)));
handles_add(__sem_handle);
}
ACL_ATOMIC *acl_atomic_new(void)
{
ACL_ATOMIC *self = (ACL_ATOMIC*) acl_mymalloc(sizeof(ACL_ATOMIC));
#ifndef HAS_ATOMIC
acl_pthread_mutex_init(&self->lock, NULL);
#endif
self->value = NULL;
return self;
}
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);
}
static void test_nested_mutex(void)
{
acl_pthread_t tid;
acl_pthread_attr_t attr;
static acl_pthread_mutex_t mutex;
#ifdef ACL_UNIX
pthread_spin_init(&__spin_lock, 0);
#endif
acl_pthread_mutex_init(&mutex, NULL);
acl_pthread_attr_init(&attr);
acl_pthread_attr_setdetachstate(&attr, ACL_PTHREAD_CREATE_DETACHED);
acl_pthread_create(&tid, &attr, thread_nested_mutex, &mutex);
acl_pthread_create(&tid, &attr, thread_nested_mutex, &mutex);
}
rpc_request::rpc_request()
: ipc_(NULL)
, wait_timedout_(false)
{
dat_.req = this;
dat_.ctx = NULL;
cond_count_ = 0;
cond_ = (acl_pthread_cond_t*) acl_mycalloc(
1, sizeof(acl_pthread_cond_t));
acl_pthread_cond_init(cond_, NULL);
lock_ = (acl_pthread_mutex_t*) acl_mycalloc(
1, sizeof(acl_pthread_mutex_t));
acl_pthread_mutex_init(lock_, NULL);
}
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);
}
acl_pthread_mutex_t *acl_pthread_mutex_create(void)
{
const char *myname = "acl_pthread_mutex_create";
acl_pthread_mutex_t *mutex;
int status;
mutex = (acl_pthread_mutex_t *)
acl_mymalloc(sizeof(acl_pthread_mutex_t));
if (mutex == NULL)
return NULL;
if ((status = acl_pthread_mutex_init(mutex, NULL)) < 0) {
acl_msg_error("%s: init mutex error(%s)",
myname, acl_last_serror());
acl_myfree(mutex);
return NULL;
}
return mutex;
}
acl_pthread_mutex_t *acl_pthread_mutex_create(void)
{
const char *myname = "acl_pthread_mutex_create";
acl_pthread_mutex_t *mutex;
int status;
char buf[256];
mutex = (acl_pthread_mutex_t *)
acl_mymalloc(sizeof(acl_pthread_mutex_t));
if (mutex == NULL)
return (NULL);
if ((status = acl_pthread_mutex_init(mutex, NULL)) < 0) {
acl_msg_error("%s: init mutex error(%s)(%s)",
myname, acl_last_strerror(buf, sizeof(buf)),
strerror(status));
acl_myfree(mutex);
return (NULL);
}
return (mutex);
}
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);
}