/* If the performance interval is zero, there's no support. */
if (hrtime_interval_ == 0) {
return 0;
}
if (!QueryPerformanceCounter(&counter)) {
return 0;
}
return (uint64_t) ((double) counter.QuadPart * hrtime_interval_ * scale);
#else
struct timeval tv;
gettimeofday(&tv, NULL);
return (uint64_t) tv.tv_sec * scale + tv.tv_usec/scale;
#endif
}
void loop_update_time (evLoop *loop){
loop->time = loop_hrtime(1000);
}
evLoop *gLoop; /* global loop instance */
evLoop *loop_init (){
evLoop *loop = malloc(sizeof(*loop));
memset(loop, 0, sizeof(*loop));
loop->active_handles = 0;
loop->stop = 0;
loop->time = 0;
loop->timer_counter = 0;
/* timer update */
loop_update_time(loop);
/* defined in select.c or any other io poll backend */
loop_poll_create(loop);
heap_init((struct heap*) &loop->timer_heap);
QUEUE_INIT(&loop->handle_queue);
QUEUE_INIT(&loop->closing_queue);
QUEUE_INIT(&loop->io_queue);
if (gLoop == NULL) gLoop = loop;
return loop;
}
/* Return 0 if not found, 1 if found and removed */
int remove_loop(char *cmd_name)
{
Loop *p;
int val;
if (*cmd_name == '#') {
val = atoi(cmd_name + 1);
p = loop_info.head;
while (p && (p->indx != val)) {
p = p->next;
}
} else {
p = find_loop(cmd_name);
}
if (!p) {
return false;
}
/* Head of list? */
if (!p->prev) {
/* Not sole node */
if (p->next) {
loop_info.head = p->next;
loop_info.head->prev = (Loop *)NULL;
} else {
/* Sole node */
loop_info.head = (Loop *)NULL;
loop_info.tail = (Loop *)NULL;
}
} else if (!p->next) {
/* End of list */
loop_info.tail = p->prev;
p->prev->next = (Loop *)NULL;
} else {
/* Middle of list */
p->prev->next = p->next;
p->next->prev = p->prev;
}
if (p->time == loop_info.low_time) {
loop_update_time();
}
strfree(p->cmd);
free(p);
loop_update_index();
return true;
}
int loop_start (evLoop *loop, int type){
while (loop->active_handles){
/* closing handles */
loop_run_closing_handles(loop);
loop_update_time(loop);
int timeout;
timeout = next_timeout(loop);
if (type == 1 && timeout > 1){
timeout = 1;
}
loop_run_timers(loop);
loop_run_immediate(loop);
if (QUEUE_EMPTY(&loop->io_queue)) {
#ifdef _WIN32
Sleep(timeout);
#else
usleep(1000 * timeout);
#endif
} else {
io_poll(loop, timeout);
}
/* run once */
if (type == 1){
loop_update_time(loop);
loop_run_timers(loop);
break;
}
}
/* check closing handles one last time*/
loop_run_closing_handles(loop);
return loop->active_handles > 0;
}
int loop_start (evLoop *loop, int type){
while (loop->active_handles){
/* closing handles */
QUEUE *q;
evHandle *handle;
while ( !QUEUE_EMPTY(&loop->closing_queue) ){
q = QUEUE_HEAD(&(loop)->closing_queue);
QUEUE_REMOVE(q);
handle = QUEUE_DATA(q, evHandle, queue);
assert(handle);
if (handle->close != NULL){
handle->close(handle);
}
_free_handle(handle);
}
loop_update_time(loop);
int timeout;
if (type == 1){
timeout = 0;
} else {
timeout = next_timeout(loop);
}
loop_run_timers(loop);
loop_run_immediate(loop);
if (QUEUE_EMPTY(&loop->io_queue)) {
#ifdef _WIN32
Sleep(timeout);
#else
usleep(1000 * timeout);
#endif
} else {
io_poll(loop, timeout);
}
/* run once */
if (type == 1){ break; }
}
return loop->active_handles > 0;
}
int add_loop(char *cmd, long int timel, int user_defn)
{
Loop *p;
p = find_loop(cmd);
if (p) {
strfree(p->cmd);
loop_update_time();
} else {
p = (Loop *)malloc(sizeof(Loop));
if (!p) {
return ERROR;
}
/* Empty list */
if (loop_info.head == (Loop *)NULL) {
loop_info.head = p;
loop_info.tail = p;
p->next = (Loop *)NULL;
p->prev = (Loop *)NULL;
} else {
p->prev = loop_info.tail;
loop_info.tail->next = p;
p->next = NULL;
loop_info.tail = p;
}
}
p->time = timel;
if (timel < loop_info.low_time) {
loop_info.low_time = timel;
}
p->last_time = time(0);
p->user_defn = user_defn;
p->cmd = string(cmd);
loop_update_index();
return p->indx;
}
