mirror of https://github.com/grpc/grpc.git
David Garcia Quintas
9 years ago
commit
1665059f63
16 changed files with 2 additions and 541 deletions
@ -1,56 +0,0 @@ |
|||||||
/*
|
|
||||||
* |
|
||||||
* Copyright 2015, Google Inc. |
|
||||||
* All rights reserved. |
|
||||||
* |
|
||||||
* Redistribution and use in source and binary forms, with or without |
|
||||||
* modification, are permitted provided that the following conditions are |
|
||||||
* met: |
|
||||||
* |
|
||||||
* * Redistributions of source code must retain the above copyright |
|
||||||
* notice, this list of conditions and the following disclaimer. |
|
||||||
* * Redistributions in binary form must reproduce the above |
|
||||||
* copyright notice, this list of conditions and the following disclaimer |
|
||||||
* in the documentation and/or other materials provided with the |
|
||||||
* distribution. |
|
||||||
* * Neither the name of Google Inc. nor the names of its |
|
||||||
* contributors may be used to endorse or promote products derived from |
|
||||||
* this software without specific prior written permission. |
|
||||||
* |
|
||||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
|
||||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
|
||||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
|
||||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
|
||||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|
||||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
|
||||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
|
||||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
|
||||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
|
||||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
|
||||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
||||||
* |
|
||||||
*/ |
|
||||||
|
|
||||||
#ifndef GRPC_SUPPORT_CANCELLABLE_PLATFORM_H |
|
||||||
#define GRPC_SUPPORT_CANCELLABLE_PLATFORM_H |
|
||||||
|
|
||||||
#include <grpc/support/atm.h> |
|
||||||
#include <grpc/support/sync.h> |
|
||||||
|
|
||||||
struct gpr_cancellable_list_ { |
|
||||||
/* a doubly-linked list on cancellable's waiters queue */ |
|
||||||
struct gpr_cancellable_list_ *next; |
|
||||||
struct gpr_cancellable_list_ *prev; |
|
||||||
/* The following two fields are arguments to gpr_cv_cancellable_wait() */ |
|
||||||
gpr_mu *mu; |
|
||||||
gpr_cv *cv; |
|
||||||
}; |
|
||||||
|
|
||||||
/* Internal definition of gpr_cancellable. */ |
|
||||||
typedef struct { |
|
||||||
gpr_mu mu; /* protects waiters and modifications to cancelled */ |
|
||||||
gpr_atm cancelled; |
|
||||||
struct gpr_cancellable_list_ waiters; |
|
||||||
} gpr_cancellable; |
|
||||||
|
|
||||||
#endif /* GRPC_SUPPORT_CANCELLABLE_PLATFORM_H */ |
|
||||||
@ -1,157 +0,0 @@ |
|||||||
/*
|
|
||||||
* |
|
||||||
* Copyright 2015, Google Inc. |
|
||||||
* All rights reserved. |
|
||||||
* |
|
||||||
* Redistribution and use in source and binary forms, with or without |
|
||||||
* modification, are permitted provided that the following conditions are |
|
||||||
* met: |
|
||||||
* |
|
||||||
* * Redistributions of source code must retain the above copyright |
|
||||||
* notice, this list of conditions and the following disclaimer. |
|
||||||
* * Redistributions in binary form must reproduce the above |
|
||||||
* copyright notice, this list of conditions and the following disclaimer |
|
||||||
* in the documentation and/or other materials provided with the |
|
||||||
* distribution. |
|
||||||
* * Neither the name of Google Inc. nor the names of its |
|
||||||
* contributors may be used to endorse or promote products derived from |
|
||||||
* this software without specific prior written permission. |
|
||||||
* |
|
||||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
|
||||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
|
||||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
|
||||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
|
||||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|
||||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
|
||||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
|
||||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
|
||||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
|
||||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
|
||||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
||||||
* |
|
||||||
*/ |
|
||||||
|
|
||||||
/* Implementation for gpr_cancellable */ |
|
||||||
|
|
||||||
#include <grpc/support/atm.h> |
|
||||||
#include <grpc/support/sync.h> |
|
||||||
#include <grpc/support/time.h> |
|
||||||
|
|
||||||
void gpr_cancellable_init(gpr_cancellable *c) { |
|
||||||
gpr_mu_init(&c->mu); |
|
||||||
c->cancelled = 0; |
|
||||||
c->waiters.next = &c->waiters; |
|
||||||
c->waiters.prev = &c->waiters; |
|
||||||
c->waiters.mu = NULL; |
|
||||||
c->waiters.cv = NULL; |
|
||||||
} |
|
||||||
|
|
||||||
void gpr_cancellable_destroy(gpr_cancellable *c) { gpr_mu_destroy(&c->mu); } |
|
||||||
|
|
||||||
int gpr_cancellable_is_cancelled(gpr_cancellable *c) { |
|
||||||
return gpr_atm_acq_load(&c->cancelled) != 0; |
|
||||||
} |
|
||||||
|
|
||||||
/* Threads in gpr_cv_cancellable_wait(cv, mu, ..., c) place themselves on a
|
|
||||||
linked list c->waiters of gpr_cancellable_list_ before waiting on their |
|
||||||
condition variables. They check for cancellation while holding *mu. Thus, |
|
||||||
to wake a thread from gpr_cv_cancellable_wait(), it suffices to: |
|
||||||
- set c->cancelled |
|
||||||
- acquire and release *mu |
|
||||||
- gpr_cv_broadcast(cv) |
|
||||||
|
|
||||||
However, gpr_cancellable_cancel() may not use gpr_mu_lock(mu), since the |
|
||||||
caller may already hold *mu---a possible deadlock. (If we knew the caller |
|
||||||
did not hold *mu, care would still be needed, because c->mu follows *mu in |
|
||||||
the locking order, so *mu could not be acquired while holding c->mu---which |
|
||||||
is needed to iterate over c->waiters.) |
|
||||||
|
|
||||||
Therefore, gpr_cancellable_cancel() uses gpr_mu_trylock() rather than |
|
||||||
gpr_mu_lock(), and retries until either gpr_mu_trylock() succeeds or the |
|
||||||
thread leaves gpr_cv_cancellable_wait() for other reasons. In the first |
|
||||||
case, gpr_cancellable_cancel() removes the entry from the waiters list; in |
|
||||||
the second, the waiting thread removes itself from the list. |
|
||||||
|
|
||||||
A one-entry cache of mutexes and condition variables processed is kept to |
|
||||||
avoid doing the same work again and again if many threads are blocked in the |
|
||||||
same place. However, it's important to broadcast on a condition variable if |
|
||||||
the corresponding mutex has been locked successfully, even if the condition |
|
||||||
variable has been signalled before. */ |
|
||||||
|
|
||||||
void gpr_cancellable_cancel(gpr_cancellable *c) { |
|
||||||
if (!gpr_cancellable_is_cancelled(c)) { |
|
||||||
int failures; |
|
||||||
int backoff = 1; |
|
||||||
do { |
|
||||||
struct gpr_cancellable_list_ *l; |
|
||||||
struct gpr_cancellable_list_ *nl; |
|
||||||
gpr_mu *omu = 0; /* one-element cache of a processed gpr_mu */ |
|
||||||
gpr_cv *ocv = 0; /* one-element cache of a processd gpr_cv */ |
|
||||||
gpr_mu_lock(&c->mu); |
|
||||||
gpr_atm_rel_store(&c->cancelled, 1); |
|
||||||
failures = 0; |
|
||||||
for (l = c->waiters.next; l != &c->waiters; l = nl) { |
|
||||||
nl = l->next; |
|
||||||
if (omu != l->mu) { |
|
||||||
omu = l->mu; |
|
||||||
if (gpr_mu_trylock(l->mu)) { |
|
||||||
gpr_mu_unlock(l->mu); |
|
||||||
l->next->prev = l->prev; /* remove *l from list */ |
|
||||||
l->prev->next = l->next; |
|
||||||
/* allow unconditional dequeue in gpr_cv_cancellable_wait() */ |
|
||||||
l->next = l; |
|
||||||
l->prev = l; |
|
||||||
ocv = 0; /* force broadcast */ |
|
||||||
} else { |
|
||||||
failures++; |
|
||||||
} |
|
||||||
} |
|
||||||
if (ocv != l->cv) { |
|
||||||
ocv = l->cv; |
|
||||||
gpr_cv_broadcast(l->cv); |
|
||||||
} |
|
||||||
} |
|
||||||
gpr_mu_unlock(&c->mu); |
|
||||||
if (failures != 0) { |
|
||||||
if (backoff < 10) { |
|
||||||
volatile int i; |
|
||||||
for (i = 0; i != (1 << backoff); i++) { |
|
||||||
} |
|
||||||
backoff++; |
|
||||||
} else { |
|
||||||
gpr_event ev; |
|
||||||
gpr_event_init(&ev); |
|
||||||
gpr_event_wait( |
|
||||||
&ev, gpr_time_add(gpr_now(GPR_CLOCK_REALTIME), |
|
||||||
gpr_time_from_micros(1000, GPR_TIMESPAN))); |
|
||||||
} |
|
||||||
} |
|
||||||
} while (failures != 0); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
int gpr_cv_cancellable_wait(gpr_cv *cv, gpr_mu *mu, gpr_timespec abs_deadline, |
|
||||||
gpr_cancellable *c) { |
|
||||||
gpr_int32 timeout; |
|
||||||
gpr_mu_lock(&c->mu); |
|
||||||
timeout = gpr_cancellable_is_cancelled(c); |
|
||||||
if (!timeout) { |
|
||||||
struct gpr_cancellable_list_ le; |
|
||||||
le.mu = mu; |
|
||||||
le.cv = cv; |
|
||||||
le.next = c->waiters.next; |
|
||||||
le.prev = &c->waiters; |
|
||||||
le.next->prev = ≤ |
|
||||||
le.prev->next = ≤ |
|
||||||
gpr_mu_unlock(&c->mu); |
|
||||||
timeout = gpr_cv_wait(cv, mu, abs_deadline); |
|
||||||
gpr_mu_lock(&c->mu); |
|
||||||
le.next->prev = le.prev; |
|
||||||
le.prev->next = le.next; |
|
||||||
if (!timeout) { |
|
||||||
timeout = gpr_cancellable_is_cancelled(c); |
|
||||||
} |
|
||||||
} |
|
||||||
gpr_mu_unlock(&c->mu); |
|
||||||
return timeout; |
|
||||||
} |
|
||||||
@ -1,172 +0,0 @@ |
|||||||
/*
|
|
||||||
* |
|
||||||
* Copyright 2015, Google Inc. |
|
||||||
* All rights reserved. |
|
||||||
* |
|
||||||
* Redistribution and use in source and binary forms, with or without |
|
||||||
* modification, are permitted provided that the following conditions are |
|
||||||
* met: |
|
||||||
* |
|
||||||
* * Redistributions of source code must retain the above copyright |
|
||||||
* notice, this list of conditions and the following disclaimer. |
|
||||||
* * Redistributions in binary form must reproduce the above |
|
||||||
* copyright notice, this list of conditions and the following disclaimer |
|
||||||
* in the documentation and/or other materials provided with the |
|
||||||
* distribution. |
|
||||||
* * Neither the name of Google Inc. nor the names of its |
|
||||||
* contributors may be used to endorse or promote products derived from |
|
||||||
* this software without specific prior written permission. |
|
||||||
* |
|
||||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
|
||||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
|
||||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
|
||||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
|
||||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|
||||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
|
||||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
|
||||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
|
||||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
|
||||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
|
||||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
||||||
* |
|
||||||
*/ |
|
||||||
|
|
||||||
/* Test of gpr_cancellable. */ |
|
||||||
|
|
||||||
#include <stdio.h> |
|
||||||
#include <stdlib.h> |
|
||||||
#include <grpc/support/log.h> |
|
||||||
#include <grpc/support/sync.h> |
|
||||||
#include <grpc/support/thd.h> |
|
||||||
#include <grpc/support/time.h> |
|
||||||
#include "test/core/util/test_config.h" |
|
||||||
|
|
||||||
struct test { |
|
||||||
gpr_mu mu; |
|
||||||
gpr_cv cv; |
|
||||||
gpr_event ev; |
|
||||||
gpr_event done; |
|
||||||
gpr_cancellable cancel; |
|
||||||
int n; |
|
||||||
}; |
|
||||||
|
|
||||||
/* A thread body. Wait until t->cancel is cancelledm then
|
|
||||||
decrement t->n. If t->n becomes 0, set t->done. */ |
|
||||||
static void thd_body(void *v) { |
|
||||||
struct test *t = v; |
|
||||||
gpr_mu_lock(&t->mu); |
|
||||||
while (!gpr_cv_cancellable_wait( |
|
||||||
&t->cv, &t->mu, gpr_inf_future(GPR_CLOCK_REALTIME), &t->cancel)) { |
|
||||||
} |
|
||||||
t->n--; |
|
||||||
if (t->n == 0) { |
|
||||||
gpr_event_set(&t->done, (void *)1); |
|
||||||
} |
|
||||||
gpr_mu_unlock(&t->mu); |
|
||||||
} |
|
||||||
|
|
||||||
static void test(void) { |
|
||||||
int i; |
|
||||||
gpr_thd_id thd; |
|
||||||
struct test t; |
|
||||||
int n = 1; |
|
||||||
gpr_timespec interval; |
|
||||||
|
|
||||||
gpr_mu_init(&t.mu); |
|
||||||
gpr_cv_init(&t.cv); |
|
||||||
gpr_event_init(&t.ev); |
|
||||||
gpr_event_init(&t.done); |
|
||||||
gpr_cancellable_init(&t.cancel); |
|
||||||
|
|
||||||
/* A gpr_cancellable starts not cancelled. */ |
|
||||||
GPR_ASSERT(!gpr_cancellable_is_cancelled(&t.cancel)); |
|
||||||
|
|
||||||
/* Test timeout on event wait for uncancelled gpr_cancellable */ |
|
||||||
interval = gpr_now(GPR_CLOCK_REALTIME); |
|
||||||
gpr_event_cancellable_wait( |
|
||||||
&t.ev, gpr_time_add(gpr_now(GPR_CLOCK_REALTIME), |
|
||||||
gpr_time_from_micros(1000000, GPR_TIMESPAN)), |
|
||||||
&t.cancel); |
|
||||||
interval = gpr_time_sub(gpr_now(GPR_CLOCK_REALTIME), interval); |
|
||||||
GPR_ASSERT( |
|
||||||
gpr_time_cmp(interval, gpr_time_from_micros(500000, GPR_TIMESPAN)) >= 0); |
|
||||||
GPR_ASSERT( |
|
||||||
gpr_time_cmp(gpr_time_from_micros(2000000, GPR_TIMESPAN), interval) >= 0); |
|
||||||
|
|
||||||
/* Test timeout on cv wait for uncancelled gpr_cancellable */ |
|
||||||
gpr_mu_lock(&t.mu); |
|
||||||
interval = gpr_now(GPR_CLOCK_REALTIME); |
|
||||||
while (!gpr_cv_cancellable_wait( |
|
||||||
&t.cv, &t.mu, gpr_time_add(gpr_now(GPR_CLOCK_REALTIME), |
|
||||||
gpr_time_from_micros(1000000, GPR_TIMESPAN)), |
|
||||||
&t.cancel)) { |
|
||||||
} |
|
||||||
interval = gpr_time_sub(gpr_now(GPR_CLOCK_REALTIME), interval); |
|
||||||
GPR_ASSERT( |
|
||||||
gpr_time_cmp(interval, gpr_time_from_micros(500000, GPR_TIMESPAN)) >= 0); |
|
||||||
GPR_ASSERT( |
|
||||||
gpr_time_cmp(gpr_time_from_micros(2000000, GPR_TIMESPAN), interval) >= 0); |
|
||||||
gpr_mu_unlock(&t.mu); |
|
||||||
|
|
||||||
/* Create some threads. They all wait until cancelled; the last to finish
|
|
||||||
sets t.done. */ |
|
||||||
t.n = n; |
|
||||||
for (i = 0; i != n; i++) { |
|
||||||
GPR_ASSERT(gpr_thd_new(&thd, &thd_body, &t, NULL)); |
|
||||||
} |
|
||||||
/* Check that t.cancel still is not cancelled. */ |
|
||||||
GPR_ASSERT(!gpr_cancellable_is_cancelled(&t.cancel)); |
|
||||||
|
|
||||||
/* Wait a second, and check that no threads have finished waiting. */ |
|
||||||
gpr_mu_lock(&t.mu); |
|
||||||
gpr_cv_wait(&t.cv, &t.mu, |
|
||||||
gpr_time_add(gpr_now(GPR_CLOCK_REALTIME), |
|
||||||
gpr_time_from_micros(1000000, GPR_TIMESPAN))); |
|
||||||
GPR_ASSERT(t.n == n); |
|
||||||
gpr_mu_unlock(&t.mu); |
|
||||||
|
|
||||||
/* Check that t.cancel still is not cancelled, but when
|
|
||||||
cancelled it retports that it is cacncelled. */ |
|
||||||
GPR_ASSERT(!gpr_cancellable_is_cancelled(&t.cancel)); |
|
||||||
gpr_cancellable_cancel(&t.cancel); |
|
||||||
GPR_ASSERT(gpr_cancellable_is_cancelled(&t.cancel)); |
|
||||||
|
|
||||||
/* Wait for threads to finish. */ |
|
||||||
gpr_event_wait(&t.done, gpr_inf_future(GPR_CLOCK_REALTIME)); |
|
||||||
GPR_ASSERT(t.n == 0); |
|
||||||
|
|
||||||
/* Test timeout on cv wait for cancelled gpr_cancellable */ |
|
||||||
gpr_mu_lock(&t.mu); |
|
||||||
interval = gpr_now(GPR_CLOCK_REALTIME); |
|
||||||
while (!gpr_cv_cancellable_wait( |
|
||||||
&t.cv, &t.mu, gpr_time_add(gpr_now(GPR_CLOCK_REALTIME), |
|
||||||
gpr_time_from_micros(1000000, GPR_TIMESPAN)), |
|
||||||
&t.cancel)) { |
|
||||||
} |
|
||||||
interval = gpr_time_sub(gpr_now(GPR_CLOCK_REALTIME), interval); |
|
||||||
GPR_ASSERT( |
|
||||||
gpr_time_cmp(gpr_time_from_micros(100000, GPR_TIMESPAN), interval) >= 0); |
|
||||||
gpr_mu_unlock(&t.mu); |
|
||||||
|
|
||||||
/* Test timeout on event wait for cancelled gpr_cancellable */ |
|
||||||
interval = gpr_now(GPR_CLOCK_REALTIME); |
|
||||||
gpr_event_cancellable_wait( |
|
||||||
&t.ev, gpr_time_add(gpr_now(GPR_CLOCK_REALTIME), |
|
||||||
gpr_time_from_micros(1000000, GPR_TIMESPAN)), |
|
||||||
&t.cancel); |
|
||||||
interval = gpr_time_sub(gpr_now(GPR_CLOCK_REALTIME), interval); |
|
||||||
GPR_ASSERT( |
|
||||||
gpr_time_cmp(gpr_time_from_micros(100000, GPR_TIMESPAN), interval) >= 0); |
|
||||||
|
|
||||||
gpr_mu_destroy(&t.mu); |
|
||||||
gpr_cv_destroy(&t.cv); |
|
||||||
gpr_cancellable_destroy(&t.cancel); |
|
||||||
} |
|
||||||
|
|
||||||
/* ------------------------------------------------- */ |
|
||||||
|
|
||||||
int main(int argc, char *argv[]) { |
|
||||||
grpc_test_init(argc, argv); |
|
||||||
test(); |
|
||||||
return 0; |
|
||||||
} |
|
||||||
File diff suppressed because one or more lines are too long
Loading…
Reference in new issue