Fix up review comments

pull/13559/head
Dave MacLachlan 7 years ago
parent 8a631a2b05
commit da341bcb89
  1. 2
      src/core/lib/iomgr/ev_poll_posix.cc
  2. 2
      src/core/lib/iomgr/executor.cc
  3. 2
      src/core/lib/iomgr/timer_manager.cc
  4. 11
      src/core/lib/support/thd_posix.cc
  5. 2
      test/core/bad_client/bad_client.cc
  6. 2
      test/core/end2end/bad_server_response_test.cc
  7. 2
      test/core/end2end/fixtures/http_proxy_fixture.cc
  8. 2
      test/core/end2end/fixtures/proxy.cc
  9. 2
      test/core/end2end/tests/connectivity.cc
  10. 2
      test/core/handshake/client_ssl.cc
  11. 2
      test/core/handshake/server_ssl_common.cc
  12. 2
      test/core/iomgr/combiner_test.cc
  13. 2
      test/core/iomgr/resolve_address_posix_test.cc
  14. 10
      test/core/iomgr/wakeup_fd_cv_test.cc
  15. 2
      test/core/support/arena_test.cc
  16. 3
      test/core/support/cpu_test.cc
  17. 8
      test/core/support/mpscq_test.cc
  18. 2
      test/core/support/spinlock_test.cc
  19. 2
      test/core/support/sync_test.cc
  20. 4
      test/core/support/thd_test.cc
  21. 2
      test/core/support/tls_test.cc
  22. 5
      test/core/surface/completion_queue_threading_test.cc
  23. 12
      test/core/surface/concurrent_connectivity_test.cc
  24. 3
      test/core/surface/sequential_connectivity_test.cc

@ -1382,7 +1382,7 @@ static poll_args* get_poller_locked(struct pollfd* fds, nfds_t count) {
gpr_thd_options opt = gpr_thd_options_default();
gpr_ref(&g_cvfds.pollcount);
gpr_thd_options_set_detached(&opt);
GPR_ASSERT(gpr_thd_new(&t_id, "gpr_poller", &run_poll, pargs, &opt));
GPR_ASSERT(gpr_thd_new(&t_id, "grpc_poller", &run_poll, pargs, &opt));
return pargs;
}

