| /* |
| * Copyright (C) 2021 The Android Open Source Project |
| * |
| * 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 <BnBinderRpcBenchmark.h> |
| #include <android-base/logging.h> |
| #include <benchmark/benchmark.h> |
| #include <binder/Binder.h> |
| #include <binder/IPCThreadState.h> |
| #include <binder/IServiceManager.h> |
| #include <binder/ProcessState.h> |
| #include <binder/RpcCertificateFormat.h> |
| #include <binder/RpcCertificateVerifier.h> |
| #include <binder/RpcServer.h> |
| #include <binder/RpcSession.h> |
| #include <binder/RpcTlsTestUtils.h> |
| #include <binder/RpcTlsUtils.h> |
| #include <binder/RpcTransportRaw.h> |
| #include <binder/RpcTransportTls.h> |
| #include <openssl/ssl.h> |
| |
| #include <thread> |
| |
| #include <signal.h> |
| #include <sys/prctl.h> |
| #include <sys/types.h> |
| #include <unistd.h> |
| |
| using android::BBinder; |
| using android::defaultServiceManager; |
| using android::IBinder; |
| using android::interface_cast; |
| using android::IPCThreadState; |
| using android::IServiceManager; |
| using android::OK; |
| using android::ProcessState; |
| using android::RpcAuthPreSigned; |
| using android::RpcCertificateFormat; |
| using android::RpcCertificateVerifier; |
| using android::RpcCertificateVerifierNoOp; |
| using android::RpcServer; |
| using android::RpcSession; |
| using android::RpcTransportCtxFactory; |
| using android::RpcTransportCtxFactoryRaw; |
| using android::RpcTransportCtxFactoryTls; |
| using android::sp; |
| using android::status_t; |
| using android::statusToString; |
| using android::String16; |
| using android::binder::Status; |
| |
| class MyBinderRpcBenchmark : public BnBinderRpcBenchmark { |
| Status repeatString(const std::string& str, std::string* out) override { |
| *out = str; |
| return Status::ok(); |
| } |
| Status repeatBinder(const sp<IBinder>& binder, sp<IBinder>* out) override { |
| *out = binder; |
| return Status::ok(); |
| } |
| Status repeatBytes(const std::vector<uint8_t>& bytes, std::vector<uint8_t>* out) override { |
| *out = bytes; |
| return Status::ok(); |
| } |
| |
| class CountedBinder : public BBinder { |
| public: |
| CountedBinder(const sp<MyBinderRpcBenchmark>& parent) : mParent(parent) { |
| std::lock_guard<std::mutex> l(mParent->mCountMutex); |
| mParent->mBinderCount++; |
| // std::cout << "Count + is now " << mParent->mBinderCount << std::endl; |
| } |
| ~CountedBinder() { |
| { |
| std::lock_guard<std::mutex> l(mParent->mCountMutex); |
| mParent->mBinderCount--; |
| // std::cout << "Count - is now " << mParent->mBinderCount << std::endl; |
| |
| // skip notify |
| if (mParent->mBinderCount != 0) return; |
| } |
| mParent->mCountCv.notify_one(); |
| } |
| |
| private: |
| sp<MyBinderRpcBenchmark> mParent; |
| }; |
| |
| Status gimmeBinder(sp<IBinder>* out) override { |
| *out = sp<CountedBinder>::make(sp<MyBinderRpcBenchmark>::fromExisting(this)); |
| return Status::ok(); |
| } |
| Status waitGimmesDestroyed() override { |
| std::unique_lock<std::mutex> l(mCountMutex); |
| mCountCv.wait(l, [&] { return mBinderCount == 0; }); |
| return Status::ok(); |
| } |
| |
| friend class CountedBinder; |
| std::mutex mCountMutex; |
| std::condition_variable mCountCv; |
| size_t mBinderCount; |
| }; |
| |
| enum Transport { |
| KERNEL, |
| RPC, |
| RPC_TLS, |
| }; |
| |
| static const std::initializer_list<int64_t> kTransportList = { |
| #ifdef __BIONIC__ |
| Transport::KERNEL, |
| #endif |
| Transport::RPC, |
| Transport::RPC_TLS, |
| }; |
| |
| std::unique_ptr<RpcTransportCtxFactory> makeFactoryTls() { |
| auto pkey = android::makeKeyPairForSelfSignedCert(); |
| CHECK_NE(pkey.get(), nullptr); |
| auto cert = android::makeSelfSignedCert(pkey.get(), android::kCertValidSeconds); |
| CHECK_NE(cert.get(), nullptr); |
| |
| auto verifier = std::make_shared<RpcCertificateVerifierNoOp>(OK); |
| auto auth = std::make_unique<RpcAuthPreSigned>(std::move(pkey), std::move(cert)); |
| return RpcTransportCtxFactoryTls::make(verifier, std::move(auth)); |
| } |
| |
| static sp<RpcSession> gSession = RpcSession::make(); |
| static sp<IBinder> gRpcBinder; |
| // Certificate validation happens during handshake and does not affect the result of benchmarks. |
| // Skip certificate validation to simplify the setup process. |
| static sp<RpcSession> gSessionTls = RpcSession::make(makeFactoryTls()); |
| static sp<IBinder> gRpcTlsBinder; |
| #ifdef __BIONIC__ |
| static const String16 kKernelBinderInstance = String16(u"binderRpcBenchmark-control"); |
| static sp<IBinder> gKernelBinder; |
| #endif |
| |
| static sp<IBinder> getBinderForOptions(benchmark::State& state) { |
| Transport transport = static_cast<Transport>(state.range(0)); |
| switch (transport) { |
| #ifdef __BIONIC__ |
| case KERNEL: |
| return gKernelBinder; |
| #endif |
| case RPC: |
| return gRpcBinder; |
| case RPC_TLS: |
| return gRpcTlsBinder; |
| default: |
| LOG(FATAL) << "Unknown transport value: " << transport; |
| return nullptr; |
| } |
| } |
| |
| static void SetLabel(benchmark::State& state) { |
| Transport transport = static_cast<Transport>(state.range(0)); |
| switch (transport) { |
| #ifdef __BIONIC__ |
| case KERNEL: |
| state.SetLabel("kernel"); |
| break; |
| #endif |
| case RPC: |
| state.SetLabel("rpc"); |
| break; |
| case RPC_TLS: |
| state.SetLabel("rpc_tls"); |
| break; |
| default: |
| LOG(FATAL) << "Unknown transport value: " << transport; |
| } |
| } |
| |
| void BM_pingTransaction(benchmark::State& state) { |
| sp<IBinder> binder = getBinderForOptions(state); |
| |
| while (state.KeepRunning()) { |
| CHECK_EQ(OK, binder->pingBinder()); |
| } |
| |
| SetLabel(state); |
| } |
| BENCHMARK(BM_pingTransaction)->ArgsProduct({kTransportList}); |
| |
| void BM_repeatTwoPageString(benchmark::State& state) { |
| sp<IBinder> binder = getBinderForOptions(state); |
| |
| sp<IBinderRpcBenchmark> iface = interface_cast<IBinderRpcBenchmark>(binder); |
| CHECK(iface != nullptr); |
| |
| // Googlers might see go/another-look-at-aidl-hidl-perf |
| // |
| // When I checked in July 2019, 99.5% of AIDL transactions and 99.99% of HIDL |
| // transactions were less than one page in size (system wide during a test |
| // involving media and camera). This is why this diverges from |
| // binderThroughputTest and hwbinderThroughputTest. Future consideration - get |
| // this data on continuous integration. Here we are testing sending a |
| // transaction of twice this size. In other cases, we should focus on |
| // benchmarks of particular usecases. If individual binder transactions like |
| // the ones tested here are fast, then Android performance will be dominated |
| // by how many binder calls work together (and by factors like the scheduler, |
| // thermal throttling, core choice, etc..). |
| std::string str = std::string(getpagesize() * 2, 'a'); |
| CHECK_EQ(static_cast<ssize_t>(str.size()), getpagesize() * 2); |
| |
| while (state.KeepRunning()) { |
| std::string out; |
| Status ret = iface->repeatString(str, &out); |
| CHECK(ret.isOk()) << ret; |
| } |
| |
| SetLabel(state); |
| } |
| BENCHMARK(BM_repeatTwoPageString)->ArgsProduct({kTransportList}); |
| |
| void BM_throughputForTransportAndBytes(benchmark::State& state) { |
| sp<IBinder> binder = getBinderForOptions(state); |
| sp<IBinderRpcBenchmark> iface = interface_cast<IBinderRpcBenchmark>(binder); |
| CHECK(iface != nullptr); |
| |
| std::vector<uint8_t> bytes = std::vector<uint8_t>(state.range(1)); |
| for (size_t i = 0; i < bytes.size(); i++) { |
| bytes[i] = i % 256; |
| } |
| |
| while (state.KeepRunning()) { |
| std::vector<uint8_t> out; |
| Status ret = iface->repeatBytes(bytes, &out); |
| CHECK(ret.isOk()) << ret; |
| } |
| |
| SetLabel(state); |
| } |
| BENCHMARK(BM_throughputForTransportAndBytes) |
| ->ArgsProduct({kTransportList, |
| {64, 1024, 2048, 4096, 8182, 16364, 32728, 65535, 65536, 65537}}); |
| |
| void BM_collectProxies(benchmark::State& state) { |
| sp<IBinder> binder = getBinderForOptions(state); |
| sp<IBinderRpcBenchmark> iface = interface_cast<IBinderRpcBenchmark>(binder); |
| CHECK(iface != nullptr); |
| |
| const size_t kNumIters = state.range(1); |
| |
| while (state.KeepRunning()) { |
| std::vector<sp<IBinder>> out; |
| out.resize(kNumIters); |
| |
| for (size_t i = 0; i < kNumIters; i++) { |
| Status ret = iface->gimmeBinder(&out[i]); |
| CHECK(ret.isOk()) << ret; |
| } |
| |
| out.clear(); |
| |
| // we are using a thread up to wait, so make a call to |
| // force all refcounts to be updated first - current |
| // binder behavior means we really don't need to wait, |
| // so code which is waiting is really there to protect |
| // against any future changes that could delay destruction |
| android::IInterface::asBinder(iface)->pingBinder(); |
| |
| iface->waitGimmesDestroyed(); |
| } |
| |
| SetLabel(state); |
| } |
| BENCHMARK(BM_collectProxies)->ArgsProduct({kTransportList, {10, 100, 1000, 5000, 10000, 20000}}); |
| |
| void BM_repeatBinder(benchmark::State& state) { |
| sp<IBinder> binder = getBinderForOptions(state); |
| CHECK(binder != nullptr); |
| sp<IBinderRpcBenchmark> iface = interface_cast<IBinderRpcBenchmark>(binder); |
| CHECK(iface != nullptr); |
| |
| while (state.KeepRunning()) { |
| // force creation of a new address |
| sp<IBinder> binder = sp<BBinder>::make(); |
| |
| sp<IBinder> out; |
| Status ret = iface->repeatBinder(binder, &out); |
| CHECK(ret.isOk()) << ret; |
| } |
| |
| SetLabel(state); |
| } |
| BENCHMARK(BM_repeatBinder)->ArgsProduct({kTransportList}); |
| |
| void forkRpcServer(const char* addr, const sp<RpcServer>& server) { |
| if (0 == fork()) { |
| prctl(PR_SET_PDEATHSIG, SIGHUP); // racey, okay |
| server->setRootObject(sp<MyBinderRpcBenchmark>::make()); |
| CHECK_EQ(OK, server->setupUnixDomainServer(addr)); |
| server->join(); |
| exit(1); |
| } |
| } |
| |
| void setupClient(const sp<RpcSession>& session, const char* addr) { |
| status_t status; |
| for (size_t tries = 0; tries < 5; tries++) { |
| usleep(10000); |
| status = session->setupUnixDomainClient(addr); |
| if (status == OK) break; |
| } |
| CHECK_EQ(status, OK) << "Could not connect: " << addr << ": " << statusToString(status).c_str(); |
| } |
| |
| int main(int argc, char** argv) { |
| ::benchmark::Initialize(&argc, argv); |
| if (::benchmark::ReportUnrecognizedArguments(argc, argv)) return 1; |
| |
| #ifdef __BIONIC__ |
| if (0 == fork()) { |
| prctl(PR_SET_PDEATHSIG, SIGHUP); // racey, okay |
| CHECK_EQ(OK, |
| defaultServiceManager()->addService(kKernelBinderInstance, |
| sp<MyBinderRpcBenchmark>::make())); |
| IPCThreadState::self()->joinThreadPool(); |
| exit(1); |
| } |
| |
| ProcessState::self()->setThreadPoolMaxThreadCount(1); |
| ProcessState::self()->startThreadPool(); |
| |
| gKernelBinder = defaultServiceManager()->waitForService(kKernelBinderInstance); |
| CHECK_NE(nullptr, gKernelBinder.get()); |
| #endif |
| |
| std::string tmp = getenv("TMPDIR") ?: "/tmp"; |
| |
| std::string addr = tmp + "/binderRpcBenchmark"; |
| (void)unlink(addr.c_str()); |
| forkRpcServer(addr.c_str(), RpcServer::make(RpcTransportCtxFactoryRaw::make())); |
| setupClient(gSession, addr.c_str()); |
| gRpcBinder = gSession->getRootObject(); |
| |
| std::string tlsAddr = tmp + "/binderRpcTlsBenchmark"; |
| (void)unlink(tlsAddr.c_str()); |
| forkRpcServer(tlsAddr.c_str(), RpcServer::make(makeFactoryTls())); |
| setupClient(gSessionTls, tlsAddr.c_str()); |
| gRpcTlsBinder = gSessionTls->getRootObject(); |
| |
| ::benchmark::RunSpecifiedBenchmarks(); |
| return 0; |
| } |