예제 #1
0
/** @brief Pop something from the message exchange queue, with a timeout.
 *
 * @see #xbt_queue_pop
 *
 */
void xbt_queue_pop_timed(xbt_queue_t queue, void *const dst, double delay)
{
  double begin = xbt_time();

  xbt_mutex_acquire(queue->mutex);

  if (delay == 0) {
    if (xbt_dynar_is_empty(queue->data)) {
      xbt_mutex_release(queue->mutex);
      THROWF(timeout_error, 0, "Delay = 0, and queue is empty");
    }
  } else {
    while ((xbt_dynar_is_empty(queue->data)) &&
           (delay < 0 || (xbt_time() - begin) <= delay)) {
      XBT_DEBUG("Queue %p empty. Waiting", queue);
      TRY {
        xbt_cond_timedwait(queue->not_empty, queue->mutex,
                           delay < 0 ? -1 : delay - (xbt_time() - begin));
      }
      CATCH_ANONYMOUS {
        xbt_mutex_release(queue->mutex);
        RETHROW;
      }
    }
  }

  xbt_dynar_pop(queue->data, dst);
  xbt_cond_signal(queue->not_full);
  xbt_mutex_release(queue->mutex);
}
예제 #2
0
/** The guy we will move from host to host. It move alone and then is moved by policeman back  */
static int emigrant(int argc, char *argv[])
{
    msg_task_t task;
    XBT_INFO
    ("I'll look for a new job on another machine where the grass is greener.");
    MSG_process_migrate(MSG_process_self(), MSG_get_host_by_name("Boivin"));

    XBT_INFO("Yeah, found something to do");
    task = MSG_task_create("job", 98095000, 0, NULL);
    MSG_task_execute(task);
    MSG_task_destroy(task);
    MSG_process_sleep(2);
    XBT_INFO("Moving back home after work");
    MSG_process_migrate(MSG_process_self(), MSG_get_host_by_name("Jacquelin"));
    MSG_process_migrate(MSG_process_self(), MSG_get_host_by_name("Boivin"));
    MSG_process_sleep(4);
    xbt_mutex_acquire(mutex);
    process_to_migrate = MSG_process_self();
    xbt_cond_broadcast(cond);
    xbt_mutex_release(mutex);
    MSG_process_suspend(MSG_process_self());
    msg_host_t h = MSG_process_get_host(MSG_process_self());
    XBT_INFO("I've been moved on this new host: %s", MSG_host_get_name(h));
    XBT_INFO("Uh, nothing to do here. Stopping now");
    return 0;
}                               /* end_of_emigrant */
예제 #3
0
/** @brief Get the queue size */
unsigned long xbt_queue_length(const xbt_queue_t queue)
{
  unsigned long res;
  xbt_mutex_acquire(queue->mutex);
  res = xbt_dynar_length(queue->data);
  xbt_mutex_release(queue->mutex);
  return res;
}
예제 #4
0
/** @brief Pop something from the message exchange queue.
 *
 * This is blocking if the queue is empty.
 *
 * @see #xbt_dynar_pop
 *
 */
void xbt_queue_pop(xbt_queue_t queue, void *const dst)
{
  xbt_mutex_acquire(queue->mutex);
  while (xbt_dynar_is_empty(queue->data)) {
    XBT_DEBUG("Queue %p empty. Waiting", queue);
    xbt_cond_wait(queue->not_empty, queue->mutex);
  }
  xbt_dynar_pop(queue->data, dst);
  xbt_cond_signal(queue->not_full);
  xbt_mutex_release(queue->mutex);
}
예제 #5
0
static int sender(int argc, char *argv[])
{
  char* message_name = argv[1];
#ifndef DISABLE_THE_MUTEX
  xbt_mutex_acquire(mutex);
#endif
  MSG_task_send(MSG_task_create(message_name, 0.0, 0.0, NULL), BOX_NAME);
#ifndef DISABLE_THE_MUTEX
  xbt_mutex_release(mutex);
#endif
  return 0;
}
예제 #6
0
JNIEXPORT void JNICALL Java_org_simgrid_msg_Mutex_acquire(JNIEnv * env, jobject obj) {
  xbt_mutex_t mutex;

  mutex = (xbt_mutex_t) (uintptr_t) env->GetLongField(obj, jsyncro_field_Mutex_bind);
  xbt_ex_t e;
  TRY {
    xbt_mutex_acquire(mutex);
  }
  CATCH(e) {
    xbt_ex_free(e);
  }
}
예제 #7
0
/** @brief Push something to the message exchange queue.
 *
 * This is blocking if the declared capacity is non-nul, and if this amount is reached.
 *
 * @see #xbt_dynar_push
 */
