SRPC is an enterprise-level RPC system used by almost all online services in Sogou. It handles tens of billions of requests every day, covering searches, recommendations, advertising system, and other types of services.
Bases on Sogou C++ Workflow, it is an excellent choice for high-performance, low-latency, lightweight RPC systems. Contains AOP aspect-oriented modules that can report Metrics and Trace to a variety of cloud-native systems, such as OpenTelemetry, etc.
Its main features include:
- Support multiple RPC protocols:
SRPC,bRPC,Thrift,tRPC - Support multiple operating systems:
Linux,MacOS,Windows - Support several IDL formats:
Protobuf,Thrift - Support several data formats transparently:
Json,Protobuf,Thrift Binary - Support several compression formats, the framework automatically decompresses:
gzip,zlib,snappy,lz4 - Support several communication protocols transparently:
tcp,udp,sctp,tcp ssl - With HTTP+JSON, you can communicate with the client or server in any language
- Use it together with Workflow Series and Parallel to facilitate the use of calculations and other asynchronous resources
- Perfectly compatible with all Workflow functions, such as name service, upstream and other components
- Report Tracing to OpenTelemetry
- Report Metrics to OpenTelemetry and Prometheus
- More features...
srpc has been packaged for Debian and Fedora. Therefore, we can install it from source code or from the package in the system.
reference: Linux, MacOS, Windows Installation and Compilation Guide
Let's quickly learn how to use it in a few steps.
For more detailed usage, please refer to Documents and Tutorial.
syntax = "proto3";// You can use either proto2 or proto3. Both are supported by srpc
message EchoRequest {
string message = 1;
string name = 2;
};
message EchoResponse {
string message = 1;
};
service Example {
rpc Echo(EchoRequest) returns (EchoResponse);
};protoc example.proto --cpp_out=./ --proto_path=./
srpc_generator protobuf ./example.proto ./#include <stdio.h>
#include <signal.h>
#include "example.srpc.h"
using namespace srpc;
class ExampleServiceImpl : public Example::Service
{
public:
void Echo(EchoRequest *request, EchoResponse *response, RPCContext *ctx) override
{
response->set_message("Hi, " + request->name());
printf("get_req:\n%s\nset_resp:\n%s\n",
request->DebugString().c_str(), response->DebugString().c_str());
}
};
void sig_handler(int signo) { }
int main()
{
signal(SIGINT, sig_handler);
signal(SIGTERM, sig_handler);
SRPCServer server_tcp;
SRPCHttpServer server_http;
ExampleServiceImpl impl;
server_tcp.add_service(&impl);
server_http.add_service(&impl);
server_tcp.start(1412);
server_http.start(8811);
getchar(); // press "Enter" to end.
server_http.stop();
server_tcp.stop();
return 0;
}#include <stdio.h>
#include "example.srpc.h"
using namespace srpc;
int main()
{
Example::SRPCClient client("127.0.0.1", 1412);
EchoRequest req;
req.set_message("Hello, srpc!");
req.set_name("workflow");
client.Echo(&req, [](EchoResponse *response, RPCContext *ctx) {
if (ctx->success())
printf("%s\n", response->DebugString().c_str());
else
printf("status[%d] error[%d] errmsg:%s\n",
ctx->get_status_code(), ctx->get_error(), ctx->get_errmsg());
});
getchar(); // press "Enter" to end.
return 0;
}These compile commands are only for Linux system. On other system, complete cmake in tutorial is recommanded.
g++ -o server server.cc example.pb.cc -std=c++11 -lsrpc
g++ -o client client.cc example.pb.cc -std=c++11 -lsrpcTerminal 1:
./serverTerminal 2:
./clientWe can also use CURL to post Http request:
curl 127.0.0.1:8811/Example/Echo -H 'Content-Type: application/json' -d '{message:"from curl",name:"CURL"}'Output of Terminal 1:
get_req:
message: "Hello, srpc!"
name: "workflow"
set_resp:
message: "Hi, workflow"
get_req:
message: "from curl"
name: "CURL"
set_resp:
message: "Hi, CURL"
Output of Terminal 2:
message: "Hi, workflow"Output of CURL:
{"message":"Hi, CURL"}- CPU 2-chip/8-core/32-processor Intel(R) Xeon(R) CPU E5-2630 v3 @2.40GHz
- Memory all 128G
- 10 Gigabit Ethernet
- BAIDU brpc-client in pooled (connection pool) mode
Client = 1
ClientThread = 64, 128, 256, 512, 1024
RequestSize = 32
Duration = 20s
Server = 1
ServerIOThread = 16
ServerHandlerThread = 16
Client = 1, 2, 4, 8, 16
ClientThread = 32
RequestSize = 32
Duration = 20s
Server = 1
ServerIOThread = 16
ServerHandlerThread = 16
Client = 1
ClientThread = 1, 2, 4, 8, 16, 32, 64, 128, 256
RequestSize = 1024
Duration = 20s
Server = 1
ServerIOThread = 16
ServerHandlerThread = 16
Client = 1
ClientThread = 100
RequestSize = 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768
Duration = 20s
Server = 1
ServerIOThread = 16
ServerHandlerThread = 16
Client = 1
ClientThread = 50
ClientQPS = 10000
RequestSize = 1024
Duration = 20s
Server = 1
ServerIOThread = 16
ServerHandlerThread = 16
Outiler = 1%
Client = 32
ClientThread = 16
ClientQPS = 2500
RequestSize = 512
Duration = 20s
Server = 1
ServerIOThread = 16
ServerHandlerThread = 16
Outiler = 1%
- Email - [email protected] - main author
- Issue - You are very welcome to post questions to issues list.
- QQ - Group number:
618773193
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent