swChannel* swChannel_create(int size, int maxlen, int flag)
{
assert(size > SW_CHANNEL_MIN_MEM + maxlen);
int ret;
void *mem;
//是否使用共享内存
if (flag & SW_CHAN_SHM)
{
mem = sw_shm_malloc(size);
}
else
{
mem = sw_malloc(size);
}
if (mem == NULL)
{
swWarn("swChannel_create: malloc fail");
return NULL;
}
swChannel *object = mem;
mem += sizeof(swChannel);
bzero(object, sizeof(swChannel));
//允许溢出
object->size = size - maxlen;
object->mem = mem;
object->maxlen = maxlen;
object->flag = flag;
//是否启用锁
if (flag & SW_CHAN_LOCK)
{
//初始化锁
if (swMutex_create(&object->lock, 1) < 0)
{
swWarn("mutex init fail\n");
return NULL;
}
}
//初始化通知系统
if (flag & SW_CHAN_NOTIFY)
{
#ifdef HAVE_EVENTFD
ret = swPipeEventfd_create(&object->notify_fd, 1, 1);
#else
ret = swPipeBase_create(&object->notify_fd, 1);
#endif
if (ret < 0)
{
swWarn("notify_fd init fail\n");
return NULL;
}
}
return object;
}
int swPipeNotify_auto(swPipe *p, int blocking, int semaphore)
{
//eventfd是2.6.26提供的,timerfd是2.6.27提供的
#ifdef HAVE_EVENTFD
return swPipeEventfd_create(p, blocking, semaphore);
#else
return swPipeBase_create(p, blocking);
#endif
}
int swFactoryThread_start(swFactory *factory)
{
swFactoryThread *this = factory->object;
swThreadParam *param;
int i;
int ret;
pthread_t pidt;
ret = swFactory_check_callback(factory);
if (ret < 0)
{
return SW_ERR;
}
for (i = 0; i < this->writer_num; i++)
{
#ifdef HAVE_EVENTFD
ret = swPipeEventfd_create(&this->writers[i].evfd, 1, 1);
#else
ret = swPipeBase_create(&this->writers[i].evfd, 1);
#endif
if (ret < 0)
{
swTrace("create eventfd fail\n");
return SW_ERR;
}
param = sw_malloc(sizeof(swThreadParam));
if (param == NULL)
{
return SW_ERR;
}
param->object = factory;
param->pti = i;
if (pthread_create(&pidt, NULL, (void * (*)(void *)) swFactoryThread_writer_loop, (void *) param) < 0)
{
swTrace("pthread_create fail\n");
return SW_ERR;
}
if (swRingQueue_init(&this->queues[i], SW_RINGQUEUE_LEN) < 0)
{
swTrace("create ring queue fail\n");
return SW_ERR;
}
this->writers[i].ptid = pidt;
//SW_START_SLEEP;
}
return SW_OK;
}
/**
* @elem_size 每个item内存块的长度
* @elem_max item最多个数
*/
int swChan_create(swChan **chan_addr, void *mem, int mem_size, int elem_max, int elem_size)
{
int slab_size, ret;
bzero(mem, sizeof(swChan)); //初始化内存块
if (mem_size <= 0 || mem == NULL || mem_size < SW_CHAN_MIN_MEM)
{
swWarn("error: mem_size <= %d or mem == NULL\n", SW_CHAN_MIN_MEM);
return SW_ERR;
}
*chan_addr = mem;
swChan *chan = *chan_addr;
mem += sizeof(swChan); //去掉swChan结构占用的部分
if (swMutex_create(&chan->lock, 1) < 0)
{
swWarn("create mutex fail.\n");
return SW_ERR;
}
if (elem_max == 0)
{
elem_max = 65535;
}
#ifdef HAVE_EVENTFD
ret = swPipeEventfd_create(&chan->notify_fd, 1, 1);
#else
ret = swPipeBase_create(&chan->notify_fd, 1);
#endif
if(ret < 0)
{
swWarn("create eventfd fail.\n");
return SW_ERR;
}
slab_size = sizeof(swChanElem)*elem_max;
chan->elem_max = elem_max;
chan->mem_size = mem_size - slab_size - sizeof(swChan);//允许溢出
chan->elems = (swChanElem *) mem;
chan->mem = mem + slab_size;
swMemPool_create(&chan->pool, chan->mem, chan->mem_size, elem_size);
return SW_OK;
}
int swTimer_start(swTimer *timer, int interval_ms)
{
struct timeval now;
if (gettimeofday(&now, NULL) < 0)
{
swWarn("malloc fail\n");
return SW_ERR;
}
timer->interval_ms = interval_ms;
timer->lasttime = interval_ms;
int sec = interval_ms / 1000;
int msec = (((float) interval_ms / 1000) - sec) * 1000;
#ifdef HAVE_TIMERFD
struct itimerspec timer_set;
memset(&timer_set, 0, sizeof(timer_set));
timer->fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK | TFD_CLOEXEC);
if (timer->fd < 0)
{
swError("create timerfd fail\n");
return SW_ERR;
}
timer_set.it_value.tv_sec = now.tv_sec + sec;
timer_set.it_value.tv_nsec = now.tv_usec + msec * 1000;
timer_set.it_interval.tv_sec = sec;
timer_set.it_interval.tv_nsec = msec * 1000 * 1000;
if (timerfd_settime(timer->fd, TFD_TIMER_ABSTIME, &timer_set, NULL) == -1)
{
swWarn("set timer fail\n");
return SW_ERR;
}
timer->use_pipe = 0;
#else
struct itimerval timer_set;
int ret;
//eventfd是2.6.26提供的,timerfd是2.6.27提供的
#ifdef HAVE_EVENTFD
ret = swPipeEventfd_create(&timer->pipe, 0, 0);
#else
ret = swPipeBase_create(&timer->pipe, 0);
#endif
if (ret < 0)
{
swWarn("create timer pipe fail");
return SW_ERR;
}
memset(&timer_set, 0, sizeof(timer_set));
timer_set.it_value.tv_sec = sec;
timer_set.it_value.tv_usec = msec * 1000;
timer_set.it_interval.tv_sec = sec;
timer_set.it_interval.tv_usec = msec * 1000;
if (setitimer(ITIMER_REAL, &timer_set, NULL) < 0)
{
swWarn("set timer fail");
return SW_ERR;
}
timer->fd = timer->pipe.getFd(&timer->pipe, 0);
timer->use_pipe = 1;
#endif
return SW_OK;
}