void grpc_fd_shutdown(grpc_fd *fd) { size_t ncb = 0; gpr_mu_lock(&fd->set_state_mu); GPR_ASSERT(!gpr_atm_no_barrier_load(&fd->shutdown)); gpr_atm_rel_store(&fd->shutdown, 1); set_ready_locked(&fd->readst, &fd->shutdown_closures[0], &ncb); set_ready_locked(&fd->writest, &fd->shutdown_closures[0], &ncb); gpr_mu_unlock(&fd->set_state_mu); GPR_ASSERT(ncb <= 2); process_callbacks(fd->shutdown_closures[0], ncb, 0 /* GPR_FALSE */, 0 /* GPR_FALSE */); }
struct bt_ctf_event *bt_ctf_iter_read_event_flags(struct bt_ctf_iter *iter, int *flags) { struct ctf_file_stream *file_stream; struct bt_ctf_event *ret; struct ctf_stream_definition *stream; struct packet_index *packet_index; /* * We do not want to fail for any other reason than end of * trace, hence the assert. */ assert(iter); ret = &iter->current_ctf_event; file_stream = bt_heap_maximum(iter->parent.stream_heap); if (!file_stream) { /* end of file for all streams */ goto stop; } stream = &file_stream->parent; ret->parent = g_ptr_array_index(stream->events_by_id, stream->event_id); if (flags) *flags = 0; if (!file_stream->pos.packet_cycles_index) packet_index = NULL; else packet_index = &g_array_index(file_stream->pos.packet_cycles_index, struct packet_index, file_stream->pos.cur_index); iter->events_lost = 0; if (packet_index && packet_index->events_discarded > file_stream->pos.last_events_discarded) { if (flags) *flags |= BT_ITER_FLAG_LOST_EVENTS; iter->events_lost += packet_index->events_discarded - file_stream->pos.last_events_discarded; file_stream->pos.last_events_discarded = packet_index->events_discarded; } if (ret->parent->stream->stream_id > iter->callbacks->len) goto end; process_callbacks(iter, ret->parent->stream); end: return ret; stop: return NULL; }
/* * Callback routine when the required locks are obtained. * Called from parent context */ static void ctdb_lock_handler(struct tevent_context *ev, struct tevent_fd *tfd, uint16_t flags, void *private_data) { struct lock_context *lock_ctx; char c; bool locked; double t; int id; lock_ctx = talloc_get_type_abort(private_data, struct lock_context); /* cancel the timeout event */ TALLOC_FREE(lock_ctx->ttimer); t = timeval_elapsed(&lock_ctx->start_time); id = lock_bucket_id(t); /* Read the status from the child process */ if (sys_read(lock_ctx->fd[0], &c, 1) != 1) { locked = false; } else { locked = (c == 0 ? true : false); } /* Update statistics */ CTDB_INCREMENT_STAT(lock_ctx->ctdb, locks.num_calls); if (lock_ctx->ctdb_db) { CTDB_INCREMENT_DB_STAT(lock_ctx->ctdb_db, locks.num_calls); } if (locked) { if (lock_ctx->ctdb_db) { CTDB_INCREMENT_STAT(lock_ctx->ctdb, locks.buckets[id]); CTDB_UPDATE_LATENCY(lock_ctx->ctdb, lock_ctx->ctdb_db, lock_type_str[lock_ctx->type], locks.latency, lock_ctx->start_time); CTDB_UPDATE_DB_LATENCY(lock_ctx->ctdb_db, lock_type_str[lock_ctx->type], locks.latency, t); CTDB_INCREMENT_DB_STAT(lock_ctx->ctdb_db, locks.buckets[id]); } } else { CTDB_INCREMENT_STAT(lock_ctx->ctdb, locks.num_failed); if (lock_ctx->ctdb_db) { CTDB_INCREMENT_DB_STAT(lock_ctx->ctdb_db, locks.num_failed); } } process_callbacks(lock_ctx, locked); }
/* * Informs other threads that this thread has passed through a quiescent * state. * If all threads have passed through a quiescent state since the last time * this thread processed it's callbacks, proceed to process pending callbacks. */ void quiescent_state (int blocking) { uint8_t my_index = ltd.thread_index; int epoch; int orig; retry: epoch = qg->global_epoch; if (shtd[my_index].epoch != epoch) { /* New epoch. */ /* Process callbacks for old 'incarnation' of this epoch. */ process_callbacks(ltd.limbo_list[epoch]); shtd[my_index].epoch = epoch; } else { orig = shtd[my_index].in_critical; shtd[my_index].in_critical = 0; int res = update_epoch(); if (res) { shtd[my_index].in_critical = orig; MEM_BARRIER; epoch = qg->global_epoch; if (shtd[my_index].epoch != epoch) { process_callbacks(ltd.limbo_list[epoch]); shtd[my_index].epoch = epoch; } return; } else if (blocking) { shtd[my_index].in_critical = orig; MEM_BARRIER; sched_yield(); goto retry; } shtd[my_index].in_critical = orig; MEM_BARRIER; } return; }
static void set_ready(grpc_fd *fd, gpr_atm *st, int allow_synchronous_callback) { /* only one set_ready can be active at once (but there may be a racing notify_on) */ int success; grpc_iomgr_closure* closure; size_t ncb = 0; gpr_mu_lock(&fd->set_state_mu); set_ready_locked(st, &closure, &ncb); gpr_mu_unlock(&fd->set_state_mu); success = !gpr_atm_acq_load(&fd->shutdown); GPR_ASSERT(ncb <= 1); if (ncb > 0) { process_callbacks(closure, ncb, success, allow_synchronous_callback); } }
void mastermind_t::data::collect_info_loop() { std::unique_lock<std::mutex> lock(m_mutex); if (m_done) { COCAINE_LOG_INFO(m_logger, "libmastermind: have to stop immediately"); return; } try { reconnect(); } catch (const std::exception &ex) { COCAINE_LOG_ERROR(m_logger, "libmastermind: reconnect: %s", ex.what()); } #if __GNUC_MINOR__ >= 6 auto no_timeout = std::cv_status::no_timeout; auto timeout = std::cv_status::timeout; auto tm = timeout; #else bool no_timeout = true; bool timeout = false; bool tm = timeout; #endif COCAINE_LOG_INFO(m_logger, "libmastermind: collect_info_loop: update period is %d", static_cast<int>(m_group_info_update_period)); do { collect_info_loop_impl(); process_callbacks(); tm = timeout; do { tm = m_weight_cache_condition_variable.wait_for(lock, std::chrono::seconds( m_group_info_update_period)); } while(tm == no_timeout && m_done == false); } while(m_done == false); }
struct bt_ctf_event *bt_ctf_iter_read_event_flags(struct bt_ctf_iter *iter, int *flags) { struct ctf_file_stream *file_stream; struct bt_ctf_event *ret; struct ctf_stream_definition *stream; struct packet_index *packet_index; /* * We do not want to fail for any other reason than end of * trace, hence the assert. */ assert(iter); if (flags) *flags = 0; ret = &iter->current_ctf_event; file_stream = bt_heap_maximum(iter->parent.stream_heap); if (!file_stream) { /* end of file for all streams */ goto stop; } /* * If the packet is empty (contains only headers or is of size 0), the * caller has to know that we can't read the current event and we need * to do a bt_iter_next. */ if (file_stream->pos.data_offset == file_stream->pos.content_size || file_stream->pos.content_size == 0) { /* More events may come. */ ret = NULL; if (flags) *flags |= BT_ITER_FLAG_RETRY; goto end; } stream = &file_stream->parent; if (iter->parent.end_pos && iter->parent.end_pos->type == BT_SEEK_TIME && stream->real_timestamp > iter->parent.end_pos->u.seek_time) { goto stop; } ret->parent = g_ptr_array_index(stream->events_by_id, stream->event_id); if (!file_stream->pos.packet_index) packet_index = NULL; else packet_index = &g_array_index(file_stream->pos.packet_index, struct packet_index, file_stream->pos.cur_index); iter->events_lost = 0; if (packet_index && packet_index->events_discarded > file_stream->pos.last_events_discarded) { if (flags) *flags |= BT_ITER_FLAG_LOST_EVENTS; iter->events_lost += packet_index->events_discarded - file_stream->pos.last_events_discarded; file_stream->pos.last_events_discarded = packet_index->events_discarded; } if (ret->parent->stream->stream_id > iter->callbacks->len) goto end; process_callbacks(iter, ret->parent->stream); end: return ret; stop: return NULL; }
void mastermind_t::data::cache_force_update() { std::lock_guard<std::mutex> lock(m_mutex); (void) lock; collect_info_loop_impl(); process_callbacks(); }