C++ (Cpp) schedule_insert Exemples

Exemple #1

0

Afficher le fichier

Fichier : schedule.c Projet : BehzadGhaem/android-external-openvpn

/*
 * Given an element, remove it from the btree if it's already
 * there and re-insert it based on its current key.
 */
void
schedule_add_modify (struct schedule *s, struct schedule_entry *e)
{
#ifdef ENABLE_DEBUG
  if (check_debug_level (D_SCHEDULER))
    schedule_entry_debug_info ("schedule_add_modify", e);
#endif

  /* already in tree, remove */
  if (IN_TREE (e))
    schedule_remove_node (s, e);

  /* set random priority */
  schedule_set_pri (e);

  if (s->root)
    schedule_insert (s, e);      /* trivial insert into tree */
  else
    s->root = e; /* tree was empty, we are the first element */

  /* This is the magic of the randomized treap algorithm which
     keeps the tree balanced.  Move the node up the tree until
     its own priority is greater than that of its parent */
  while (e->parent && e->parent->pri > e->pri)
    schedule_rotate_up (s, e);
}

Exemple #2

0

Afficher le fichier

Fichier : sched_util.c Projet : jczech/appveyor_test

/*************************************************************************
schedule_reschedule:
  Moves an item from one time to another in the schedule.  Currently, this is
  used when the unimolecular rates for a subunit cause a molecule's
  unimolecular reaction rate to change.

  In: struct schedule_helper *sh - the scheduler from which to remove
      void  *data - the item to remove
      double new_t - the new time for the item
  Out: 0 on success, 1 if the item was not found
*************************************************************************/
int schedule_reschedule(struct schedule_helper *sh, void *data, double new_t) {
  if (!schedule_deschedule(sh, data)) {
    struct abstract_element *ae = (struct abstract_element *)data;
    ae->t = new_t;
    return schedule_insert(sh, data, 1);
  } else
    return 1;
}

Exemple #3

0

Afficher le fichier

Fichier : sched_util.c Projet : jczech/appveyor_test

int schedule_advance(struct schedule_helper *sh, struct abstract_element **head,
                     struct abstract_element **tail) {
  int n;
  struct abstract_element *p, *nextp;

  if (head != NULL)
    *head = sh->circ_buf_head[sh->index];
  if (tail != NULL)
    *tail = sh->circ_buf_tail[sh->index];

  sh->circ_buf_head[sh->index] = sh->circ_buf_tail[sh->index] = NULL;
  sh->count -= n = sh->circ_buf_count[sh->index];
  sh->circ_buf_count[sh->index] = 0;

  sh->index++;
  sh->now += sh->dt;

  if (sh->index >= sh->buf_len) {
    /* Move events from coarser time scale to this time scale */

    sh->index = 0;
    if (sh->next_scale != NULL) {
      /* Save our depth */
      int old_depth = sh->depth;
      int conservecount = sh->count;

      /* Hack: Toggle the non-zero-ness of our depth to toggle FIFO/LIFO
       * behavior
       */
      sh->depth = old_depth ? 0 : -1;

      if (schedule_advance(sh->next_scale, &p, NULL) == -1) {
        sh->depth = old_depth;
        return -1;
      }
      while (p != NULL) {
        nextp = p->next;
        if (schedule_insert(sh, (void *)p, 0)) {
          sh->depth = old_depth;
          return -1;
        }
        p = nextp;
      }

      /* moved items were already counted when originally scheduled so don't
       * count again */
      sh->count = conservecount;

      /* restore our depth */
      sh->depth = old_depth;
    }
  }

  return n;
}

Exemple #4

0

Afficher le fichier

Fichier : thread.c Projet : jrepan/rhombus

struct thread *thread_thaw(struct thread *thread) {
	
	if (thread->frozen) {
		thread->frozen--;
	}

	if (!thread->frozen) {
		schedule_insert(thread);
	}

	return thread;
}

Exemple #5

0

Afficher le fichier

Fichier : thread.c Projet : jrepan/rhombus

struct thread *thread_send(struct thread *image, pid_t target, portid_t port, struct msg *msg) {
	struct process *p_targ;
	struct thread *new_image;

	/* find target process */
	p_targ = process_get(target);

	/* check process */
	if (!p_targ || !p_targ->entry) {
		return image;
	}

	/* create new thread */
	new_image = thread_alloc();
	thread_bind(new_image, p_targ);

	new_image->ds      = 0x23;
	new_image->cs      = 0x1B;
	new_image->ss      = 0x23;
	new_image->eflags  = 0;
	new_image->useresp = new_image->stack + SEGSZ;
	new_image->proc    = p_targ;
	new_image->eip     = p_targ->entry;

	/* set up registers in new thread */
	new_image->ebx     = 0;
	new_image->ecx     = (msg) ? msg->count : 0;
	new_image->edx     = port;
	new_image->esi     = (image) ? image->proc->pid : 0;
	new_image->edi     = 0;
	new_image->msg     = msg;

	/* set new thread's user id */
	new_image->user = (!image || p_targ->user) ? p_targ->user : image->user;

	/* insert new thread into scheduler */
	schedule_insert(new_image);

	/* return new thread */
	return new_image;
}

Exemple #6

0

Afficher le fichier

Fichier : decoder.c Projet : via/tfi-computer

static void set_expire_event(timeval_t t) {
  disable_interrupts();
  expire_event.time = t;
  schedule_insert(current_time(), &expire_event);
  enable_interrupts();
}

Exemple #7

0

Afficher le fichier