mirror of https://github.com/grpc/grpc.git
The C based gRPC (C++, Python, Ruby, Objective-C, PHP, C#)
https://grpc.io/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
306 lines
12 KiB
306 lines
12 KiB
// |
|
// |
|
// Copyright 2017 gRPC authors. |
|
// |
|
// Licensed under the Apache License, Version 2.0 (the "License"); |
|
// you may not use this file except in compliance with the License. |
|
// You may obtain a copy of the License at |
|
// |
|
// http://www.apache.org/licenses/LICENSE-2.0 |
|
// |
|
// Unless required by applicable law or agreed to in writing, software |
|
// distributed under the License is distributed on an "AS IS" BASIS, |
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|
// See the License for the specific language governing permissions and |
|
// limitations under the License. |
|
// |
|
// |
|
|
|
#include <chrono> |
|
|
|
#include <gtest/gtest.h> |
|
|
|
#include "absl/log/check.h" |
|
|
|
#include <grpc/support/log.h> |
|
#include <grpcpp/channel.h> |
|
#include <grpcpp/create_channel.h> |
|
#include <grpcpp/impl/grpc_library.h> |
|
#include <grpcpp/security/credentials.h> |
|
#include <grpcpp/security/server_credentials.h> |
|
#include <grpcpp/server.h> |
|
#include <grpcpp/server_builder.h> |
|
|
|
#include "src/core/ext/transport/chttp2/transport/chttp2_transport.h" |
|
#include "src/core/lib/channel/channel_args.h" |
|
#include "src/core/lib/config/core_configuration.h" |
|
#include "src/core/lib/debug/stats.h" |
|
#include "src/core/lib/event_engine/channel_args_endpoint_config.h" |
|
#include "src/core/lib/event_engine/default_event_engine.h" |
|
#include "src/core/lib/event_engine/tcp_socket_utils.h" |
|
#include "src/core/lib/gprpp/notification.h" |
|
#include "src/core/lib/iomgr/endpoint.h" |
|
#include "src/core/lib/iomgr/event_engine_shims/endpoint.h" |
|
#include "src/core/lib/iomgr/exec_ctx.h" |
|
#include "src/core/lib/surface/channel.h" |
|
#include "src/core/lib/surface/channel_create.h" |
|
#include "src/core/server/server.h" |
|
#include "src/cpp/client/create_channel_internal.h" |
|
#include "src/proto/grpc/testing/echo.grpc.pb.h" |
|
#include "test/core/event_engine/fuzzing_event_engine/fuzzing_event_engine.h" |
|
#include "test/core/test_util/port.h" |
|
#include "test/core/test_util/test_config.h" |
|
|
|
namespace grpc { |
|
namespace testing { |
|
|
|
namespace { |
|
using grpc_event_engine::experimental::EventEngine; |
|
using grpc_event_engine::experimental::ThreadedFuzzingEventEngine; |
|
using grpc_event_engine::experimental::URIToResolvedAddress; |
|
|
|
void* tag(intptr_t x) { return reinterpret_cast<void*>(x); } |
|
|
|
constexpr int kIterations = 1000; |
|
constexpr int kSnapshotEvery = kIterations / 10; |
|
} // namespace |
|
|
|
class InProcessCHTTP2 { |
|
public: |
|
InProcessCHTTP2(Service* service, std::string& addr, |
|
ThreadedFuzzingEventEngine* fuzzing_engine) { |
|
// TODO(hork): move to a endpoint pair helper |
|
// Creating the listener |
|
grpc_core::Notification listener_started; |
|
std::unique_ptr<EventEngine::Endpoint> listener_endpoint; |
|
grpc_core::ChannelArgs args; |
|
grpc_event_engine::experimental::ChannelArgsEndpointConfig config(args); |
|
auto listener = fuzzing_engine->CreateListener( |
|
[&](std::unique_ptr<EventEngine::Endpoint> ep, |
|
grpc_core::MemoryAllocator) { |
|
listener_endpoint = std::move(ep); |
|
listener_started.Notify(); |
|
}, |
|
[](absl::Status status) { CHECK(status.ok()); }, config, |
|
std::make_unique<grpc_core::MemoryQuota>("foo")); |
|
if (!listener.ok()) { |
|
grpc_core::Crash(absl::StrCat("failed to start listener: ", |
|
listener.status().ToString())); |
|
} |
|
auto target_addr = URIToResolvedAddress(addr); |
|
CHECK(target_addr.ok()); |
|
CHECK((*listener)->Bind(*target_addr).ok()); |
|
CHECK((*listener)->Start().ok()); |
|
// Creating the client |
|
std::unique_ptr<EventEngine::Endpoint> client_endpoint; |
|
grpc_core::Notification client_connected; |
|
auto client_memory_quota = |
|
std::make_unique<grpc_core::MemoryQuota>("client"); |
|
std::ignore = fuzzing_engine->Connect( |
|
[&](absl::StatusOr<std::unique_ptr<EventEngine::Endpoint>> endpoint) { |
|
CHECK(endpoint.ok()); |
|
client_endpoint = std::move(*endpoint); |
|
client_connected.Notify(); |
|
}, |
|
*target_addr, config, |
|
client_memory_quota->CreateMemoryAllocator("conn-1"), |
|
grpc_core::Duration::Infinity()); |
|
client_connected.WaitForNotification(); |
|
listener_started.WaitForNotification(); |
|
ServerBuilder b; |
|
cq_ = b.AddCompletionQueue(true); |
|
b.RegisterService(service); |
|
b.SetMaxReceiveMessageSize(INT_MAX); |
|
b.SetMaxSendMessageSize(INT_MAX); |
|
server_ = b.BuildAndStart(); |
|
grpc_core::ExecCtx exec_ctx; |
|
// add server endpoint to server_ |
|
{ |
|
grpc_core::Server* core_server = |
|
grpc_core::Server::FromC(server_->c_server()); |
|
grpc_endpoint* iomgr_server_endpoint = |
|
grpc_event_engine_endpoint_create(std::move(listener_endpoint)); |
|
grpc_core::Transport* transport = grpc_create_chttp2_transport( |
|
core_server->channel_args(), iomgr_server_endpoint, |
|
/*is_client=*/false); |
|
for (grpc_pollset* pollset : core_server->pollsets()) { |
|
grpc_endpoint_add_to_pollset(iomgr_server_endpoint, pollset); |
|
} |
|
CHECK(GRPC_LOG_IF_ERROR( |
|
"SetupTransport", |
|
core_server->SetupTransport(transport, nullptr, |
|
core_server->channel_args(), nullptr))); |
|
grpc_chttp2_transport_start_reading(transport, nullptr, nullptr, nullptr); |
|
} |
|
// create channel |
|
{ |
|
grpc_core::ChannelArgs args = |
|
grpc_core::CoreConfiguration::Get() |
|
.channel_args_preconditioning() |
|
.PreconditionChannelArgs(nullptr) |
|
.Set(GRPC_ARG_DEFAULT_AUTHORITY, "test.authority"); |
|
args = args.Set(GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH, INT_MAX) |
|
.Set(GRPC_ARG_MAX_SEND_MESSAGE_LENGTH, INT_MAX) |
|
.Set(GRPC_ARG_HTTP2_BDP_PROBE, 0); |
|
grpc_core::Transport* transport = grpc_create_chttp2_transport( |
|
args, grpc_event_engine_endpoint_create(std::move(client_endpoint)), |
|
/*is_client=*/true); |
|
CHECK(transport); |
|
grpc_channel* channel = |
|
grpc_core::ChannelCreate("target", args, GRPC_CLIENT_DIRECT_CHANNEL, |
|
transport) |
|
->release() |
|
->c_ptr(); |
|
grpc_chttp2_transport_start_reading(transport, nullptr, nullptr, nullptr); |
|
channel_ = grpc::CreateChannelInternal( |
|
"", channel, |
|
std::vector<std::unique_ptr< |
|
experimental::ClientInterceptorFactoryInterface>>()); |
|
} |
|
} |
|
|
|
virtual ~InProcessCHTTP2() { |
|
server_->Shutdown(); |
|
cq_->Shutdown(); |
|
void* tag; |
|
bool ok; |
|
while (cq_->Next(&tag, &ok)) { |
|
} |
|
} |
|
|
|
ServerCompletionQueue* cq() { return cq_.get(); } |
|
std::shared_ptr<Channel> channel() { return channel_; } |
|
|
|
private: |
|
std::unique_ptr<Server> server_; |
|
std::unique_ptr<ServerCompletionQueue> cq_; |
|
std::shared_ptr<Channel> channel_; |
|
}; |
|
|
|
static double UnaryPingPong(ThreadedFuzzingEventEngine* fuzzing_engine, |
|
int request_size, int response_size) { |
|
EchoTestService::AsyncService service; |
|
std::string target_addr = absl::StrCat( |
|
"ipv6:[::1]:", std::to_string(grpc_pick_unused_port_or_die())); |
|
std::unique_ptr<InProcessCHTTP2> fixture( |
|
new InProcessCHTTP2(&service, target_addr, fuzzing_engine)); |
|
EchoRequest send_request; |
|
EchoResponse send_response; |
|
EchoResponse recv_response; |
|
if (request_size > 0) { |
|
send_request.set_message(std::string(request_size, 'a')); |
|
} |
|
if (response_size > 0) { |
|
send_response.set_message(std::string(response_size, 'a')); |
|
} |
|
Status recv_status; |
|
struct ServerEnv { |
|
ServerContext ctx; |
|
EchoRequest recv_request; |
|
grpc::ServerAsyncResponseWriter<EchoResponse> response_writer; |
|
ServerEnv() : response_writer(&ctx) {} |
|
}; |
|
uint8_t server_env_buffer[2 * sizeof(ServerEnv)]; |
|
ServerEnv* server_env[2] = { |
|
reinterpret_cast<ServerEnv*>(server_env_buffer), |
|
reinterpret_cast<ServerEnv*>(server_env_buffer + sizeof(ServerEnv))}; |
|
new (server_env[0]) ServerEnv; |
|
new (server_env[1]) ServerEnv; |
|
service.RequestEcho(&server_env[0]->ctx, &server_env[0]->recv_request, |
|
&server_env[0]->response_writer, fixture->cq(), |
|
fixture->cq(), tag(0)); |
|
service.RequestEcho(&server_env[1]->ctx, &server_env[1]->recv_request, |
|
&server_env[1]->response_writer, fixture->cq(), |
|
fixture->cq(), tag(1)); |
|
std::unique_ptr<EchoTestService::Stub> stub( |
|
EchoTestService::NewStub(fixture->channel())); |
|
auto baseline = grpc_core::global_stats().Collect(); |
|
auto snapshot = grpc_core::global_stats().Collect(); |
|
auto last_snapshot = absl::Now(); |
|
for (int iteration = 0; iteration < kIterations; iteration++) { |
|
if (iteration > 0 && iteration % kSnapshotEvery == 0) { |
|
auto new_snapshot = grpc_core::global_stats().Collect(); |
|
auto diff = new_snapshot->Diff(*snapshot); |
|
auto now = absl::Now(); |
|
LOG(ERROR) << " SNAPSHOT: UnaryPingPong(" << request_size << ", " |
|
<< response_size << "): writes_per_iteration=" |
|
<< static_cast<double>(diff->syscall_write) / |
|
static_cast<double>(kSnapshotEvery) |
|
<< " (total=" << diff->syscall_write << ", i=" << iteration |
|
<< ") pings=" << diff->http2_pings_sent |
|
<< "; duration=" << now - last_snapshot; |
|
last_snapshot = now; |
|
snapshot = std::move(new_snapshot); |
|
} |
|
recv_response.Clear(); |
|
ClientContext cli_ctx; |
|
std::unique_ptr<ClientAsyncResponseReader<EchoResponse>> response_reader( |
|
stub->AsyncEcho(&cli_ctx, send_request, fixture->cq())); |
|
void* t; |
|
bool ok; |
|
response_reader->Finish(&recv_response, &recv_status, tag(4)); |
|
CHECK(fixture->cq()->Next(&t, &ok)); |
|
CHECK(ok); |
|
CHECK(t == tag(0) || t == tag(1)) << "Found unexpected tag " << t; |
|
intptr_t slot = reinterpret_cast<intptr_t>(t); |
|
ServerEnv* senv = server_env[slot]; |
|
senv->response_writer.Finish(send_response, Status::OK, tag(3)); |
|
for (int i = (1 << 3) | (1 << 4); i != 0;) { |
|
CHECK(fixture->cq()->Next(&t, &ok)); |
|
CHECK(ok); |
|
int tagnum = static_cast<int>(reinterpret_cast<intptr_t>(t)); |
|
CHECK(i & (1 << tagnum)); |
|
i -= 1 << tagnum; |
|
} |
|
CHECK(recv_status.ok()); |
|
|
|
senv->~ServerEnv(); |
|
senv = new (senv) ServerEnv(); |
|
service.RequestEcho(&senv->ctx, &senv->recv_request, &senv->response_writer, |
|
fixture->cq(), fixture->cq(), tag(slot)); |
|
} |
|
auto end_stats = grpc_core::global_stats().Collect()->Diff(*baseline); |
|
double writes_per_iteration = |
|
end_stats->syscall_write / static_cast<double>(kIterations); |
|
gpr_log(GPR_DEBUG, |
|
"UnaryPingPong(%d, %d): writes_per_iteration=%0.3f (total=%lu)", |
|
request_size, response_size, writes_per_iteration, |
|
end_stats->syscall_write); |
|
|
|
fixture.reset(); |
|
server_env[0]->~ServerEnv(); |
|
server_env[1]->~ServerEnv(); |
|
|
|
return writes_per_iteration; |
|
} |
|
|
|
TEST(WritesPerRpcTest, UnaryPingPong) { |
|
auto fuzzing_engine = std::dynamic_pointer_cast< |
|
grpc_event_engine::experimental::ThreadedFuzzingEventEngine>( |
|
grpc_event_engine::experimental::GetDefaultEventEngine()); |
|
EXPECT_LT(UnaryPingPong(fuzzing_engine.get(), 0, 0), 2.2); |
|
EXPECT_LT(UnaryPingPong(fuzzing_engine.get(), 1, 0), 2.2); |
|
EXPECT_LT(UnaryPingPong(fuzzing_engine.get(), 0, 1), 2.2); |
|
EXPECT_LT(UnaryPingPong(fuzzing_engine.get(), 4096, 0), 2.5); |
|
EXPECT_LT(UnaryPingPong(fuzzing_engine.get(), 0, 4096), 2.5); |
|
} |
|
|
|
} // namespace testing |
|
} // namespace grpc |
|
|
|
int main(int argc, char** argv) { |
|
grpc_event_engine::experimental::SetEventEngineFactory( |
|
[]() -> std::unique_ptr<grpc_event_engine::experimental::EventEngine> { |
|
return std::make_unique< |
|
grpc_event_engine::experimental::ThreadedFuzzingEventEngine>( |
|
std::chrono::milliseconds(1)); |
|
}); |
|
// avoids a race around gpr_now_impl |
|
auto engine = grpc_event_engine::experimental::GetDefaultEventEngine(); |
|
::testing::InitGoogleTest(&argc, argv); |
|
grpc::testing::TestEnvironment env(&argc, argv); |
|
grpc_init(); |
|
int ret = RUN_ALL_TESTS(); |
|
grpc_shutdown(); |
|
return ret; |
|
}
|
|
|