diff options
Diffstat (limited to 'include/grpc/support/sync.h')
| -rw-r--r-- | include/grpc/support/sync.h | 60 |
1 files changed, 30 insertions, 30 deletions
diff --git a/include/grpc/support/sync.h b/include/grpc/support/sync.h index ddb85808c7..75192673a6 100644 --- a/include/grpc/support/sync.h +++ b/include/grpc/support/sync.h @@ -34,26 +34,26 @@ extern "C" { gpr_mu are uninitialized when first declared. */ /** Initialize *mu. Requires: *mu uninitialized. */ -GPRAPI void gpr_mu_init(gpr_mu *mu); +GPRAPI void gpr_mu_init(gpr_mu* mu); /** Cause *mu no longer to be initialized, freeing any memory in use. Requires: - *mu initialized; no other concurrent operation on *mu. */ -GPRAPI void gpr_mu_destroy(gpr_mu *mu); + *mu initialized; no other concurrent operation on *mu. */ +GPRAPI void gpr_mu_destroy(gpr_mu* mu); /** Wait until no thread has a lock on *mu, cause the calling thread to own an exclusive lock on *mu, then return. May block indefinitely or crash if the calling thread has a lock on *mu. Requires: *mu initialized. */ -GPRAPI void gpr_mu_lock(gpr_mu *mu); +GPRAPI void gpr_mu_lock(gpr_mu* mu); /** Release an exclusive lock on *mu held by the calling thread. Requires: *mu initialized; the calling thread holds an exclusive lock on *mu. */ -GPRAPI void gpr_mu_unlock(gpr_mu *mu); +GPRAPI void gpr_mu_unlock(gpr_mu* mu); /** Without blocking, attempt to acquire an exclusive lock on *mu for the calling thread, then return non-zero iff success. Fail, if any thread holds the lock; succeeds with high probability if no thread holds the lock. Requires: *mu initialized. */ -GPRAPI int gpr_mu_trylock(gpr_mu *mu); +GPRAPI int gpr_mu_trylock(gpr_mu* mu); /** --- Condition variable interface --- @@ -62,11 +62,11 @@ GPRAPI int gpr_mu_trylock(gpr_mu *mu); uninitialized when first declared. */ /** Initialize *cv. Requires: *cv uninitialized. */ -GPRAPI void gpr_cv_init(gpr_cv *cv); +GPRAPI void gpr_cv_init(gpr_cv* cv); /** Cause *cv no longer to be initialized, freeing any memory in use. Requires: - *cv initialized; no other concurrent operation on *cv.*/ -GPRAPI void gpr_cv_destroy(gpr_cv *cv); + *cv initialized; no other concurrent operation on *cv.*/ +GPRAPI void gpr_cv_destroy(gpr_cv* cv); /** Atomically release *mu and wait on *cv. When the calling thread is woken from *cv or the deadline abs_deadline is exceeded, execute gpr_mu_lock(mu) @@ -75,16 +75,16 @@ GPRAPI void gpr_cv_destroy(gpr_cv *cv); an absolute deadline, or a GPR_TIMESPAN. May return even when not woken explicitly. Requires: *mu and *cv initialized; the calling thread holds an exclusive lock on *mu. */ -GPRAPI int gpr_cv_wait(gpr_cv *cv, gpr_mu *mu, gpr_timespec abs_deadline); +GPRAPI int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline); /** If any threads are waiting on *cv, wake at least one. Clients may treat this as an optimization of gpr_cv_broadcast() for use in the case where waking more than one waiter is not useful. Requires: *cv initialized. */ -GPRAPI void gpr_cv_signal(gpr_cv *cv); +GPRAPI void gpr_cv_signal(gpr_cv* cv); /** Wake all threads waiting on *cv. Requires: *cv initialized. */ -GPRAPI void gpr_cv_broadcast(gpr_cv *cv); +GPRAPI void gpr_cv_broadcast(gpr_cv* cv); /** --- One-time initialization --- @@ -97,7 +97,7 @@ GPRAPI void gpr_cv_broadcast(gpr_cv *cv); If multiple threads call gpr_once() on the same gpr_once instance, one of them will call (*init_routine)(), and the others will block until that call finishes.*/ -GPRAPI void gpr_once_init(gpr_once *once, void (*init_routine)(void)); +GPRAPI void gpr_once_init(gpr_once* once, void (*init_routine)(void)); /** --- One-time event notification --- @@ -107,51 +107,51 @@ GPRAPI void gpr_once_init(gpr_once *once, void (*init_routine)(void)); It requires no destruction. */ /** Initialize *ev. */ -GPRAPI void gpr_event_init(gpr_event *ev); +GPRAPI void gpr_event_init(gpr_event* ev); /** Set *ev so that gpr_event_get() and gpr_event_wait() will return value. Requires: *ev initialized; value != NULL; no prior or concurrent calls to gpr_event_set(ev, ...) since initialization. */ -GPRAPI void gpr_event_set(gpr_event *ev, void *value); +GPRAPI void gpr_event_set(gpr_event* ev, void* value); /** Return the value set by gpr_event_set(ev, ...), or NULL if no such call has completed. If the result is non-NULL, all operations that occurred prior to the gpr_event_set(ev, ...) set will be visible after this call returns. Requires: *ev initialized. This operation is faster than acquiring a mutex on most platforms. */ -GPRAPI void *gpr_event_get(gpr_event *ev); +GPRAPI void* gpr_event_get(gpr_event* ev); /** Wait until *ev is set by gpr_event_set(ev, ...), or abs_deadline is exceeded, then return gpr_event_get(ev). Requires: *ev initialized. Use abs_deadline==gpr_inf_future for no deadline. When the event has been signalled before the call, this operation is faster than acquiring a mutex on most platforms. */ -GPRAPI void *gpr_event_wait(gpr_event *ev, gpr_timespec abs_deadline); +GPRAPI void* gpr_event_wait(gpr_event* ev, gpr_timespec abs_deadline); /** --- Reference counting --- These calls act on the type gpr_refcount. It requires no destruction. */ /** Initialize *r to value n. */ -GPRAPI void gpr_ref_init(gpr_refcount *r, int n); +GPRAPI void gpr_ref_init(gpr_refcount* r, int n); /** Increment the reference count *r. Requires *r initialized. */ -GPRAPI void gpr_ref(gpr_refcount *r); +GPRAPI void gpr_ref(gpr_refcount* r); /** Increment the reference count *r. Requires *r initialized. Crashes if refcount is zero */ -GPRAPI void gpr_ref_non_zero(gpr_refcount *r); +GPRAPI void gpr_ref_non_zero(gpr_refcount* r); /** Increment the reference count *r by n. Requires *r initialized, n > 0. */ -GPRAPI void gpr_refn(gpr_refcount *r, int n); +GPRAPI void gpr_refn(gpr_refcount* r, int n); /** Decrement the reference count *r and return non-zero iff it has reached zero. . Requires *r initialized. */ -GPRAPI int gpr_unref(gpr_refcount *r); +GPRAPI int gpr_unref(gpr_refcount* r); /** Return non-zero iff the reference count of *r is one, and thus is owned by exactly one object. */ -GPRAPI int gpr_ref_is_unique(gpr_refcount *r); +GPRAPI int gpr_ref_is_unique(gpr_refcount* r); /** --- Stats counters --- @@ -162,13 +162,13 @@ GPRAPI int gpr_ref_is_unique(gpr_refcount *r); synchronize other events. */ /** Initialize *c to the value n. */ -GPRAPI void gpr_stats_init(gpr_stats_counter *c, intptr_t n); +GPRAPI void gpr_stats_init(gpr_stats_counter* c, intptr_t n); /** *c += inc. Requires: *c initialized. */ -GPRAPI void gpr_stats_inc(gpr_stats_counter *c, intptr_t inc); +GPRAPI void gpr_stats_inc(gpr_stats_counter* c, intptr_t inc); /** Return *c. Requires: *c initialized. */ -GPRAPI intptr_t gpr_stats_read(const gpr_stats_counter *c); +GPRAPI intptr_t gpr_stats_read(const gpr_stats_counter* c); /** ==================Example use of interface=================== A producer-consumer queue of up to N integers, @@ -280,14 +280,14 @@ namespace grpc_core { class mu_guard { public: - mu_guard(gpr_mu *mu) : mu_(mu) { gpr_mu_lock(mu); } + mu_guard(gpr_mu* mu) : mu_(mu) { gpr_mu_lock(mu); } ~mu_guard() { gpr_mu_unlock(mu_); } - mu_guard(const mu_guard &) = delete; - mu_guard &operator=(const mu_guard &) = delete; + mu_guard(const mu_guard&) = delete; + mu_guard& operator=(const mu_guard&) = delete; private: - gpr_mu *const mu_; + gpr_mu* const mu_; }; } // namespace grpc_core |