int sched_add_delay_task_ex(ScheduleContext *pContext, TaskFunc task_func,
void *func_args, const int delay_seconds, const bool new_thread)
{
FastDelayTask *task;
if (!pContext->timer_init)
{
logError("file: "__FILE__", line: %d, "
"NOT support delay tasks, you should call sched_set_delay_params "
"before sched_start!", __LINE__);
return EOPNOTSUPP;
}
task = (FastDelayTask *)fast_mblock_alloc_object(&pContext->mblock);
if (task == NULL)
{
return ENOMEM;
}
task->task_func = task_func;
task->func_args = func_args;
task->new_thread = new_thread;
task->next = NULL;
if (delay_seconds > 0)
{
task->timer.expires = g_current_time + delay_seconds;
}
else
{
task->timer.expires = g_current_time;
}
pthread_mutex_lock(&pContext->delay_queue.lock);
if (pContext->delay_queue.head == NULL)
{
pContext->delay_queue.head = task;
}
else
{
pContext->delay_queue.tail->next = task;
}
pContext->delay_queue.tail = task;
pthread_mutex_unlock(&pContext->delay_queue.lock);
return 0;
}
int flat_skiplist_insert(FlatSkiplist *sl, void *data)
{
int i;
int level_index;
FlatSkiplistNode *node;
FlatSkiplistNode *previous;
FlatSkiplistNode *current = NULL;
level_index = flat_skiplist_get_level_index(sl);
node = (FlatSkiplistNode *)fast_mblock_alloc_object(sl->mblocks + level_index);
if (node == NULL) {
return ENOMEM;
}
previous = sl->top;
for (i=sl->top_level_index; i>level_index; i--) {
while (previous->links[i] != sl->tail && sl->compare_func(data,
previous->links[i]->data) < 0)
{
previous = previous->links[i];
}
}
while (i >= 0) {
while (previous->links[i] != sl->tail && sl->compare_func(data,
previous->links[i]->data) < 0)
{
previous = previous->links[i];
}
current = previous->links[i];
previous->links[i] = node;
node->links[i] = current;
i--;
}
node->prev = previous;
current->prev = node;
node->data = data;
return 0;
}
void *fast_allocator_alloc(struct fast_allocator_context *acontext,
const int bytes)
{
int alloc_bytes;
int64_t total_reclaim_bytes;
struct fast_allocator_info *allocator_info;
void *ptr;
if (bytes < 0)
{
return NULL;
}
alloc_bytes = sizeof(struct allocator_wrapper) + bytes;
allocator_info = get_allocator(acontext, &alloc_bytes);
if (allocator_info->pooled)
{
ptr = fast_mblock_alloc_object(&allocator_info->mblock);
if (ptr == NULL)
{
if (acontext->allocator_array.reclaim_interval <= 0)
{
return NULL;
}
if (fast_allocator_retry_reclaim(acontext, &total_reclaim_bytes) != 0)
{
return NULL;
}
logInfo("reclaimed bytes: %"PRId64, total_reclaim_bytes);
if (total_reclaim_bytes < allocator_info->mblock.info.trunk_size)
{
return NULL;
}
ptr = fast_mblock_alloc_object(&allocator_info->mblock);
if (ptr == NULL)
{
return NULL;
}
}
}
else
{
if (fast_allocator_malloc_trunk_check(alloc_bytes, acontext) != 0)
{
return NULL;
}
ptr = malloc(alloc_bytes);
if (ptr == NULL)
{
return NULL;
}
fast_allocator_malloc_trunk_notify_func(alloc_bytes, acontext);
}
((struct allocator_wrapper *)ptr)->allocator_index = allocator_info->index;
((struct allocator_wrapper *)ptr)->magic_number = allocator_info->magic_number;
((struct allocator_wrapper *)ptr)->alloc_bytes = alloc_bytes;
__sync_add_and_fetch(&acontext->alloc_bytes, alloc_bytes);
return (char *)ptr + sizeof(struct allocator_wrapper);
}
int flat_skiplist_init_ex(FlatSkiplist *sl, const int level_count,
skiplist_compare_func compare_func, skiplist_free_func free_func,
const int min_alloc_elements_once)
{
int bytes;
int element_size;
int i;
int alloc_elements_once;
int result;
struct fast_mblock_man *top_mblock;
if (level_count <= 0) {
/*logError("file: "__FILE__", line: %d, "
"invalid level count: %d",
__LINE__, level_count);*/
return EINVAL;
}
if (level_count > 20) {
/*logError("file: "__FILE__", line: %d, "
"level count: %d is too large",
__LINE__, level_count);*/
return E2BIG;
}
bytes = sizeof(struct fast_mblock_man) * level_count;
sl->mblocks = (struct fast_mblock_man *)malloc(bytes);
if (sl->mblocks == NULL) {
/*logError("file: "__FILE__", line: %d, "
"malloc %d bytes fail, errno: %d, error info: %s",
__LINE__, bytes, errno, STRERROR(errno));*/
return errno != 0 ? errno : ENOMEM;
}
memset(sl->mblocks, 0, bytes);
alloc_elements_once = min_alloc_elements_once;
if (alloc_elements_once <= 0) {
alloc_elements_once = SKIPLIST_DEFAULT_MIN_ALLOC_ELEMENTS_ONCE;
}
else if (alloc_elements_once > 1024) {
alloc_elements_once = 1024;
}
for (i=level_count-1; i>=0; i--) {
element_size = sizeof(FlatSkiplistNode) + sizeof(FlatSkiplistNode *) * (i + 1);
if ((result=fast_mblock_init_ex(sl->mblocks + i,
element_size, alloc_elements_once, NULL, false)) != 0)
{
return result;
}
if (alloc_elements_once < 1024 * 1024) {
alloc_elements_once *= 2;
}
}
sl->top_level_index = level_count - 1;
top_mblock = sl->mblocks + sl->top_level_index;
sl->top = (FlatSkiplistNode *)fast_mblock_alloc_object(top_mblock);
if (sl->top == NULL) {
return ENOMEM;
}
memset(sl->top, 0, top_mblock->info.element_size);
sl->tail = (FlatSkiplistNode *)fast_mblock_alloc_object(sl->mblocks + 0);
if (sl->tail == NULL) {
return ENOMEM;
}
memset(sl->tail, 0, sl->mblocks[0].info.element_size);
sl->tail->prev = sl->top;
for (i=0; i<level_count; i++) {
sl->top->links[i] = sl->tail;
}
sl->level_count = level_count;
sl->compare_func = compare_func;
sl->free_func = free_func;
srand(time(NULL));
return 0;
}
