SET(TARGET_RPC_PORT "rpc-port")
SET(TARGET_RPC_PORT_UNITTESTS "rpc-port_unittests")
SET(TARGET_RPC_PORT_UTIL "rpc-port-util")
-SET(TARGET_BENCHMARK_SERVER "rpc-port-benchmark-server")
+SET(TARGET_BENCHMARK_SERVER_TIDL "rpc-port-benchmark-server-tidl")
SET(TARGET_BENCHMARK_SERVER_DBUS "rpc-port-benchmark-server-dbus")
+SET(TARGET_BENCHMARK_SERVER_GRPC "rpc-port-benchmark-server-grpc")
SET(TARGET_BENCHMARK_TOOL "rpc-port-benchmark-tool")
ENABLE_TESTING()
PKG_CHECK_MODULES(PKGMGR_INFO_DEPS REQUIRED pkgmgr-info)
PKG_CHECK_MODULES(TIZEN_SHARED_QUEUE_DEPS REQUIRED tizen-shared-queue)
PKG_CHECK_MODULES(UUID_DEPS REQUIRED uuid)
+PKG_CHECK_MODULES(GRPC_DEPS REQUIRED grpc)
+PKG_CHECK_MODULES(PROTOBUF_DEPS REQUIRED protobuf)
ADD_SUBDIRECTORY(src)
ADD_SUBDIRECTORY(benchmark)
ADD_SUBDIRECTORY(tidl)
ADD_SUBDIRECTORY(dbus)
+ADD_SUBDIRECTORY(grpc)
--- /dev/null
+
+# Proto file
+get_filename_component(hw_proto "./grpcbench.proto" ABSOLUTE)
+get_filename_component(hw_proto_path "${hw_proto}" PATH)
+
+# Generated sources
+SET(hw_proto_srcs "${CMAKE_CURRENT_BINARY_DIR}/grpcbench.pb.cc")
+SET(hw_proto_hdrs "${CMAKE_CURRENT_BINARY_DIR}/grpcbench.pb.h")
+SET(hw_grpc_srcs "${CMAKE_CURRENT_BINARY_DIR}/grpcbench.grpc.pb.cc")
+SET(hw_grpc_hdrs "${CMAKE_CURRENT_BINARY_DIR}/grpcbench.grpc.pb.h")
+ADD_CUSTOM_COMMAND(
+ OUTPUT "${hw_proto_srcs}" "${hw_proto_hdrs}" "${hw_grpc_srcs}" "${hw_grpc_hdrs}"
+ COMMAND protoc
+ ARGS --grpc_out "${CMAKE_CURRENT_BINARY_DIR}"
+ --cpp_out "${CMAKE_CURRENT_BINARY_DIR}"
+ -I "${hw_proto_path}"
+ --plugin=protoc-gen-grpc=`which grpc_cpp_plugin`
+ "${hw_proto}"
+ DEPENDS "${hw_proto}")
+
+#include_directories("${CMAKE_CURRENT_BINARY_DIR}")
+
+AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} BENCHMARK_SERVER_GRPC_SRCS)
+ADD_EXECUTABLE(${TARGET_BENCHMARK_SERVER_GRPC}
+ ${hw_proto_srcs}
+ ${hw_grpc_srcs}
+ ${BENCHMARK_SERVER_GRPC_SRCS}
+)
+
+TARGET_INCLUDE_DIRECTORIES(${TARGET_BENCHMARK_SERVER_GRPC} PUBLIC
+ ${CMAKE_CURRENT_SOURCE_DIR}
+ ${CMAKE_CURRENT_SOURCE_DIR}/../../../include/)
+
+APPLY_PKG_CONFIG(${TARGET_BENCHMARK_SERVER_GRPC} PUBLIC
+ DLOG_DEPS
+ GLIB_DEPS
+ GIO_DEPS
+ GRPC_DEPS
+ PROTOBUF_DEPS
+)
+
+TARGET_LINK_LIBRARIES(${TARGET_BENCHMARK_SERVER_GRPC} PUBLIC
+ ${TARGET_RPC_PORT} "-lpthread" grpc++)
+SET_TARGET_PROPERTIES(${TARGET_BENCHMARK_SERVER_GRPC} PROPERTIES
+ COMPILE_FLAGS "-fPIE")
+SET_TARGET_PROPERTIES(${TARGET_BENCHMARK_SERVER_GRPC} PROPERTIES
+ LINK_FLAGS "-pie")
+
+INSTALL(TARGETS ${TARGET_BENCHMARK_SERVER_GRPC} DESTINATION bin)
--- /dev/null
+#include <iostream>
+#include <memory>
+#include <string>
+
+#include <grpcpp/grpcpp.h>
+
+#include "grpcbench.grpc.pb.h"
+
+using grpc::Server;
+using grpc::ServerBuilder;
+using grpc::ServerContext;
+using grpc::Status;
+using grpcbench::Greeter;
+using grpcbench::HelloReply;
+using grpcbench::HelloRequest;
+
+class GreeterServiceImpl final : public Greeter::Service {
+ Status SayHello(ServerContext* context, const HelloRequest* request,
+ HelloReply* reply) override {
+ reply->set_message(0);
+ return Status::OK;
+ }
+};
+
+int main(int argc, char** argv) {
+ std::string server_address("unix:///tmp/test.socket");
+
+ GreeterServiceImpl service;
+
+ ServerBuilder builder;
+ builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());
+ builder.RegisterService(&service);
+ std::unique_ptr<Server> server(builder.BuildAndStart());
+ std::cout << "Server listening on " << server_address << std::endl;
+
+ server->Wait();
+
+ return 0;
+}
\ No newline at end of file
--- /dev/null
+syntax = "proto3";
+
+package grpcbench;
+
+// The greeting service definition.
+service Greeter {
+ // Sends a greeting
+ rpc SayHello (HelloRequest) returns (HelloReply) {}
+}
+
+// The request message containing the user's name.
+message HelloRequest {
+ string name = 1;
+}
+
+// The response message containing the greetings
+message HelloReply {
+ int32 message = 1;
+}
-AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} BENCHMARK_SERVER_SRCS)
+AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} BENCHMARK_SERVER_TIDL_SRCS)
-ADD_EXECUTABLE(${TARGET_BENCHMARK_SERVER} ${BENCHMARK_SERVER_SRCS})
+ADD_EXECUTABLE(${TARGET_BENCHMARK_SERVER_TIDL} ${BENCHMARK_SERVER_TIDL_SRCS})
-TARGET_INCLUDE_DIRECTORIES(${TARGET_BENCHMARK_SERVER} PUBLIC
+TARGET_INCLUDE_DIRECTORIES(${TARGET_BENCHMARK_SERVER_TIDL} PUBLIC
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/../../../include/)
-APPLY_PKG_CONFIG(${TARGET_BENCHMARK_SERVER} PUBLIC
+APPLY_PKG_CONFIG(${TARGET_BENCHMARK_SERVER_TIDL} PUBLIC
AUL_DEPS
DLOG_DEPS
GLIB_DEPS
)
-TARGET_LINK_LIBRARIES(${TARGET_BENCHMARK_SERVER} PUBLIC
+TARGET_LINK_LIBRARIES(${TARGET_BENCHMARK_SERVER_TIDL} PUBLIC
${TARGET_RPC_PORT} "-lpthread")
-SET_TARGET_PROPERTIES(${TARGET_BENCHMARK_SERVER} PROPERTIES
+SET_TARGET_PROPERTIES(${TARGET_BENCHMARK_SERVER_TIDL} PROPERTIES
COMPILE_FLAGS "-fPIE")
-SET_TARGET_PROPERTIES(${TARGET_BENCHMARK_SERVER} PROPERTIES
+SET_TARGET_PROPERTIES(${TARGET_BENCHMARK_SERVER_TIDL} PROPERTIES
LINK_FLAGS "-pie")
-INSTALL(TARGETS ${TARGET_BENCHMARK_SERVER} DESTINATION bin)
+INSTALL(TARGETS ${TARGET_BENCHMARK_SERVER_TIDL} DESTINATION bin)
+# Proto file
+get_filename_component(hw_proto "./grpcbench.proto" ABSOLUTE)
+get_filename_component(hw_proto_path "${hw_proto}" PATH)
+
+# Generated sources
+SET(hw_proto_srcs "${CMAKE_CURRENT_BINARY_DIR}/grpcbench.pb.cc")
+SET(hw_proto_hdrs "${CMAKE_CURRENT_BINARY_DIR}/grpcbench.pb.h")
+SET(hw_grpc_srcs "${CMAKE_CURRENT_BINARY_DIR}/grpcbench.grpc.pb.cc")
+SET(hw_grpc_hdrs "${CMAKE_CURRENT_BINARY_DIR}/grpcbench.grpc.pb.h")
+ADD_CUSTOM_COMMAND(
+ OUTPUT "${hw_proto_srcs}" "${hw_proto_hdrs}" "${hw_grpc_srcs}" "${hw_grpc_hdrs}"
+ COMMAND protoc
+ ARGS --grpc_out "${CMAKE_CURRENT_BINARY_DIR}"
+ --cpp_out "${CMAKE_CURRENT_BINARY_DIR}"
+ -I "${hw_proto_path}"
+ --plugin=protoc-gen-grpc=`which grpc_cpp_plugin`
+ "${hw_proto}"
+ DEPENDS "${hw_proto}")
+
AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} BENCHMARK_SRCS)
-ADD_EXECUTABLE(${TARGET_BENCHMARK_TOOL} ${BENCHMARK_SRCS})
+ADD_EXECUTABLE(${TARGET_BENCHMARK_TOOL}
+ ${hw_proto_srcs}
+ ${hw_grpc_srcs}
+ ${BENCHMARK_SRCS}
+)
TARGET_INCLUDE_DIRECTORIES(${TARGET_BENCHMARK_TOOL} PUBLIC
${CMAKE_CURRENT_SOURCE_DIR}
BUNDLE_DEPS
DLOG_DEPS
GLIB_DEPS
+ GRPC_DEPS
+ PROTOBUF_DEPS
)
TARGET_LINK_LIBRARIES(${TARGET_BENCHMARK_TOOL} PUBLIC
- ${TARGET_RPC_PORT} "-lpthread")
+ ${TARGET_RPC_PORT} "-lpthread" grpc++)
SET_TARGET_PROPERTIES(${TARGET_BENCHMARK_TOOL} PROPERTIES
COMPILE_FLAGS "-fPIE")
SET_TARGET_PROPERTIES(${TARGET_BENCHMARK_TOOL} PROPERTIES
--- /dev/null
+/*
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
+ *
+ * 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 "grpc-proxy.hh"
+
+namespace rpc_port {
+namespace benchmark {
+
+GrpcProxy::GrpcProxy() {
+}
+
+void GrpcProxy::Connect() {
+ std::string target_str("unix:///tmp/test.socket");
+ channel_ = grpc::CreateChannel(target_str,
+ grpc::InsecureChannelCredentials());
+ stub_ = grpcbench::Greeter::NewStub(channel_);
+}
+
+int GrpcProxy::Test(std::string data) const {
+ grpcbench::HelloRequest request;
+ request.set_name(data);
+
+ grpc::ClientContext context;
+ grpcbench::HelloReply response;
+
+ grpc::Status status = stub_->SayHello(&context, request, &response);
+ if (status.ok()) {
+ int ret = response.message();
+ return ret;
+ }
+
+ return -1;
+}
+
+} // namespace benchmark
+} // namespace rpc_port
--- /dev/null
+/*
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
+ *
+ * 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.
+ */
+
+#ifndef GRPC_PROXY_HH_
+#define GRPC_PROXY_HH_
+
+#include <string>
+#include <memory>
+
+#include <grpcpp/grpcpp.h>
+#include "grpcbench.grpc.pb.h"
+
+namespace rpc_port {
+namespace benchmark {
+
+class GrpcProxy {
+ public:
+ GrpcProxy();
+
+ void Connect();
+ int Test(std::string data) const;
+
+ private:
+ std::unique_ptr<grpcbench::Greeter::Stub> stub_;
+ std::shared_ptr<grpc::Channel> channel_;
+};
+
+} // namespace benchmark
+} // namespace rpc_port
+
+#endif // GRPC_PROXY_HH_
--- /dev/null
+syntax = "proto3";
+
+package grpcbench;
+
+// The greeting service definition.
+service Greeter {
+ // Sends a greeting
+ rpc SayHello (HelloRequest) returns (HelloReply) {}
+}
+
+// The request message containing the user's name.
+message HelloRequest {
+ string name = 1;
+}
+
+// The response message containing the greetings
+message HelloReply {
+ int32 message = 1;
+}
#include "options.hh"
#include "BenchmarkProxy.h"
#include "dbus-proxy.hh"
+#include "grpc-proxy.hh"
namespace {
#define SERVER_PROC_NAME "org.tizen.appfw.rpc_port.benchmark"
-#define SERVER_BIN "/usr/bin/rpc-port-benchmark-server"
+#define SERVER_BIN_TIDL "/usr/bin/rpc-port-benchmark-server-tidl"
#define SERVER_BIN_DBUS "/usr/bin/rpc-port-benchmark-server-dbus"
+#define SERVER_BIN_GRPC "/usr/bin/rpc-port-benchmark-server-grpc"
namespace bp = rpc_port::BenchmarkProxy::proxy;
return;
}
- ExecuteServer(options_->IsDbus());
+ ExecuteServer();
if (options_->IsDbus()) {
dbus_proxy_.Connect();
+ } else if (options_->IsGrpc()) {
+ grpc_proxy_.Connect();
} else {
proxy_.reset(new bp::Benchmark(&listener_, SERVER_PROC_NAME));
void DoTest(int iters, int size) {
bool is_func = options_->IsFunction();
bool is_dbus = options_->IsDbus();
+ bool is_grpc = options_->IsGrpc();
StartTime();
for (int i = 0; i < iters; i++) {
if (is_func) {
int ret = FakeFunction(std::string(size, 'a'));
if (ret != 0) {
- _E("Invalid return");
+ std::cerr << "Invalid return" << std::endl;
break;
}
if (is_dbus) {
int ret = dbus_proxy_.Test(std::string(size, 'a'));
if (ret != 0) {
- _E("Invalid return");
+ std::cerr << "Invalid return" << std::endl;
+ break;
+ }
+
+ continue;
+ }
+
+ if (is_grpc) {
+ int ret = grpc_proxy_.Test(std::string(size, 'a'));
+ if (ret != 0) {
+ std::cerr << "Invalid return" << std::endl;
break;
}
int ret = proxy_->Test(std::string(size, 'a'));
if (ret != 0) {
- _E("Invalid return");
+ std::cerr << "Invalid return" << std::endl;
break;
}
}
sec.count(), t, l);
}
- void ExecuteServer(bool is_dbus) {
+ void ExecuteServer() {
+ bool is_dbus = options_->IsDbus();
+ bool is_grpc = options_->IsGrpc();
+
server_pid_ = fork();
if (server_pid_ == 0) {
setsid();
char bin[] = { SERVER_BIN_DBUS };
char* argv[] = { bin, nullptr, nullptr };
ret = execv(argv[0], argv);
+ } else if (is_grpc) {
+ char bin[] = { SERVER_BIN_GRPC };
+ char* argv[] = { bin, nullptr, nullptr };
+ ret = execv(argv[0], argv);
} else {
- char bin[] = { SERVER_BIN };
+ char bin[] = { SERVER_BIN_TIDL };
char* argv[] = { bin, nullptr, nullptr };
ret = execv(argv[0], argv);
}
std::chrono::system_clock::time_point start_;
pid_t server_pid_ = -1;
rpc_port::benchmark::DbusProxy dbus_proxy_;
+ rpc_port::benchmark::GrpcProxy grpc_proxy_;
};
} // namespace
Additional Options:
-f, --funcation Use function call instead of RPC
-d, --dbus Use Dbus method instead of TIDL RPC
+ -g, --grpc Use gRPC over UDS instead of TIDL RPC
-a, --all Test pre-defined test-cases
-i, --interations=<Iterations> Iterations
-s, --size=<Data size> Data size (byte)
{"size", required_argument, nullptr, 's'},
{"function", no_argument, nullptr, 'f'},
{"dbus", no_argument, nullptr, 'd'},
+ {"grpc", no_argument, nullptr, 'g'},
{"all", no_argument, nullptr, 'a'},
{0, 0, 0, 0}
};
while (true) {
- int c = getopt_long(argc, argv, "vhfdai:s:", long_options,
+ int c = getopt_long(argc, argv, "vhfdgai:s:", long_options,
&option_index);
if (c == -1)
break;
options->is_dbus_ = true;
break;
+ case 'g':
+ opt[OPT_GRPC] = true;
+ options->is_grpc_ = true;
+ break;
+
case 'a':
opt[OPT_ALL] = true;
options->is_all_ = true;
return is_dbus_;
}
+ bool IsGrpc() const {
+ return is_grpc_;
+ }
+
private:
enum Cmd {
CMD_VERSION,
OPT_ALL,
OPT_FUNCTION,
OPT_DBUS,
+ OPT_GRPC,
OPT_MAX
};
bool is_function_ = false;
bool is_all_ = false;
bool is_dbus_ = false;
+ bool is_grpc_ = false;
};
} // namespace benchmark
BuildRequires: pkgconfig(pkgmgr-info)
BuildRequires: pkgconfig(tizen-shared-queue)
BuildRequires: pkgconfig(uuid)
+BuildRequires: pkgconfig(grpc)
+BuildRequires: pkgconfig(protobuf)
%if 0%{?gcov:1}
BuildRequires: lcov
%attr(0644,root,root) %{_libdir}/lib%{name}.so.*
%license LICENSE.APLv2
%{_bindir}/rpc-port-util
-%{_bindir}/rpc-port-benchmark-server
+%{_bindir}/rpc-port-benchmark-server-tidl
%{_bindir}/rpc-port-benchmark-server-dbus
+%{_bindir}/rpc-port-benchmark-server-grpc
%{_bindir}/rpc-port-benchmark-tool
%config %{_sysconfdir}/dbus-1/system.d/rpc-port.conf
projects / platform / core / appfw / rpc-port.git / commitdiff