@ -104,7 +104,7 @@ void grpc_executor_set_threading(grpc_exec_ctx* exec_ctx, bool threading) {
gpr_thd_options opt = gpr_thd_options_default();
gpr_thd_options_set_joinable(&opt);
gpr_thd_new(&g_thread_state[0].id, "gpr_executor", executor_thread,
gpr_thd_new(&g_thread_state[0].id, "grpc_executor", executor_thread,
&g_thread_state[0], &opt);
} else {
if (cur_threads == 0) return;

@ -93,7 +93,7 @@ static void start_timer_thread_and_unlock(void) {
// to leak through g_completed_threads and be freed in gc_completed_threads()
// before "&ct->t" is written to, causing a use-after-free.
gpr_mu_lock(&g_mu);
gpr_thd_new(&ct->t, "gpr_timer", timer_thread, ct, &opt);
gpr_thd_new(&ct->t, "grpc_global_timer", timer_thread, ct, &opt);
gpr_mu_unlock(&g_mu);
}

@ -33,22 +33,23 @@
struct thd_arg {
void (*body)(void* arg); /* body of a thread */
void* arg; /* argument to a thread */
const char* name; /* name of thread */
const char* name; /* name of thread. Can be nullptr. */
};
/* Body of every thread started via gpr_thd_new. */
static void* thread_body(void* v) {
struct thd_arg a = *(struct thd_arg*)v;
free(v);
if (a.name != NULL) {
if (a.name != nullptr) {
#if GPR_APPLE_PTHREAD_NAME
/* Apple supports 64 characters, and will truncate if it's longer. */
pthread_setname_np(a.name);
#elif GPR_LINUX_PTHREAD_NAME
/* Linux supports 16 characters max, and will error if it's longer. */
char buf[16];
strncpy(buf, a.name, sizeof(buf) - 1);
buf[sizeof(buf) - 1] = '\0';
size_t buf_len = GPR_ARRAY_SIZE(buf) - 1;
strncpy(buf, a.name, buf_len);
buf[buf_len] = '\0';
pthread_setname_np(pthread_self(), buf);
#endif // GPR_APPLE_PTHREAD_NAME
}
@ -69,7 +70,7 @@ int gpr_thd_new(gpr_thd_id* t, const char* thd_name,
a->body = thd_body;
a->arg = arg;
a->name = thd_name;
GPR_ASSERT(pthread_attr_init(&attr) == 0);
if (gpr_thd_options_is_detached(options)) {
GPR_ASSERT(pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) ==

@ -128,7 +128,7 @@ void grpc_run_bad_client_test(
GPR_ASSERT(grpc_server_has_open_connections(a.server));
/* Start validator */
gpr_thd_new(&id, "gpr_bad_client", thd_func, &a, nullptr);
gpr_thd_new(&id, "grpc_bad_client", thd_func, &a, nullptr);
grpc_slice_buffer_init(&outgoing);
grpc_slice_buffer_add(&outgoing, slice);

@ -262,7 +262,7 @@ static void poll_server_until_read_done(test_tcp_server* server,
poll_args* pa = (poll_args*)gpr_malloc(sizeof(*pa));
pa->server = server;
pa->signal_when_done = signal_when_done;
gpr_thd_new(&id, "gpr_poll_server", actually_poll_server, pa, nullptr);
gpr_thd_new(&id, "grpc_poll_server", actually_poll_server, pa, nullptr);
}
static void run_test(const char* response_payload,

@ -529,7 +529,7 @@ grpc_end2end_http_proxy* grpc_end2end_http_proxy_create(
// Start proxy thread.
gpr_thd_options opt = gpr_thd_options_default();
gpr_thd_options_set_joinable(&opt);
GPR_ASSERT(gpr_thd_new(&proxy->thd, "gpr_http_proxy", thread_main, proxy,
GPR_ASSERT(gpr_thd_new(&proxy->thd, "grpc_http_proxy", thread_main, proxy,
&opt));
return proxy;
}

@ -98,7 +98,7 @@ grpc_end2end_proxy* grpc_end2end_proxy_create(const grpc_end2end_proxy_def* def,
grpc_call_details_init(&proxy->new_call_details);
gpr_thd_options_set_joinable(&opt);
GPR_ASSERT(gpr_thd_new(&proxy->thd, "gpr_end2end_proxy", thread_main, proxy,
GPR_ASSERT(gpr_thd_new(&proxy->thd, "grpc_end2end_proxy", thread_main, proxy,
&opt));
request_call(proxy);

@ -68,7 +68,7 @@ static void test_connectivity(grpc_end2end_test_config config) {
ce.cq = f.cq;
gpr_event_init(&ce.started);
gpr_thd_options_set_joinable(&thdopt);
GPR_ASSERT(gpr_thd_new(&thdid, "gpr_connectivity", child_thread, &ce,
GPR_ASSERT(gpr_thd_new(&thdid, "grpc_connectivity", child_thread, &ce,
&thdopt));
gpr_event_wait(&ce.started, gpr_inf_future(GPR_CLOCK_MONOTONIC));

@ -231,7 +231,7 @@ static bool client_ssl_test(char* server_alpn_preferred) {
gpr_thd_id thdid;
gpr_thd_options_set_joinable(&thdopt);
server_args args = {server_socket, server_alpn_preferred};
GPR_ASSERT(gpr_thd_new(&thdid, "gpr_client_ssl_test", server_thread, &args,
GPR_ASSERT(gpr_thd_new(&thdid, "grpc_client_ssl_test", server_thread, &args,
&thdopt));
// Load key pair and establish client SSL credentials.

@ -137,7 +137,7 @@ bool server_ssl_test(const char* alpn_list[], unsigned int alpn_list_len,
gpr_thd_options thdopt = gpr_thd_options_default();
gpr_thd_id thdid;
gpr_thd_options_set_joinable(&thdopt);
GPR_ASSERT(gpr_thd_new(&thdid, "gpr_ssl_test", server_thread, &port,
GPR_ASSERT(gpr_thd_new(&thdid, "grpc_ssl_test", server_thread, &port,
&thdopt));
SSL_load_error_strings();

@ -112,7 +112,7 @@ static void test_execute_many(void) {
ta[i].ctr = 0;
ta[i].lock = lock;
gpr_event_init(&ta[i].done);
GPR_ASSERT(gpr_thd_new(&thds[i], "gpr_execute_many", execute_many_loop,
GPR_ASSERT(gpr_thd_new(&thds[i], "grpc_execute_many", execute_many_loop,
&ta[i], &options));
}
for (size_t i = 0; i < GPR_ARRAY_SIZE(thds); i++) {

@ -104,7 +104,7 @@ static void actually_poll(void* argsp) {
static void poll_pollset_until_request_done(args_struct* args) {
gpr_atm_rel_store(&args->done_atm, 0);
gpr_thd_id id;
gpr_thd_new(&id, "gpr_poll_pollset", actually_poll, args, nullptr);
gpr_thd_new(&id, "grpc_poll_pollset", actually_poll, args, nullptr);
}
static void must_succeed(grpc_exec_ctx* exec_ctx, void* argsp,

@ -138,7 +138,7 @@ void test_poll_cv_trigger(void) {
opt = gpr_thd_options_default();
gpr_thd_options_set_joinable(&opt);
gpr_thd_new(&t_id, "gpr_background_poll", &background_poll, &pargs, &opt);
gpr_thd_new(&t_id, "grpc_background_poll", &background_poll, &pargs, &opt);
// Wakeup wakeup_fd not listening for events
GPR_ASSERT(grpc_wakeup_fd_wakeup(&cvfd1) == GRPC_ERROR_NONE);
@ -154,7 +154,7 @@ void test_poll_cv_trigger(void) {
// Pollin on socket fd
pargs.timeout = -1;
pargs.result = -2;
gpr_thd_new(&t_id, "gpr_background_poll", &background_poll, &pargs, &opt);
gpr_thd_new(&t_id, "grpc_background_poll", &background_poll, &pargs, &opt);
trigger_socket_event();
gpr_thd_join(t_id);
GPR_ASSERT(pargs.result == 1);
@ -168,7 +168,7 @@ void test_poll_cv_trigger(void) {
// Pollin on wakeup fd
reset_socket_event();
pargs.result = -2;
gpr_thd_new(&t_id, "gpr_background_poll", &background_poll, &pargs, &opt);
gpr_thd_new(&t_id, "grpc_background_poll", &background_poll, &pargs, &opt);
GPR_ASSERT(grpc_wakeup_fd_wakeup(&cvfd2) == GRPC_ERROR_NONE);
gpr_thd_join(t_id);
@ -182,7 +182,7 @@ void test_poll_cv_trigger(void) {
// Pollin on wakeupfd before poll()
pargs.result = -2;
gpr_thd_new(&t_id, "gpr_background_poll", &background_poll, &pargs, &opt);
gpr_thd_new(&t_id, "grpc_background_poll", &background_poll, &pargs, &opt);
gpr_thd_join(t_id);
GPR_ASSERT(pargs.result == 1);
@ -199,7 +199,7 @@ void test_poll_cv_trigger(void) {
reset_socket_event();
GPR_ASSERT(grpc_wakeup_fd_consume_wakeup(&cvfd1) == GRPC_ERROR_NONE);
GPR_ASSERT(grpc_wakeup_fd_consume_wakeup(&cvfd2) == GRPC_ERROR_NONE);
gpr_thd_new(&t_id, "gpr_background_poll", &background_poll, &pargs, &opt);
gpr_thd_new(&t_id, "grpc_background_poll", &background_poll, &pargs, &opt);
gpr_thd_join(t_id);
GPR_ASSERT(pargs.result == 0);

@ -100,7 +100,7 @@ static void concurrent_test(void) {
for (int i = 0; i < CONCURRENT_TEST_THREADS; i++) {
gpr_thd_options opt = gpr_thd_options_default();
gpr_thd_options_set_joinable(&opt);
gpr_thd_new(&thds[i], "gpr_concurrent_test", concurrent_test_body, &args,
gpr_thd_new(&thds[i], "grpc_concurrent_test", concurrent_test_body, &args,
&opt);
}

@ -110,7 +110,8 @@ static void cpu_test(void) {
gpr_cv_init(&ct.done_cv);
ct.is_done = 0;
for (i = 0; i < ct.ncores * 3; i++) {
GPR_ASSERT(gpr_thd_new(&thd, "gpr_cpu_test", &worker_thread, &ct, nullptr));
GPR_ASSERT(gpr_thd_new(&thd, "grpc_cpu_test", &worker_thread, &ct,
nullptr));
}
gpr_mu_lock(&ct.mu);
while (!ct.is_done) {

@ -85,7 +85,7 @@ static void test_mt(void) {
ta[i].ctr = 0;
ta[i].q = &q;
ta[i].start = &start;
GPR_ASSERT(gpr_thd_new(&thds[i], "gpr_test_md", test_thread, &ta[i],
GPR_ASSERT(gpr_thd_new(&thds[i], "grpc_mt_test", test_thread, &ta[i],
&options));
}
size_t num_done = 0;
@ -157,7 +157,7 @@ static void test_mt_multipop(void) {
ta[i].ctr = 0;
ta[i].q = &q;
ta[i].start = &start;
GPR_ASSERT(gpr_thd_new(&thds[i], "gpr_multipop_test", test_thread, &ta[i],
GPR_ASSERT(gpr_thd_new(&thds[i], "grpc_multipop_test", test_thread, &ta[i],
&options));
}
pull_args pa;
@ -171,8 +171,8 @@ static void test_mt_multipop(void) {
for (size_t i = 0; i < GPR_ARRAY_SIZE(pull_thds); i++) {
gpr_thd_options options = gpr_thd_options_default();
gpr_thd_options_set_joinable(&options);
GPR_ASSERT(gpr_thd_new(&pull_thds[i], "gpr_multipop_pull", pull_thread, &pa,
&options));
GPR_ASSERT(gpr_thd_new(&pull_thds[i], "grpc_multipop_pull", pull_thread,
&pa, &options));
}
gpr_event_set(&start, (void*)1);
for (size_t i = 0; i < GPR_ARRAY_SIZE(pull_thds); i++) {

@ -67,7 +67,7 @@ static void test_create_threads(struct test* m, void (*body)(void* arg)) {
for (i = 0; i != m->thread_count; i++) {
gpr_thd_options opt = gpr_thd_options_default();
gpr_thd_options_set_joinable(&opt);
GPR_ASSERT(gpr_thd_new(&m->threads[i], "gpr_create_threads", body, m,
GPR_ASSERT(gpr_thd_new(&m->threads[i], "grpc_create_threads", body, m,
&opt));
}
}

@ -189,7 +189,7 @@ static void test_create_threads(struct test* m, void (*body)(void* arg)) {
gpr_thd_id id;
int i;
for (i = 0; i != m->threads; i++) {
GPR_ASSERT(gpr_thd_new(&id, "gpr_create_threads", body, m, nullptr));
GPR_ASSERT(gpr_thd_new(&id, "grpc_create_threads", body, m, nullptr));
}
}

@ -74,7 +74,7 @@ static void test(void) {
t.n = NUM_THREADS;
t.is_done = 0;
for (i = 0; i < NUM_THREADS; i++) {
GPR_ASSERT(gpr_thd_new(&thd, "gpr_thread_test", &thd_body, &t, nullptr));
GPR_ASSERT(gpr_thd_new(&thd, "grpc_thread_test", &thd_body, &t, nullptr));
}
gpr_mu_lock(&t.mu);
while (!t.is_done) {
@ -84,7 +84,7 @@ static void test(void) {
GPR_ASSERT(t.n == 0);
gpr_thd_options_set_joinable(&options);
for (i = 0; i < NUM_THREADS; i++) {
GPR_ASSERT(gpr_thd_new(&thds[i], "gpr_thread_test_joinable",
GPR_ASSERT(gpr_thd_new(&thds[i], "grpc_joinable_thread_test",
&thd_body_joinable, nullptr, &options));
}
for (i = 0; i < NUM_THREADS; i++) {

@ -56,7 +56,7 @@ int main(int argc, char* argv[]) {
gpr_thd_options_set_joinable(&opt);
for (i = 0; i < NUM_THREADS; i++) {
gpr_thd_new(&threads[i], "gpr_tls_test", thd_body, nullptr, &opt);
gpr_thd_new(&threads[i], "grpc_tls_test", thd_body, nullptr, &opt);
}
for (i = 0; i < NUM_THREADS; i++) {
gpr_thd_join(threads[i]);

@ -96,7 +96,7 @@ static void test_too_many_plucks(void) {
}
thread_states[i].cc = cc;
thread_states[i].tag = tags[i];
gpr_thd_new(thread_ids + i, "gpr_test_pluck", pluck_one, thread_states + i,
gpr_thd_new(thread_ids + i, "grpc_pluck_test", pluck_one, thread_states + i,
&thread_options);
}
@ -234,7 +234,8 @@ static void test_threading(size_t producers, size_t consumers) {
options[i].events_triggered = 0;
options[i].cc = cc;
options[i].id = optid++;
GPR_ASSERT(gpr_thd_new(&id, i < producers ? "gpr_producer" : "gpr_consumer",
GPR_ASSERT(gpr_thd_new(&id,
i < producers ? "grpc_producer" : "grpc_consumer",
i < producers ? producer_thread : consumer_thread,
options + i, nullptr));
gpr_event_wait(&options[i].on_started, ten_seconds_time());

@ -180,7 +180,7 @@ int run_concurrent_connectivity_test() {
/* First round, no server */
gpr_log(GPR_DEBUG, "Wave 1");
for (size_t i = 0; i < NUM_THREADS; ++i) {
gpr_thd_new(&threads[i], "gpr_wave_1", create_loop_destroy, localhost,
gpr_thd_new(&threads[i], "grpc_wave_1", create_loop_destroy, localhost,
&options);
}
for (size_t i = 0; i < NUM_THREADS; ++i) {
@ -197,10 +197,10 @@ int run_concurrent_connectivity_test() {
args.cq = grpc_completion_queue_create_for_next(nullptr);
grpc_server_register_completion_queue(args.server, args.cq, nullptr);
grpc_server_start(args.server);
gpr_thd_new(&server, "gpr_wave_2_server", server_thread, &args, &options);
gpr_thd_new(&server, "grpc_wave_2_server", server_thread, &args, &options);
for (size_t i = 0; i < NUM_THREADS; ++i) {
gpr_thd_new(&threads[i], "gpr_wave_2", create_loop_destroy, args.addr,
gpr_thd_new(&threads[i], "grpc_wave_2", create_loop_destroy, args.addr,
&options);
}
for (size_t i = 0; i < NUM_THREADS; ++i) {
@ -218,11 +218,11 @@ int run_concurrent_connectivity_test() {
args.pollset = static_cast<grpc_pollset*>(gpr_zalloc(grpc_pollset_size()));
grpc_pollset_init(args.pollset, &args.mu);
gpr_event_init(&args.ready);
gpr_thd_new(&server, "gpr_wave_3_server", bad_server_thread, &args, &options);
gpr_thd_new(&server, "grpc_wave_3_server", bad_server_thread, &args, &options);
gpr_event_wait(&args.ready, gpr_inf_future(GPR_CLOCK_MONOTONIC));
for (size_t i = 0; i < NUM_THREADS; ++i) {
gpr_thd_new(&threads[i], "gpr_wave_3", create_loop_destroy, args.addr,
gpr_thd_new(&threads[i], "grpc_wave_3", create_loop_destroy, args.addr,
&options);
}
for (size_t i = 0; i < NUM_THREADS; ++i) {
@ -281,7 +281,7 @@ int run_concurrent_watches_with_short_timeouts_test() {
gpr_thd_options_set_joinable(&options);
for (size_t i = 0; i < NUM_THREADS; ++i) {
gpr_thd_new(&threads[i], "gpr_watches_with_short_timeouts",
gpr_thd_new(&threads[i], "grpc_short_watches",
watches_with_short_timeouts, localhost, &options);
}
for (size_t i = 0; i < NUM_THREADS; ++i) {

@ -70,8 +70,7 @@ static void run_test(const test_fixture* fixture) {
gpr_thd_id server_thread;
gpr_thd_options thdopt = gpr_thd_options_default();
gpr_thd_options_set_joinable(&thdopt);
gpr_thd_new(&server_thread, "gpr_server_thread", server_thread_func, &sta,
&thdopt);
gpr_thd_new(&server_thread, "grpc_server", server_thread_func, &sta, &thdopt);
grpc_completion_queue* cq = grpc_completion_queue_create_for_next(nullptr);
grpc_channel* channels[NUM_CONNECTIONS];

Loading…
Cancel
Save