Example #1
0
void
bqueue_dequeue_wait(bounded_queue_t q, void **data, sched_task_t stask)
{
  for (int i = 0; i < 32; i++)
    {
      if(queue_impl_dequeue(q->impl, data))
        {
          task_mutex_lock(q->not_full_mutex, stask);
          task_condition_signal_all(q->not_full, stask);
          task_mutex_unlock(q->not_full_mutex, stask);
          return;
        }
    }

  if (!queue_impl_dequeue(q->impl, data))
    {
      task_mutex_lock(q->not_empty_mutex, stask);
      while (!queue_impl_dequeue(q->impl, data))
        {
          DEBUG_LOG(2, "%p waiting to dequeue in %p\n", stask, q);
          task_condition_wait(q->not_empty, q->not_empty_mutex, stask);
        }
      /* task_condition_signal(q->not_empty); */
      task_mutex_unlock(q->not_empty_mutex, stask);
    }

  DEBUG_LOG(2, "%p bounded queue notifying not full %p\n", stask, q);
  task_mutex_lock(q->not_full_mutex, stask);
  task_condition_signal_all(q->not_full, stask);
  task_mutex_unlock(q->not_full_mutex, stask);
}
Example #2
0
void unlock_pool(void)
{
#ifdef ZEPHYR_MICRO_OS_ABSTRACTION_USE_SINGLE_POOL_LOCK

#ifdef CONFIG_NANOKERNEL
    _PoolUnlock();
#else
    task_mutex_unlock(MTX_POOL_GENERIC);
#endif

#else

#ifdef CONFIG_NANOKERNEL
    nano_fiber_sem_give (&QueuePoolLockSem) ;
#else
    task_mutex_unlock(MTX_POOL_QUEUE);
#endif
#endif
}
Example #3
0
void
proc_wait_for_available(processor_t proc, processor_t client)
{
  task_mutex_lock(proc->mutex, &client->stask);
  proc->last_waiter = client;

  while (proc->last_waiter == client)
    {
      task_condition_wait(proc->cv, proc->mutex, &client->stask);
    }
  task_mutex_unlock(proc->mutex, &client->stask);
}
Example #4
0
void
mutex_task(void* data)
{
  sched_task_t stask = (sched_task_t) data;

  for (int i = 0; i < NUM_ITERS; i++)
    {
      task_mutex_lock(mutex, stask);
      finished++;
      task_mutex_unlock(mutex, stask);
    }
}
Example #5
0
void
worker_task(sched_task_t stask, int flag)
{
    for (int i = 0; i < NUM_ITERS; i++)
    {
        task_mutex_lock(mutex, stask);
        while (finished % 2 == flag)
        {
            task_condition_wait(cv, mutex, stask);
        }
        finished++;
        task_condition_signal_all(cv, stask);
        task_mutex_unlock(mutex, stask);
    }
}
Example #6
0
void Task50(void)
{
	int  rv;

	/* Wait for private mutex to be released */

	rv = task_mutex_lock(private_mutex, TICKS_UNLIMITED);
	if (rv != RC_OK) {
		tcRC = TC_FAIL;
		TC_ERROR("Failed to obtain private mutex\n");
		return;
	}

	/* Wait a bit, then release the mutex */

	task_sleep(HALF_SECOND);
	task_mutex_unlock(private_mutex);

}   /* Task50 */
Example #7
0
static
void
notify_available(processor_t proc)
{

  // If we're processing a wait condition, then we don't want to
  // notify any other threads that this processor is available,
  // because here availability means:
  //
  //   This processor might have undergone a state change so
  //   check your wait-condition again.
  //
  // This is designed to prevent wait conditions from waking up other
  // wait conditions.
  /* if (!proc->processing_wait) */
  /*   { */
      task_mutex_lock(proc->mutex, &proc->stask);
      proc->last_waiter = NULL;
      task_condition_signal_all(proc->cv, &proc->stask);
      task_mutex_unlock(proc->mutex, &proc->stask);
  /*   } */

  /* proc->processing_wait = false; */
}