Exemplo n.º 1
0
int uv_timer_start(uv_timer_t* handle,
                   uv_timer_cb cb,
                   uint64_t timeout,
                   uint64_t repeat) {
  uint64_t clamped_timeout;

  if (cb == NULL)
    return UV_EINVAL;

  if (uv__is_active(handle))
    uv_timer_stop(handle);

  clamped_timeout = handle->loop->time + timeout;
  if (clamped_timeout < timeout)
    clamped_timeout = (uint64_t) -1;

  handle->timer_cb = cb;
  handle->timeout = clamped_timeout;
  handle->repeat = repeat;
  /* start_id is the second index to be compared in uv__timer_cmp() */
  handle->start_id = handle->loop->timer_counter++;

  heap_insert(timer_heap(handle->loop),
              (struct heap_node*) &handle->heap_node,
              timer_less_than);
  uv__handle_start(handle);

  return 0;
}
Exemplo n.º 2
0
// This test function was contributed with Bugzilla #2447 to test validity
// of ACE_Timer_Heap timer IDs around the boundary of having to enlarge
// the heap.
static void
test_unique_timer_heap_ids (void)
{
  Example_Handler eh;
  ACE_Timer_Heap timer_heap (44);
  ACE_Time_Value anytime(1);
  ACE_Bounded_Set<long> timer_ids (max_iterations);
  long timer_id = -1;
  bool all_unique = true;

  for (int i = 0; i < 100; ++i)
    {
      timer_id = timer_heap.schedule (&eh, 0, anytime);
      if (timer_id == -1)
        {
          ACE_ERROR ((LM_ERROR,
                      ACE_TEXT ("Schedule timer %d %p\n"),
                      i,
                      ACE_TEXT ("test_unique_timer_heap_ids")));
          continue;
        }
      ACE_DEBUG ((LM_DEBUG,
                  ACE_TEXT ("Schedule timer %d. Timer id = %d\n"),
                  i,
                  timer_id));
      if (1 == timer_ids.insert (timer_id))
        {
          ACE_ERROR ((LM_ERROR,
                      ACE_TEXT ("Pass %d, id %d is not unique\n"),
                      i,
                      timer_id));
          all_unique = false;
        }

      if (i == 0 || i == 1 || i == 47 || i == 48)
        {
          ACE_DEBUG ((LM_DEBUG,
                      ACE_TEXT ("Free Timer %d. Timer Id = %d\n"),
                      i,
                      timer_id));
          timer_heap.cancel (timer_id);
          if (timer_id == -1)
            ACE_ERROR ((LM_ERROR,
                        ACE_TEXT ("%p\n"),
                        ACE_TEXT ("Failed to cancel timer")));

          timer_ids.remove (timer_id);
        }
    }

  if (all_unique)
    ACE_DEBUG ((LM_INFO, ACE_TEXT ("All timer ids were unique.\n")));

  return;
}
Exemplo n.º 3
0
int uv_timer_stop(uv_timer_t* handle) {
  if (!uv__is_active(handle))
    return 0;

  heap_remove(timer_heap(handle->loop),
              (struct heap_node*) &handle->heap_node,
              timer_less_than);
  uv__handle_stop(handle);

  return 0;
}
Exemplo n.º 4
0
void uv__run_timers(uv_loop_t* loop) {
  struct heap_node* heap_node;
  uv_timer_t* handle;

  for (;;) {
    heap_node = heap_min(timer_heap(loop));
    if (heap_node == NULL)
      break;

    handle = container_of(heap_node, uv_timer_t, heap_node);
    if (handle->timeout > loop->time)
      break;

    uv_timer_stop(handle);
    uv_timer_again(handle);
    handle->timer_cb(handle);
  }
}
Exemplo n.º 5
0
int uv__next_timeout(const uv_loop_t* loop) {
  const struct heap_node* heap_node;
  const uv_timer_t* handle;
  uint64_t diff;

  heap_node = heap_min(timer_heap(loop));
  if (heap_node == NULL)
    return -1; /* block indefinitely */

  handle = container_of(heap_node, uv_timer_t, heap_node);
  if (handle->timeout <= loop->time)
    return 0;

  diff = handle->timeout - loop->time;
  if (diff > INT_MAX)
    diff = INT_MAX;

  return (int) diff;
}