int network_register_fdevents(server *srv) {
size_t i;
if (-1 == fdevent_reset(srv->ev)) {
return -1;
}
/* register fdevents after reset */
for (i = 0; i < srv->srv_sockets.used; i++) {
server_socket *srv_socket = srv->srv_sockets.ptr[i];
Cdbg(DBE, "network_register_fdevents..[%d]: fd=[%d]\n", i, srv_socket->fd);
fdevent_register(srv->ev, srv_socket->fd, network_server_handle_fdevent, srv_socket);
fdevent_event_set(srv->ev, &(srv_socket->fde_ndx), srv_socket->fd, FDEVENT_IN);
}
return 0;
}
int network_register_fdevents(server *srv) {
size_t i;
if (-1 == fdevent_reset(srv->ev)) {
return -1;
}
if (srv->sockets_disabled) return 0; /* lighttpd -1 (one-shot mode) */
/* register fdevents after reset */
for (i = 0; i < srv->srv_sockets.used; i++) {
server_socket *srv_socket = srv->srv_sockets.ptr[i];
fdevent_register(srv->ev, srv_socket->fd, network_server_handle_fdevent, srv_socket);
fdevent_event_set(srv->ev, &(srv_socket->fde_ndx), srv_socket->fd, FDEVENT_IN);
}
return 0;
}
//将所有已创建的监听套接字描述符加入i／o复用中
int network_register_fdevents(server *srv) {
size_t i;
//重置i/o模型处理器fdevents结构体
if (-1 == fdevent_reset(srv->ev)) {
return -1;
}
/* register fdevents after reset */
for (i = 0; i < srv->srv_sockets.used; i++) {
server_socket *srv_socket = srv->srv_sockets.ptr[i];
//当此srv_socket->fd就绪时，调用network_server_handle_fdevent函数进行处理
fdevent_register(srv->ev, srv_socket->fd, network_server_handle_fdevent, srv_socket);
fdevent_event_add(srv->ev, &(srv_socket->fde_ndx), srv_socket->fd, FDEVENT_IN);
}
return 0;
}
void SetUp() override {
// We don't need an fdevent loop, but adding/removing listeners must be done from the
// fdevent thread if one exists. Since previously run tests may have created an fdevent
// thread, we need to reset to prevent the thread check.
fdevent_reset();
}
virtual void SetUp() {
fdevent_reset();
ASSERT_EQ(0u, fdevent_installed_count());
}
void BM_Connection_Echo(benchmark::State& state) {
int fds[2];
if (adb_socketpair(fds) != 0) {
LOG(FATAL) << "failed to create socketpair";
}
auto client = MakeConnection<ConnectionType>(unique_fd(fds[0]));
auto server = MakeConnection<ConnectionType>(unique_fd(fds[1]));
std::atomic<size_t> received_bytes;
fdevent_reset();
std::thread fdevent_thread([]() { fdevent_loop(); });
client->SetReadCallback([&received_bytes](Connection*, std::unique_ptr<apacket> packet) -> bool {
received_bytes += packet->payload.size();
return true;
});
static const auto handle_packet = [](Connection* connection, std::unique_ptr<apacket> packet) {
connection->Write(std::move(packet));
};
server->SetReadCallback([](Connection* connection, std::unique_ptr<apacket> packet) -> bool {
if (Policy == ThreadPolicy::MainThread) {
auto raw_packet = packet.release();
fdevent_run_on_main_thread([connection, raw_packet]() {
std::unique_ptr<apacket> packet(raw_packet);
handle_packet(connection, std::move(packet));
});
} else {
handle_packet(connection, std::move(packet));
}
return true;
});
client->SetErrorCallback(
[](Connection*, const std::string& error) { LOG(INFO) << "client closed: " << error; });
server->SetErrorCallback(
[](Connection*, const std::string& error) { LOG(INFO) << "server closed: " << error; });
client->Start();
server->Start();
for (auto _ : state) {
size_t data_size = state.range(0);
std::unique_ptr<apacket> packet = std::make_unique<apacket>();
memset(&packet->msg, 0, sizeof(packet->msg));
packet->msg.command = A_WRTE;
packet->msg.data_length = data_size;
packet->payload.resize(data_size);
memset(&packet->payload[0], 0xff, data_size);
received_bytes = 0;
client->Write(std::move(packet));
while (received_bytes < data_size) {
continue;
}
}
state.SetBytesProcessed(static_cast<int64_t>(state.iterations()) * state.range(0));
client->Stop();
server->Stop();
// TODO: Make it so that you don't need to poke the fdevent loop to make it terminate?
fdevent_terminate_loop();
fdevent_run_on_main_thread([]() {});
fdevent_thread.join();
}