blob: f91234868987ce9189425dc5eb4929b94d181497 [file] [log] [blame] [edit]
#include <binder/Binder.h>
#include <binder/IBinder.h>
#include <binder/IPCThreadState.h>
#include <binder/IServiceManager.h>
#include <string>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <fstream>
#include <iostream>
#include <tuple>
#include <vector>
#include <unistd.h>
#include <sys/wait.h>
using namespace std;
using namespace android;
enum BinderWorkerServiceCode {
BINDER_NOP = IBinder::FIRST_CALL_TRANSACTION,
};
#define ASSERT_TRUE(cond) \
do { \
if (!(cond)) {\
cerr << __func__ << ":" << __LINE__ << " condition:" << #cond << " failed\n" << endl; \
exit(EXIT_FAILURE); \
} \
} while (0)
class BinderWorkerService : public BBinder
{
public:
BinderWorkerService() {}
~BinderWorkerService() {}
virtual status_t onTransact(uint32_t code,
const Parcel& data, Parcel* reply,
uint32_t flags = 0) {
(void)flags;
(void)data;
(void)reply;
switch (code) {
case BINDER_NOP:
return NO_ERROR;
default:
return UNKNOWN_TRANSACTION;
};
}
};
static uint64_t warn_latency = std::numeric_limits<uint64_t>::max();
struct ProcResults {
vector<uint64_t> data;
ProcResults(size_t capacity) { data.reserve(capacity); }
void add_time(uint64_t time) { data.push_back(time); }
void combine_with(const ProcResults& append) {
data.insert(data.end(), append.data.begin(), append.data.end());
}
uint64_t worst() {
return *max_element(data.begin(), data.end());
}
void dump_to_file(string filename) {
ofstream output;
output.open(filename);
if (!output.is_open()) {
cerr << "Failed to open '" << filename << "'." << endl;
exit(EXIT_FAILURE);
}
for (uint64_t value : data) {
output << value << "\n";
}
output.close();
}
void dump() {
if (data.size() == 0) {
// This avoids index-out-of-bounds below.
cout << "error: no data\n" << endl;
return;
}
size_t num_long_transactions = 0;
for (uint64_t elem : data) {
if (elem > warn_latency) {
num_long_transactions += 1;
}
}
if (num_long_transactions > 0) {
cout << (double)num_long_transactions / data.size() << "% of transactions took longer "
"than estimated max latency. Consider setting -m to be higher than "
<< worst() / 1000 << " microseconds" << endl;
}
sort(data.begin(), data.end());
uint64_t total_time = 0;
for (uint64_t elem : data) {
total_time += elem;
}
double best = (double)data[0] / 1.0E6;
double worst = (double)data.back() / 1.0E6;
double average = (double)total_time / data.size() / 1.0E6;
cout << "average:" << average << "ms worst:" << worst << "ms best:" << best << "ms" << endl;
double percentile_50 = data[(50 * data.size()) / 100] / 1.0E6;
double percentile_90 = data[(90 * data.size()) / 100] / 1.0E6;
double percentile_95 = data[(95 * data.size()) / 100] / 1.0E6;
double percentile_99 = data[(99 * data.size()) / 100] / 1.0E6;
cout << "50%: " << percentile_50 << " ";
cout << "90%: " << percentile_90 << " ";
cout << "95%: " << percentile_95 << " ";
cout << "99%: " << percentile_99 << endl;
}
};
class Pipe {
int m_readFd;
int m_writeFd;
Pipe(int readFd, int writeFd) : m_readFd{readFd}, m_writeFd{writeFd} {}
Pipe(const Pipe &) = delete;
Pipe& operator=(const Pipe &) = delete;
Pipe& operator=(const Pipe &&) = delete;
public:
Pipe(Pipe&& rval) noexcept {
m_readFd = rval.m_readFd;
m_writeFd = rval.m_writeFd;
rval.m_readFd = 0;
rval.m_writeFd = 0;
}
~Pipe() {
if (m_readFd)
close(m_readFd);
if (m_writeFd)
close(m_writeFd);
}
void signal() {
bool val = true;
int error = write(m_writeFd, &val, sizeof(val));
ASSERT_TRUE(error >= 0);
};
void wait() {
bool val = false;
int error = read(m_readFd, &val, sizeof(val));
ASSERT_TRUE(error >= 0);
}
void send(const ProcResults& v) {
size_t num_elems = v.data.size();
int error = write(m_writeFd, &num_elems, sizeof(size_t));
ASSERT_TRUE(error >= 0);
char* to_write = (char*)v.data.data();
size_t num_bytes = sizeof(uint64_t) * num_elems;
while (num_bytes > 0) {
int ret = write(m_writeFd, to_write, num_bytes);
ASSERT_TRUE(ret >= 0);
num_bytes -= ret;
to_write += ret;
}
}
void recv(ProcResults& v) {
size_t num_elems = 0;
int error = read(m_readFd, &num_elems, sizeof(size_t));
ASSERT_TRUE(error >= 0);
v.data.resize(num_elems);
char* read_to = (char*)v.data.data();
size_t num_bytes = sizeof(uint64_t) * num_elems;
while (num_bytes > 0) {
int ret = read(m_readFd, read_to, num_bytes);
ASSERT_TRUE(ret >= 0);
num_bytes -= ret;
read_to += ret;
}
}
static tuple<Pipe, Pipe> createPipePair() {
int a[2];
int b[2];
int error1 = pipe(a);
int error2 = pipe(b);
ASSERT_TRUE(error1 >= 0);
ASSERT_TRUE(error2 >= 0);
return make_tuple(Pipe(a[0], b[1]), Pipe(b[0], a[1]));
}
};
String16 generateServiceName(int num)
{
char num_str[32];
snprintf(num_str, sizeof(num_str), "%d", num);
String16 serviceName = String16("binderWorker") + String16(num_str);
return serviceName;
}
void worker_fx(int num,
int worker_count,
int iterations,
int payload_size,
bool cs_pair,
Pipe p)
{
// Create BinderWorkerService and for go.
ProcessState::self()->startThreadPool();
sp<IServiceManager> serviceMgr = defaultServiceManager();
sp<BinderWorkerService> service = new BinderWorkerService;
serviceMgr->addService(generateServiceName(num), service);
srand(num);
p.signal();
p.wait();
// If client/server pairs, then half the workers are
// servers and half are clients
int server_count = cs_pair ? worker_count / 2 : worker_count;
// Get references to other binder services.
cout << "Created BinderWorker" << num << endl;
(void)worker_count;
vector<sp<IBinder> > workers;
for (int i = 0; i < server_count; i++) {
if (num == i)
continue;
workers.push_back(serviceMgr->waitForService(generateServiceName(i)));
}
p.signal();
p.wait();
ProcResults results(iterations);
chrono::time_point<chrono::high_resolution_clock> start, end;
// Skip the benchmark if server of a cs_pair.
if (!(cs_pair && num < server_count)) {
for (int i = 0; i < iterations; i++) {
Parcel data, reply;
int target = cs_pair ? num % server_count : rand() % workers.size();
int sz = payload_size;
while (sz >= sizeof(uint32_t)) {
data.writeInt32(0);
sz -= sizeof(uint32_t);
}
start = chrono::high_resolution_clock::now();
status_t ret = workers[target]->transact(BINDER_NOP, data, &reply);
end = chrono::high_resolution_clock::now();
uint64_t cur_time = uint64_t(chrono::duration_cast<chrono::nanoseconds>(end - start).count());
results.add_time(cur_time);
if (ret != NO_ERROR) {
cout << "thread " << num << " failed " << ret << "i : " << i << endl;
exit(EXIT_FAILURE);
}
}
}
// Signal completion to master and wait.
p.signal();
p.wait();
// Send results to master and wait for go to exit.
p.send(results);
p.wait();
exit(EXIT_SUCCESS);
}
Pipe make_worker(int num, int iterations, int worker_count, int payload_size, bool cs_pair)
{
auto pipe_pair = Pipe::createPipePair();
pid_t pid = fork();
if (pid) {
/* parent */
return std::move(get<0>(pipe_pair));
} else {
/* child */
worker_fx(num, worker_count, iterations, payload_size, cs_pair,
std::move(get<1>(pipe_pair)));
/* never get here */
return std::move(get<0>(pipe_pair));
}
}
void wait_all(vector<Pipe>& v)
{
for (int i = 0; i < v.size(); i++) {
v[i].wait();
}
}
void signal_all(vector<Pipe>& v)
{
for (int i = 0; i < v.size(); i++) {
v[i].signal();
}
}
void run_main(int iterations, int workers, int payload_size, int cs_pair,
bool training_round = false, bool dump_to_file = false, string dump_filename = "") {
vector<Pipe> pipes;
// Create all the workers and wait for them to spawn.
for (int i = 0; i < workers; i++) {
pipes.push_back(make_worker(i, iterations, workers, payload_size, cs_pair));
}
wait_all(pipes);
// All workers have now been spawned and added themselves to service
// manager. Signal each worker to obtain a handle to the server workers from
// servicemanager.
signal_all(pipes);
// Wait for each worker to finish obtaining a handle to all server workers
// from servicemanager.
wait_all(pipes);
// Run the benchmark and wait for completion.
chrono::time_point<chrono::high_resolution_clock> start, end;
cout << "waiting for workers to complete" << endl;
start = chrono::high_resolution_clock::now();
signal_all(pipes);
wait_all(pipes);
end = chrono::high_resolution_clock::now();
// Calculate overall throughput.
double iterations_per_sec = double(iterations * workers) / (chrono::duration_cast<chrono::nanoseconds>(end - start).count() / 1.0E9);
cout << "iterations per sec: " << iterations_per_sec << endl;
// Collect all results from the workers.
cout << "collecting results" << endl;
signal_all(pipes);
ProcResults tot_results(0), tmp_results(0);
for (int i = 0; i < workers; i++) {
pipes[i].recv(tmp_results);
tot_results.combine_with(tmp_results);
}
// Kill all the workers.
cout << "killing workers" << endl;
signal_all(pipes);
for (int i = 0; i < workers; i++) {
int status;
wait(&status);
if (status != 0) {
cout << "nonzero child status" << status << endl;
}
}
if (training_round) {
// Sets warn_latency to 2 * worst from the training round.
warn_latency = 2 * tot_results.worst();
cout << "Max latency during training: " << tot_results.worst() / 1.0E6 << "ms" << endl;
} else {
if (dump_to_file) {
tot_results.dump_to_file(dump_filename);
}
tot_results.dump();
}
}
int main(int argc, char *argv[])
{
int workers = 2;
int iterations = 10000;
int payload_size = 0;
bool cs_pair = false;
bool training_round = false;
int max_time_us;
bool dump_to_file = false;
string dump_filename;
// Parse arguments.
for (int i = 1; i < argc; i++) {
if (string(argv[i]) == "--help") {
cout << "Usage: binderThroughputTest [OPTIONS]" << endl;
cout << "\t-i N : Specify number of iterations." << endl;
cout << "\t-m N : Specify expected max latency in microseconds." << endl;
cout << "\t-p : Split workers into client/server pairs." << endl;
cout << "\t-s N : Specify payload size." << endl;
cout << "\t-t : Run training round." << endl;
cout << "\t-w N : Specify total number of workers." << endl;
cout << "\t-d FILE : Dump raw data to file." << endl;
return 0;
}
if (string(argv[i]) == "-w") {
if (i + 1 == argc) {
cout << "-w requires an argument\n" << endl;
exit(EXIT_FAILURE);
}
workers = atoi(argv[i+1]);
i++;
continue;
}
if (string(argv[i]) == "-i") {
if (i + 1 == argc) {
cout << "-i requires an argument\n" << endl;
exit(EXIT_FAILURE);
}
iterations = atoi(argv[i+1]);
i++;
continue;
}
if (string(argv[i]) == "-s") {
if (i + 1 == argc) {
cout << "-s requires an argument\n" << endl;
exit(EXIT_FAILURE);
}
payload_size = atoi(argv[i+1]);
i++;
continue;
}
if (string(argv[i]) == "-p") {
// client/server pairs instead of spreading
// requests to all workers. If true, half
// the workers become clients and half servers
cs_pair = true;
continue;
}
if (string(argv[i]) == "-t") {
// Run one training round before actually collecting data
// to get an approximation of max latency.
training_round = true;
continue;
}
if (string(argv[i]) == "-m") {
if (i + 1 == argc) {
cout << "-m requires an argument\n" << endl;
exit(EXIT_FAILURE);
}
// Caller specified the max latency in microseconds.
// No need to run training round in this case.
max_time_us = atoi(argv[i+1]);
if (max_time_us <= 0) {
cout << "Max latency -m must be positive." << endl;
exit(EXIT_FAILURE);
}
warn_latency = max_time_us * 1000ull;
i++;
continue;
}
if (string(argv[i]) == "-d") {
if (i + 1 == argc) {
cout << "-d requires an argument\n" << endl;
exit(EXIT_FAILURE);
}
dump_to_file = true;
dump_filename = argv[i + 1];
i++;
continue;
}
}
if (training_round) {
cout << "Start training round" << endl;
run_main(iterations, workers, payload_size, cs_pair, true);
cout << "Completed training round" << endl << endl;
}
run_main(iterations, workers, payload_size, cs_pair, false, dump_to_file, dump_filename);
return 0;
}