void xbt_queue_push(xbt_queue_t queue, const void *src)
{
  xbt_mutex_acquire(queue->mutex);
  while (queue->capacity != 0
         && queue->capacity == xbt_dynar_length(queue->data)) {
    XBT_DEBUG("Capacity of %p exceeded (=%d). Waiting", queue,
           queue->capacity);
    xbt_cond_wait(queue->not_full, queue->mutex);
  }
  xbt_dynar_push(queue->data, src);
  xbt_cond_signal(queue->not_empty);
  xbt_mutex_release(queue->mutex);
}
예제 #8
0
/* This function move the emigrant on Jacquelin */
static int policeman(int argc, char *argv[])
{

    xbt_mutex_acquire(mutex);
    XBT_INFO("Wait a bit before migrating the emigrant.");
    while (process_to_migrate == NULL) xbt_cond_wait(cond, mutex);
    MSG_process_migrate(process_to_migrate, MSG_get_host_by_name("Jacquelin"));
    XBT_INFO("I moved the emigrant");
    MSG_process_resume(process_to_migrate);
    xbt_mutex_release(mutex);

    return 0;
}                               /* end_of_policeman */
예제 #9
0
void xbt_thread_join(xbt_thread_t thread)
{
  xbt_mutex_acquire(thread->mutex);
  xbt_assert(thread->joinable,
              "Cannot join on %p: wasn't created joinable", thread);
  if (!thread->done) {
    xbt_cond_wait(thread->cond, thread->mutex);
    xbt_mutex_release(thread->mutex);
  }

  xbt_mutex_destroy(thread->mutex);
  xbt_cond_destroy(thread->cond);
  free(thread->name);
  free(thread);

}
예제 #10
0
static int xbt_thread_create_wrapper(int argc, char *argv[])
{
  smx_process_t self = SIMIX_process_self();
  xbt_thread_t t =
      (xbt_thread_t) SIMIX_process_self_get_data(self);
  simcall_process_set_data(self, t->father_data);
  t->code(t->userparam);
  if (t->joinable) {
    t->done = 1;
    xbt_mutex_acquire(t->mutex);
    xbt_cond_broadcast(t->cond);
    xbt_mutex_release(t->mutex);
  } else {
    xbt_mutex_destroy(t->mutex);
    xbt_cond_destroy(t->cond);
    free(t->name);
    free(t);
  }
  return 0;
}
예제 #11
0
/** @brief Unshift something to the message exchange queue, with a timeout.
 *
 * @see #xbt_queue_unshift
 */
void xbt_queue_unshift_timed(xbt_queue_t queue, const void *src,
                             double delay)
{
  double begin = xbt_time();

  xbt_mutex_acquire(queue->mutex);

  if (delay == 0) {
    if (queue->capacity != 0 &&
        queue->capacity == xbt_dynar_length(queue->data)) {

      xbt_mutex_release(queue->mutex);
      THROWF(timeout_error, 0,
             "Capacity of %p exceeded (=%d), and delay = 0", queue,
             queue->capacity);
    }
  } else {
    while (queue->capacity != 0 &&
           queue->capacity == xbt_dynar_length(queue->data) &&
           (delay < 0 || (xbt_time() - begin) <= delay)) {

      XBT_DEBUG("Capacity of %p exceeded (=%d). Waiting", queue,
             queue->capacity);
      TRY {
        xbt_cond_timedwait(queue->not_full, queue->mutex,
                           delay < 0 ? -1 : delay - (xbt_time() - begin));
      }
      CATCH_ANONYMOUS {
        xbt_mutex_release(queue->mutex);
        RETHROW;
      }
    }
  }

  xbt_dynar_unshift(queue->data, src);
  xbt_cond_signal(queue->not_empty);
  xbt_mutex_release(queue->mutex);
}