Пример #1
0
void connection_consumer_start(void *arg)
{
    int rc;
    struct server_ctx *ctx;
    uv_loop_t* loop;
    
    ctx = arg;
    loop = uv_loop_new();
    listener_event_loops[ctx->index] = *loop;
    
    http_request_cache_configure_listener(loop, &listener_async_handles[ctx->index]);
    uv_barrier_wait(listeners_created_barrier);
    
    rc = uv_async_init(loop, &ctx->async_handle, connection_consumer_close);
    uv_unref((uv_handle_t*) &ctx->async_handle);
    
    /* Wait until the main thread is ready. */
    uv_sem_wait(&ctx->semaphore);
    get_listen_handle(loop, (uv_stream_t*) &ctx->server_handle);
    uv_sem_post(&ctx->semaphore);
    
    rc = uv_listen((uv_stream_t*)&ctx->server_handle, 128, connection_consumer_new_connection);
    rc = uv_run(loop, UV_RUN_DEFAULT);
    
    uv_loop_delete(loop);
}
Пример #2
0
static PyObject *
Barrier_func_wait(Barrier *self)
{
    RAISE_IF_NOT_INITIALIZED(self, NULL);

    Py_BEGIN_ALLOW_THREADS
    uv_barrier_wait(&self->uv_barrier);
    Py_END_ALLOW_THREADS

    Py_RETURN_NONE;
}
static void thread_main(void* arg) {
  struct thread_ctx* ctx;
  char buf[4096];
  ssize_t n;

  ctx = arg;
  uv_barrier_wait(&ctx->barrier);

  do
    n = read(ctx->fd, buf, sizeof(buf));
  while (n > 0 || (n == -1 && errno == EINTR));

  ASSERT(n == 0);
}
Пример #4
0
void reader(void *n)
{
	int num = *(int*)n;
	int i;
	for (i = 0; i < 20; ++i)
	{
		uv_rwlock_rdlock(&numlock);
		printf("Reader %d: acquired lock\n", num);
		printf("Reader %d: shared num = %d\n", num, shared_num);
		uv_rwlock_rdunlock(&numlock);
		printf("Reader %d: released lock\n", num);
	}
	uv_barrier_wait(&blocker);
}
Пример #5
0
void writer(void *n)
{
	int num = *(int*)n;
	int i;
	for (i = 0; i < 20; ++i)
	{
		uv_rwlock_wrlock(&numlock);
		printf("Writer %d: acquired lock\n", num);
		shared_num++;
		printf("Writer %d: incremented shared num = %d\n", num, shared_num);
		uv_rwlock_wrunlock(&numlock);
		printf("Writer %d: released lock\n", num);
	}
	uv_barrier_wait(&blocker);
}
Пример #6
0
// https://github.com/thlorenz/libuv-dox/blob/master/methods.md#uv_rwlock_wrlock
void writer_entry(void *n) {
  int r;
  int num = *(int*)n;
  for (int i = 0; i < ROUNDS; i++) {
    do {
      r = uv_rwlock_trywrlock(&numlock);

      // see: reader_entry
      if (r && r != -EBUSY && r != -EAGAIN) ERROR("obtaining write lock", r);
    } while(r);

    fprintf(stderr, "Writer %d: aquired lock\n", num);
    shared_num++;
    fprintf(stderr, "Writer %d: incremented shared num = %d\n", num, shared_num);
    uv_rwlock_wrunlock(&numlock);
    fprintf(stderr, "Writer %d: released lock\n", num);
  }
  uv_barrier_wait(&blocker);
}
Пример #7
0
int main()
{
	uv_thread_t threads[3];
	int thread_nums[] = {1, 2, 1};

	uv_barrier_init(&blocker, 4);

	shared_num = 0;
	uv_rwlock_init(&numlock);

	uv_thread_create(&threads[0], reader, &thread_nums[0]);
	uv_thread_create(&threads[1], reader, &thread_nums[1]);
	uv_thread_create(&threads[2], writer, &thread_nums[2]);

	uv_barrier_wait(&blocker);
	uv_barrier_destroy(&blocker);

	uv_rwlock_destroy(&numlock);
	return 0;
}
Пример #8
0
// https://github.com/thlorenz/libuv-dox/blob/master/methods.md#uv_rwlock_rdlock
void reader_entry(void *n) {
  int r;
  int num = *(int*)n;
  for (int i = 0; i < ROUNDS; i++) {
    do {
      r = uv_rwlock_tryrdlock(&numlock);

      // implementation ./src/unix/thread.c aborts the process unless return value was EBUSY or EAGAIN
      // so checking here again is redundant and mainly done for documentation
      // fact is that the only r we'd ever get would be EBUSY or EAGAIN (negated)
      if (r && r != -EBUSY && r != -EAGAIN) ERROR("obtaining read lock", r);
    } while(r);

    fprintf(stderr, "Reader %d: aquired lock and shared num = %d\n", num, shared_num);

    uv_rwlock_rdunlock(&numlock);
    fprintf(stderr, "Reader %d: released lock\n", num);
  }
  uv_barrier_wait(&blocker);
}
Пример #9
0
Файл: partr.c Проект: KDr2/julia
// thread function: used by all except the main thread
void jl_threadfun(void *arg)
{
    jl_threadarg_t *targ = (jl_threadarg_t*)arg;

    // initialize this thread (set tid, create heap, set up root task)
    jl_init_threadtls(targ->tid);
    void *stack_lo, *stack_hi;
    jl_init_stack_limits(0, &stack_lo, &stack_hi);
    jl_init_root_task(stack_lo, stack_hi);

    jl_ptls_t ptls = jl_get_ptls_states();
    jl_gc_state_set(ptls, JL_GC_STATE_SAFE, 0);
    uv_barrier_wait(targ->barrier);

    // free the thread argument here
    free(targ);

    (void)jl_gc_unsafe_enter(ptls);
    jl_current_task->exception = jl_nothing;
    jl_finish_task(jl_current_task, jl_nothing); // noreturn
}
Пример #10
0
// same as ./10-locks, but using try* functions when obtaining read and write locks
//
int main() {
  int r;
  const int count = 4;

  fprintf(stderr, "barrier: init\n");
  uv_barrier_init(&blocker, count);

  shared_num = 0;

  // https://github.com/thlorenz/libuv-dox/blob/master/methods.md#rwlock
  fprintf(stderr, "rwlock: init\n");
  r = uv_rwlock_init(&numlock);
  if (r) ERROR("rwlock_init", r);

  uv_thread_t threads[3];

  int thread_nums[] = { 1, 2, 1 };
  r = uv_thread_create(&threads[0], reader_entry, &thread_nums[0]);
  if (r) ERROR("thread_create", r);

  r = uv_thread_create(&threads[1], reader_entry, &thread_nums[1]);
  if (r) ERROR("thread_create", r);

  r = uv_thread_create(&threads[2], writer_entry, &thread_nums[2]);
  if (r) ERROR("thread_create", r);

  // https://github.com/thlorenz/libuv-dox/blob/master/methods.md#barrier
  fprintf(stderr, "barrier: wait\n");
  uv_barrier_wait(&blocker);

  fprintf(stderr, "barrier: destroy\n");
  uv_barrier_destroy(&blocker);

  fprintf(stderr, "rwlock: destroy\n");
  uv_rwlock_destroy(&numlock);
  if (r) ERROR("rwlock_destroy", r);

  return 0;
}
Пример #11
0
static mrb_value
mrb_uv_barrier_wait(mrb_state *mrb, mrb_value self)
{
  uv_barrier_wait((uv_barrier_t*)mrb_uv_get_ptr(mrb, self, &barrier_type));
  return self;
}