aboutsummaryrefslogtreecommitdiffhomepage
path: root/src/core/lib/iomgr/ev_poll_posix.cc
diff options
context:
space:
mode:
Diffstat (limited to 'src/core/lib/iomgr/ev_poll_posix.cc')
-rw-r--r--src/core/lib/iomgr/ev_poll_posix.cc96
1 files changed, 51 insertions, 45 deletions
diff --git a/src/core/lib/iomgr/ev_poll_posix.cc b/src/core/lib/iomgr/ev_poll_posix.cc
index 3b79728055..e92163322f 100644
--- a/src/core/lib/iomgr/ev_poll_posix.cc
+++ b/src/core/lib/iomgr/ev_poll_posix.cc
@@ -34,11 +34,11 @@
#include <grpc/support/log.h>
#include <grpc/support/string_util.h>
#include <grpc/support/thd.h>
-#include <grpc/support/tls.h>
-#include <grpc/support/useful.h>
#include "src/core/lib/debug/stats.h"
#include "src/core/lib/gpr/murmur_hash.h"
+#include "src/core/lib/gpr/tls.h"
+#include "src/core/lib/gpr/useful.h"
#include "src/core/lib/iomgr/block_annotate.h"
#include "src/core/lib/iomgr/iomgr_internal.h"
#include "src/core/lib/iomgr/wakeup_fd_cv.h"
@@ -323,7 +323,7 @@ static void unref_by(grpc_fd* fd, int n) {
}
static grpc_fd* fd_create(int fd, const char* name) {
- grpc_fd* r = (grpc_fd*)gpr_malloc(sizeof(*r));
+ grpc_fd* r = static_cast<grpc_fd*>(gpr_malloc(sizeof(*r)));
gpr_mu_init(&r->mu);
gpr_atm_rel_store(&r->refst, 1);
r->shutdown = 0;
@@ -457,16 +457,20 @@ static grpc_error* fd_shutdown_error(grpc_fd* fd) {
if (!fd->shutdown) {
return GRPC_ERROR_NONE;
} else {
- return GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
- "FD shutdown", &fd->shutdown_error, 1);
+ return grpc_error_set_int(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+ "FD shutdown", &fd->shutdown_error, 1),
+ GRPC_ERROR_INT_GRPC_STATUS,
+ GRPC_STATUS_UNAVAILABLE);
}
}
static void notify_on_locked(grpc_fd* fd, grpc_closure** st,
grpc_closure* closure) {
if (fd->shutdown || gpr_atm_no_barrier_load(&fd->pollhup)) {
- GRPC_CLOSURE_SCHED(closure,
- GRPC_ERROR_CREATE_FROM_STATIC_STRING("FD shutdown"));
+ GRPC_CLOSURE_SCHED(
+ closure, grpc_error_set_int(
+ GRPC_ERROR_CREATE_FROM_STATIC_STRING("FD shutdown"),
+ GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE));
} else if (*st == CLOSURE_NOT_READY) {
/* not ready ==> switch to a waiting state by setting the closure */
*st = closure;
@@ -706,14 +710,14 @@ static void kick_append_error(grpc_error** composite, grpc_error* error) {
static grpc_error* pollset_kick_ext(grpc_pollset* p,
grpc_pollset_worker* specific_worker,
uint32_t flags) {
- GPR_TIMER_BEGIN("pollset_kick_ext", 0);
+ GPR_TIMER_SCOPE("pollset_kick_ext", 0);
grpc_error* error = GRPC_ERROR_NONE;
GRPC_STATS_INC_POLLSET_KICK();
/* pollset->mu already held */
if (specific_worker != nullptr) {
if (specific_worker == GRPC_POLLSET_KICK_BROADCAST) {
- GPR_TIMER_BEGIN("pollset_kick_ext.broadcast", 0);
+ GPR_TIMER_SCOPE("pollset_kick_ext.broadcast", 0);
GPR_ASSERT((flags & GRPC_POLLSET_REEVALUATE_POLLING_ON_WAKEUP) == 0);
for (specific_worker = p->root_worker.next;
specific_worker != &p->root_worker;
@@ -722,7 +726,6 @@ static grpc_error* pollset_kick_ext(grpc_pollset* p,
&error, grpc_wakeup_fd_wakeup(&specific_worker->wakeup_fd->fd));
}
p->kicked_without_pollers = true;
- GPR_TIMER_END("pollset_kick_ext.broadcast", 0);
} else if (gpr_tls_get(&g_current_thread_worker) !=
(intptr_t)specific_worker) {
GPR_TIMER_MARK("different_thread_worker", 0);
@@ -769,7 +772,6 @@ static grpc_error* pollset_kick_ext(grpc_pollset* p,
}
}
- GPR_TIMER_END("pollset_kick_ext", 0);
GRPC_LOG_IF_ERROR("pollset_kick_ext", GRPC_ERROR_REF(error));
return error;
}
@@ -833,8 +835,8 @@ static void pollset_add_fd(grpc_pollset* pollset, grpc_fd* fd) {
if (pollset->fd_count == pollset->fd_capacity) {
pollset->fd_capacity =
GPR_MAX(pollset->fd_capacity + 8, pollset->fd_count * 3 / 2);
- pollset->fds = (grpc_fd**)gpr_realloc(
- pollset->fds, sizeof(grpc_fd*) * pollset->fd_capacity);
+ pollset->fds = static_cast<grpc_fd**>(
+ gpr_realloc(pollset->fds, sizeof(grpc_fd*) * pollset->fd_capacity));
}
pollset->fds[pollset->fd_count++] = fd;
GRPC_FD_REF(fd, "multipoller");
@@ -864,6 +866,8 @@ static void work_combine_error(grpc_error** composite, grpc_error* error) {
static grpc_error* pollset_work(grpc_pollset* pollset,
grpc_pollset_worker** worker_hdl,
grpc_millis deadline) {
+ GPR_TIMER_SCOPE("pollset_work", 0);
+
grpc_pollset_worker worker;
if (worker_hdl) *worker_hdl = &worker;
grpc_error* error = GRPC_ERROR_NONE;
@@ -878,7 +882,6 @@ static grpc_error* pollset_work(grpc_pollset* pollset,
int locked = 1;
int queued_work = 0;
int keep_polling = 0;
- GPR_TIMER_BEGIN("pollset_work", 0);
/* this must happen before we (potentially) drop pollset->mu */
worker.next = worker.prev = nullptr;
worker.reevaluate_polling_on_wakeup = 0;
@@ -886,8 +889,8 @@ static grpc_error* pollset_work(grpc_pollset* pollset,
worker.wakeup_fd = pollset->local_wakeup_cache;
pollset->local_wakeup_cache = worker.wakeup_fd->next;
} else {
- worker.wakeup_fd =
- (grpc_cached_wakeup_fd*)gpr_malloc(sizeof(*worker.wakeup_fd));
+ worker.wakeup_fd = static_cast<grpc_cached_wakeup_fd*>(
+ gpr_malloc(sizeof(*worker.wakeup_fd)));
error = grpc_wakeup_fd_init(&worker.wakeup_fd->fd);
if (error != GRPC_ERROR_NONE) {
GRPC_LOG_IF_ERROR("pollset_work", GRPC_ERROR_REF(error));
@@ -921,7 +924,7 @@ static grpc_error* pollset_work(grpc_pollset* pollset,
added_worker = 1;
gpr_tls_set(&g_current_thread_worker, (intptr_t)&worker);
}
- GPR_TIMER_BEGIN("maybe_work_and_unlock", 0);
+ GPR_TIMER_SCOPE("maybe_work_and_unlock", 0);
#define POLLOUT_CHECK (POLLOUT | POLLHUP | POLLERR)
#define POLLIN_CHECK (POLLIN | POLLHUP | POLLERR)
@@ -942,8 +945,9 @@ static grpc_error* pollset_work(grpc_pollset* pollset,
const size_t pfd_size = sizeof(*pfds) * (pollset->fd_count + 2);
const size_t watch_size = sizeof(*watchers) * (pollset->fd_count + 2);
void* buf = gpr_malloc(pfd_size + watch_size);
- pfds = (struct pollfd*)buf;
- watchers = (grpc_fd_watcher*)(void*)((char*)buf + pfd_size);
+ pfds = static_cast<struct pollfd*>(buf);
+ watchers = static_cast<grpc_fd_watcher*>(
+ (void*)(static_cast<char*>(buf) + pfd_size));
}
fd_count = 0;
@@ -969,8 +973,8 @@ static grpc_error* pollset_work(grpc_pollset* pollset,
for (i = 1; i < pfd_count; i++) {
grpc_fd* fd = watchers[i].fd;
- pfds[i].events = (short)fd_begin_poll(fd, pollset, &worker, POLLIN,
- POLLOUT, &watchers[i]);
+ pfds[i].events = static_cast<short>(
+ fd_begin_poll(fd, pollset, &worker, POLLIN, POLLOUT, &watchers[i]));
GRPC_FD_UNREF(fd, "multipoller_start");
}
@@ -1037,7 +1041,6 @@ static grpc_error* pollset_work(grpc_pollset* pollset,
gpr_free(pfds);
}
- GPR_TIMER_END("maybe_work_and_unlock", 0);
locked = 0;
} else {
GPR_TIMER_MARK("pollset_work.kicked_without_pollers", 0);
@@ -1097,7 +1100,6 @@ static grpc_error* pollset_work(grpc_pollset* pollset,
}
}
if (worker_hdl) *worker_hdl = nullptr;
- GPR_TIMER_END("pollset_work", 0);
GRPC_LOG_IF_ERROR("pollset_work", GRPC_ERROR_REF(error));
return error;
}
@@ -1122,7 +1124,7 @@ static int poll_deadline_to_millis_timeout(grpc_millis deadline) {
grpc_millis n = deadline - grpc_core::ExecCtx::Get()->Now();
if (n < 0) return 0;
if (n > INT_MAX) return -1;
- return (int)n;
+ return static_cast<int>(n);
}
/*******************************************************************************
@@ -1131,7 +1133,7 @@ static int poll_deadline_to_millis_timeout(grpc_millis deadline) {
static grpc_pollset_set* pollset_set_create(void) {
grpc_pollset_set* pollset_set =
- (grpc_pollset_set*)gpr_zalloc(sizeof(*pollset_set));
+ static_cast<grpc_pollset_set*>(gpr_zalloc(sizeof(*pollset_set)));
gpr_mu_init(&pollset_set->mu);
return pollset_set;
}
@@ -1172,9 +1174,9 @@ static void pollset_set_add_pollset(grpc_pollset_set* pollset_set,
if (pollset_set->pollset_count == pollset_set->pollset_capacity) {
pollset_set->pollset_capacity =
GPR_MAX(8, 2 * pollset_set->pollset_capacity);
- pollset_set->pollsets = (grpc_pollset**)gpr_realloc(
+ pollset_set->pollsets = static_cast<grpc_pollset**>(gpr_realloc(
pollset_set->pollsets,
- pollset_set->pollset_capacity * sizeof(*pollset_set->pollsets));
+ pollset_set->pollset_capacity * sizeof(*pollset_set->pollsets)));
}
pollset_set->pollsets[pollset_set->pollset_count++] = pollset;
for (i = 0, j = 0; i < pollset_set->fd_count; i++) {
@@ -1221,9 +1223,9 @@ static void pollset_set_add_pollset_set(grpc_pollset_set* bag,
gpr_mu_lock(&bag->mu);
if (bag->pollset_set_count == bag->pollset_set_capacity) {
bag->pollset_set_capacity = GPR_MAX(8, 2 * bag->pollset_set_capacity);
- bag->pollset_sets = (grpc_pollset_set**)gpr_realloc(
- bag->pollset_sets,
- bag->pollset_set_capacity * sizeof(*bag->pollset_sets));
+ bag->pollset_sets = static_cast<grpc_pollset_set**>(
+ gpr_realloc(bag->pollset_sets,
+ bag->pollset_set_capacity * sizeof(*bag->pollset_sets)));
}
bag->pollset_sets[bag->pollset_set_count++] = item;
for (i = 0, j = 0; i < bag->fd_count; i++) {
@@ -1258,8 +1260,9 @@ static void pollset_set_add_fd(grpc_pollset_set* pollset_set, grpc_fd* fd) {
gpr_mu_lock(&pollset_set->mu);
if (pollset_set->fd_count == pollset_set->fd_capacity) {
pollset_set->fd_capacity = GPR_MAX(8, 2 * pollset_set->fd_capacity);
- pollset_set->fds = (grpc_fd**)gpr_realloc(
- pollset_set->fds, pollset_set->fd_capacity * sizeof(*pollset_set->fds));
+ pollset_set->fds = static_cast<grpc_fd**>(
+ gpr_realloc(pollset_set->fds,
+ pollset_set->fd_capacity * sizeof(*pollset_set->fds)));
}
GRPC_FD_REF(fd, "pollset_set");
pollset_set->fds[pollset_set->fd_count++] = fd;
@@ -1311,12 +1314,12 @@ static void cache_insert_locked(poll_args* args) {
}
static void init_result(poll_args* pargs) {
- pargs->result = (poll_result*)gpr_malloc(sizeof(poll_result));
+ pargs->result = static_cast<poll_result*>(gpr_malloc(sizeof(poll_result)));
gpr_ref_init(&pargs->result->refcount, 1);
pargs->result->watchers = nullptr;
pargs->result->watchcount = 0;
- pargs->result->fds =
- (struct pollfd*)gpr_malloc(sizeof(struct pollfd) * pargs->nfds);
+ pargs->result->fds = static_cast<struct pollfd*>(
+ gpr_malloc(sizeof(struct pollfd) * pargs->nfds));
memcpy(pargs->result->fds, pargs->fds, sizeof(struct pollfd) * pargs->nfds);
pargs->result->nfds = pargs->nfds;
pargs->result->retval = 0;
@@ -1355,7 +1358,8 @@ static poll_args* get_poller_locked(struct pollfd* fds, nfds_t count) {
return pargs;
}
- poll_args* pargs = (poll_args*)gpr_malloc(sizeof(struct poll_args));
+ poll_args* pargs =
+ static_cast<poll_args*>(gpr_malloc(sizeof(struct poll_args)));
gpr_cv_init(&pargs->trigger);
pargs->fds = fds;
pargs->nfds = count;
@@ -1403,7 +1407,7 @@ static void cache_poller_locked(poll_args* args) {
poll_cache.size = poll_cache.size * 2;
poll_cache.count = 0;
poll_cache.active_pollers =
- (poll_args**)gpr_malloc(sizeof(void*) * poll_cache.size);
+ static_cast<poll_args**>(gpr_malloc(sizeof(void*) * poll_cache.size));
for (unsigned int i = 0; i < poll_cache.size; i++) {
poll_cache.active_pollers[i] = nullptr;
}
@@ -1460,7 +1464,7 @@ gpr_timespec thread_grace;
// Poll in a background thread
static void run_poll(void* args) {
- poll_args* pargs = (poll_args*)args;
+ poll_args* pargs = static_cast<poll_args*>(args);
while (1) {
poll_result* result = pargs->result;
int retval = g_cvfds.poll(result->fds, result->nfds, CV_POLL_PERIOD_MS);
@@ -1508,12 +1512,13 @@ static int cvfd_poll(struct pollfd* fds, nfds_t nfds, int timeout) {
nfds_t nsockfds = 0;
poll_result* result = nullptr;
gpr_mu_lock(&g_cvfds.mu);
- pollcv = (grpc_cv_node*)gpr_malloc(sizeof(grpc_cv_node));
+ pollcv = static_cast<grpc_cv_node*>(gpr_malloc(sizeof(grpc_cv_node)));
pollcv->next = nullptr;
gpr_cv pollcv_cv;
gpr_cv_init(&pollcv_cv);
pollcv->cv = &pollcv_cv;
- grpc_cv_node* fd_cvs = (grpc_cv_node*)gpr_malloc(nfds * sizeof(grpc_cv_node));
+ grpc_cv_node* fd_cvs =
+ static_cast<grpc_cv_node*>(gpr_malloc(nfds * sizeof(grpc_cv_node)));
for (i = 0; i < nfds; i++) {
fds[i].revents = 0;
@@ -1545,8 +1550,8 @@ static int cvfd_poll(struct pollfd* fds, nfds_t nfds, int timeout) {
res = 0;
if (!skip_poll && nsockfds > 0) {
- struct pollfd* pollfds =
- (struct pollfd*)gpr_malloc(sizeof(struct pollfd) * nsockfds);
+ struct pollfd* pollfds = static_cast<struct pollfd*>(
+ gpr_malloc(sizeof(struct pollfd) * nsockfds));
idx = 0;
for (i = 0; i < nfds; i++) {
if (fds[i].fd >= 0) {
@@ -1609,8 +1614,8 @@ static void global_cv_fd_table_init() {
gpr_cv_init(&g_cvfds.shutdown_cv);
gpr_ref_init(&g_cvfds.pollcount, 1);
g_cvfds.size = CV_DEFAULT_TABLE_SIZE;
- g_cvfds.cvfds =
- (grpc_fd_node*)gpr_malloc(sizeof(grpc_fd_node) * CV_DEFAULT_TABLE_SIZE);
+ g_cvfds.cvfds = static_cast<grpc_fd_node*>(
+ gpr_malloc(sizeof(grpc_fd_node) * CV_DEFAULT_TABLE_SIZE));
g_cvfds.free_fds = nullptr;
thread_grace = gpr_time_from_millis(POLLCV_THREAD_GRACE_MS, GPR_TIMESPAN);
for (int i = 0; i < CV_DEFAULT_TABLE_SIZE; i++) {
@@ -1627,7 +1632,8 @@ static void global_cv_fd_table_init() {
poll_cache.size = 32;
poll_cache.count = 0;
poll_cache.free_pollers = nullptr;
- poll_cache.active_pollers = (poll_args**)gpr_malloc(sizeof(void*) * 32);
+ poll_cache.active_pollers =
+ static_cast<poll_args**>(gpr_malloc(sizeof(void*) * 32));
for (unsigned int i = 0; i < poll_cache.size; i++) {
poll_cache.active_pollers[i] = nullptr;
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-05 10:09:14 +0000