blob: fe9e05a4f140fe3b5ddbc36284bfe52383d76452 [file] [log] [blame]
Howard Chenc135dbc2017-03-25 17:12:59 +08001#include <binder/Binder.h>
2#include <binder/IBinder.h>
3#include <binder/IPCThreadState.h>
4#include <binder/IServiceManager.h>
5#include <cstdio>
6#include <cstdlib>
7#include <cstring>
8#include <string>
9
10#include <iomanip>
11#include <iostream>
12#include <tuple>
13#include <vector>
14
15#include <pthread.h>
16#include <sys/wait.h>
17#include <unistd.h>
Howard Chen25715512017-03-28 17:05:11 +080018#include <fstream>
Howard Chenc135dbc2017-03-25 17:12:59 +080019
20using namespace std;
21using namespace android;
22
23enum BinderWorkerServiceCode {
24 BINDER_NOP = IBinder::FIRST_CALL_TRANSACTION,
25};
26
27#define ASSERT(cond) \
28 do { \
29 if (!(cond)) { \
30 cerr << __func__ << ":" << __LINE__ << " condition:" << #cond \
31 << " failed\n" \
32 << endl; \
33 exit(EXIT_FAILURE); \
34 } \
35 } while (0)
36
37vector<sp<IBinder> > workers;
38
39// the ratio that the service is synced on the same cpu beyond
40// GOOD_SYNC_MIN is considered as good
41#define GOOD_SYNC_MIN (0.6)
42
43#define DUMP_PRICISION 3
44
Howard Chen25715512017-03-28 17:05:11 +080045string trace_path = "/sys/kernel/debug/tracing";
46
Howard Chenc135dbc2017-03-25 17:12:59 +080047// the default value
48int no_process = 2;
49int iterations = 100;
50int payload_size = 16;
51int no_inherent = 0;
52int no_sync = 0;
53int verbose = 0;
Howard Chen25715512017-03-28 17:05:11 +080054int trace;
55
56bool traceIsOn() {
57 fstream file;
58 file.open(trace_path + "/tracing_on", ios::in);
59 char on;
60 file >> on;
61 file.close();
62 return on == '1';
63}
64
65void traceStop() {
66 ofstream file;
67 file.open(trace_path + "/tracing_on", ios::out | ios::trunc);
68 file << '0' << endl;
69 file.close();
70}
Howard Chenc135dbc2017-03-25 17:12:59 +080071
72// the deadline latency that we are interested in
73uint64_t deadline_us = 2500;
74
75int thread_pri() {
76 struct sched_param param;
77 int policy;
78 ASSERT(!pthread_getschedparam(pthread_self(), &policy, &param));
79 return param.sched_priority;
80}
81
82void thread_dump(const char* prefix) {
83 struct sched_param param;
84 int policy;
85 if (!verbose) return;
86 cout << "--------------------------------------------------" << endl;
87 cout << setw(12) << left << prefix << " pid: " << getpid()
88 << " tid: " << gettid() << " cpu: " << sched_getcpu() << endl;
89 ASSERT(!pthread_getschedparam(pthread_self(), &policy, &param));
90 string s = (policy == SCHED_OTHER)
91 ? "SCHED_OTHER"
92 : (policy == SCHED_FIFO)
93 ? "SCHED_FIFO"
94 : (policy == SCHED_RR) ? "SCHED_RR" : "???";
95 cout << setw(12) << left << s << param.sched_priority << endl;
96 return;
97}
98
99class BinderWorkerService : public BBinder {
100 public:
101 BinderWorkerService() {
102 }
103 ~BinderWorkerService() {
104 }
105 virtual status_t onTransact(uint32_t code, const Parcel& data, Parcel* reply,
106 uint32_t flags = 0) {
107 (void)flags;
108 (void)data;
109 (void)reply;
110 switch (code) {
111 // The transaction format is like
112 //
113 // data[in]: int32: caller priority
114 // int32: caller cpu
115 //
116 // reply[out]: int32: 1 if caller's priority != callee's priority
117 // int32: 1 if caller's cpu != callee's cpu
118 //
119 // note the caller cpu read here is not always correct
120 // there're still chances that the caller got switched out
121 // right after it read the cpu number and still before the transaction.
122 case BINDER_NOP: {
123 thread_dump("binder");
124 int priority = thread_pri();
125 int priority_caller = data.readInt32();
126 int h = 0, s = 0;
127 if (priority_caller != priority) {
128 h++;
129 if (verbose) {
130 cout << "err priority_caller:" << priority_caller
131 << ", priority:" << priority << endl;
132 }
133 }
134 if (priority == sched_get_priority_max(SCHED_FIFO)) {
135 int cpu = sched_getcpu();
136 int cpu_caller = data.readInt32();
137 if (cpu != cpu_caller) {
138 s++;
139 }
140 }
141 reply->writeInt32(h);
142 reply->writeInt32(s);
143 return NO_ERROR;
144 }
145 default:
146 return UNKNOWN_TRANSACTION;
147 };
148 }
149};
150
151class Pipe {
152 int m_readFd;
153 int m_writeFd;
154 Pipe(int readFd, int writeFd) : m_readFd{readFd}, m_writeFd{writeFd} {
155 }
156 Pipe(const Pipe&) = delete;
157 Pipe& operator=(const Pipe&) = delete;
158 Pipe& operator=(const Pipe&&) = delete;
159
160 public:
161 Pipe(Pipe&& rval) noexcept {
162 m_readFd = rval.m_readFd;
163 m_writeFd = rval.m_writeFd;
164 rval.m_readFd = 0;
165 rval.m_writeFd = 0;
166 }
167 ~Pipe() {
168 if (m_readFd) close(m_readFd);
169 if (m_writeFd) close(m_writeFd);
170 }
171 void signal() {
172 bool val = true;
173 int error = write(m_writeFd, &val, sizeof(val));
174 ASSERT(error >= 0);
175 };
176 void wait() {
177 bool val = false;
178 int error = read(m_readFd, &val, sizeof(val));
179 ASSERT(error >= 0);
180 }
181 template <typename T>
182 void send(const T& v) {
183 int error = write(m_writeFd, &v, sizeof(T));
184 ASSERT(error >= 0);
185 }
186 template <typename T>
187 void recv(T& v) {
188 int error = read(m_readFd, &v, sizeof(T));
189 ASSERT(error >= 0);
190 }
191 static tuple<Pipe, Pipe> createPipePair() {
192 int a[2];
193 int b[2];
194
195 int error1 = pipe(a);
196 int error2 = pipe(b);
197 ASSERT(error1 >= 0);
198 ASSERT(error2 >= 0);
199
200 return make_tuple(Pipe(a[0], b[1]), Pipe(b[0], a[1]));
201 }
202};
203
204typedef chrono::time_point<chrono::high_resolution_clock> Tick;
205
206static inline Tick tickNow() {
207 return chrono::high_resolution_clock::now();
208}
209
210static inline uint64_t tickNano(Tick& sta, Tick& end) {
211 return uint64_t(chrono::duration_cast<chrono::nanoseconds>(end - sta).count());
212}
213
214struct Results {
215 uint64_t m_best = 0xffffffffffffffffULL;
216 uint64_t m_worst = 0;
217 uint64_t m_transactions = 0;
218 uint64_t m_total_time = 0;
219 uint64_t m_miss = 0;
Howard Chen25715512017-03-28 17:05:11 +0800220 bool tracing;
221 Results(bool _tracing) : tracing(_tracing) {
222 }
223 inline bool miss_deadline(uint64_t nano) {
224 return nano > deadline_us * 1000;
225 }
Howard Chenc135dbc2017-03-25 17:12:59 +0800226 void add_time(uint64_t nano) {
227 m_best = min(nano, m_best);
228 m_worst = max(nano, m_worst);
229 m_transactions += 1;
230 m_total_time += nano;
Howard Chen25715512017-03-28 17:05:11 +0800231 if (miss_deadline(nano)) m_miss++;
232 if (miss_deadline(nano) && tracing) {
233 // There might be multiple process pair running the test concurrently
234 // each may execute following statements and only the first one actually
235 // stop the trace and any traceStop() afterthen has no effect.
236 traceStop();
237 cout << endl;
238 cout << "deadline triggered: halt & stop trace" << endl;
239 cout << "log:" + trace_path + "/trace" << endl;
240 cout << endl;
241 exit(1);
242 }
Howard Chenc135dbc2017-03-25 17:12:59 +0800243 }
244 void dump() {
245 double best = (double)m_best / 1.0E6;
246 double worst = (double)m_worst / 1.0E6;
247 double average = (double)m_total_time / m_transactions / 1.0E6;
248 // FIXME: libjson?
249 cout << std::setprecision(DUMP_PRICISION) << "{ \"avg\":" << setw(5) << left
250 << average << ", \"wst\":" << setw(5) << left << worst
Howard Chen25715512017-03-28 17:05:11 +0800251 << ", \"bst\":" << setw(5) << left << best << ", \"miss\":" << setw(5)
252 << left << m_miss << ", \"meetR\":" << setw(3) << left
253 << (1.0 - (double)m_miss / m_transactions) << "}";
Howard Chenc135dbc2017-03-25 17:12:59 +0800254 }
255};
256
257String16 generateServiceName(int num) {
258 char num_str[32];
259 snprintf(num_str, sizeof(num_str), "%d", num);
260 String16 serviceName = String16("binderWorker") + String16(num_str);
261 return serviceName;
262}
263
264static void parcel_fill(Parcel& data, int sz, int priority, int cpu) {
265 ASSERT(sz >= (int)sizeof(uint32_t) * 2);
266 data.writeInt32(priority);
267 data.writeInt32(cpu);
268 sz -= sizeof(uint32_t);
269 while (sz > (int)sizeof(uint32_t)) {
270 data.writeInt32(0);
271 sz -= sizeof(uint32_t);
272 }
273}
274
275static void* thread_start(void* p) {
276 Results* results_fifo = (Results*)p;
277 Parcel data, reply;
278 Tick sta, end;
279
280 parcel_fill(data, payload_size, thread_pri(), sched_getcpu());
281 thread_dump("fifo-caller");
282
283 sta = tickNow();
284 status_t ret = workers[0]->transact(BINDER_NOP, data, &reply);
285 end = tickNow();
286 results_fifo->add_time(tickNano(sta, end));
287
288 no_inherent += reply.readInt32();
289 no_sync += reply.readInt32();
290 return 0;
291}
292
293// create a fifo thread to transact and wait it to finished
294static void thread_transaction(Results* results_fifo) {
295 void* dummy;
296 pthread_t thread;
297 pthread_attr_t attr;
298 struct sched_param param;
299 ASSERT(!pthread_attr_init(&attr));
300 ASSERT(!pthread_attr_setschedpolicy(&attr, SCHED_FIFO));
301 param.sched_priority = sched_get_priority_max(SCHED_FIFO);
302 ASSERT(!pthread_attr_setschedparam(&attr, &param));
303 ASSERT(!pthread_create(&thread, &attr, &thread_start, results_fifo));
304 ASSERT(!pthread_join(thread, &dummy));
305}
306
307#define is_client(_num) ((_num) >= (no_process / 2))
308
309void worker_fx(int num, int no_process, int iterations, int payload_size,
310 Pipe p) {
311 int dummy;
Howard Chen25715512017-03-28 17:05:11 +0800312 Results results_other(false), results_fifo(trace);
Howard Chenc135dbc2017-03-25 17:12:59 +0800313
314 // Create BinderWorkerService and for go.
315 ProcessState::self()->startThreadPool();
316 sp<IServiceManager> serviceMgr = defaultServiceManager();
317 sp<BinderWorkerService> service = new BinderWorkerService;
318 serviceMgr->addService(generateServiceName(num), service);
319 p.signal();
320 p.wait();
321
322 // If client/server pairs, then half the workers are
323 // servers and half are clients
324 int server_count = no_process / 2;
325
326 for (int i = 0; i < server_count; i++) {
327 // self service is in-process so just skip
328 if (num == i) continue;
329 workers.push_back(serviceMgr->getService(generateServiceName(i)));
330 }
331
332 // Client for each pair iterates here
333 // each iterations contains exatcly 2 transactions
334 for (int i = 0; is_client(num) && i < iterations; i++) {
335 Parcel data, reply;
336 Tick sta, end;
337 // the target is paired to make it easier to diagnose
338 int target = num % server_count;
339
340 // 1. transaction by fifo thread
341 thread_transaction(&results_fifo);
342 parcel_fill(data, payload_size, thread_pri(), sched_getcpu());
343 thread_dump("other-caller");
344
345 // 2. transaction by other thread
346 sta = tickNow();
347 ASSERT(NO_ERROR == workers[target]->transact(BINDER_NOP, data, &reply));
348 end = tickNow();
349 results_other.add_time(tickNano(sta, end));
350
351 no_inherent += reply.readInt32();
352 no_sync += reply.readInt32();
353 }
354 // Signal completion to master and wait.
355 p.signal();
356 p.wait();
357
358 p.send(&dummy);
359 p.wait();
360 // Client for each pair dump here
361 if (is_client(num)) {
362 int no_trans = iterations * 2;
363 double sync_ratio = (1.0 - (double)no_sync / no_trans);
364 // FIXME: libjson?
365 cout << "\"P" << (num - server_count) << "\":{\"SYNC\":\""
366 << ((sync_ratio > GOOD_SYNC_MIN) ? "GOOD" : "POOR") << "\","
367 << "\"S\":" << (no_trans - no_sync) << ",\"I\":" << no_trans << ","
368 << "\"R\":" << sync_ratio << "," << endl;
369
370 cout << " \"other_ms\":";
371 results_other.dump();
372 cout << "," << endl;
373 cout << " \"fifo_ms\": ";
374 results_fifo.dump();
375 cout << endl;
376 cout << "}," << endl;
377 }
378 exit(no_inherent);
379}
380
381Pipe make_process(int num, int iterations, int no_process, int payload_size) {
382 auto pipe_pair = Pipe::createPipePair();
383 pid_t pid = fork();
384 if (pid) {
385 // parent
386 return move(get<0>(pipe_pair));
387 } else {
388 // child
389 thread_dump(is_client(num) ? "client" : "server");
390 worker_fx(num, no_process, iterations, payload_size,
391 move(get<1>(pipe_pair)));
392 // never get here
393 return move(get<0>(pipe_pair));
394 }
395}
396
397void wait_all(vector<Pipe>& v) {
398 for (size_t i = 0; i < v.size(); i++) {
399 v[i].wait();
400 }
401}
402
403void signal_all(vector<Pipe>& v) {
404 for (size_t i = 0; i < v.size(); i++) {
405 v[i].signal();
406 }
407}
408
409// This test is modified from binderThroughputTest.cpp
410int main(int argc, char** argv) {
411 for (int i = 1; i < argc; i++) {
412 if (string(argv[i]) == "-i") {
413 iterations = atoi(argv[i + 1]);
414 i++;
415 continue;
416 }
417 if (string(argv[i]) == "-pair") {
418 no_process = 2 * atoi(argv[i + 1]);
419 i++;
420 continue;
421 }
422 if (string(argv[i]) == "-deadline_us") {
423 deadline_us = atoi(argv[i + 1]);
424 i++;
425 continue;
426 }
427 if (string(argv[i]) == "-v") {
428 verbose = 1;
Howard Chenc135dbc2017-03-25 17:12:59 +0800429 }
Howard Chen25715512017-03-28 17:05:11 +0800430 // The -trace argument is used like that:
431 //
432 // First start trace with atrace command as usual
433 // >atrace --async_start sched freq
434 //
435 // then use schd-dbg with -trace arguments
436 //./schd-dbg -trace -deadline_us 2500
437 //
438 // This makes schd-dbg to stop trace once it detects a transaction
439 // duration over the deadline. By writing '0' to
440 // /sys/kernel/debug/tracing and halt the process. The tracelog is
441 // then available on /sys/kernel/debug/trace
442 if (string(argv[i]) == "-trace") {
443 trace = 1;
444 }
445 }
446 if (trace && !traceIsOn()) {
447 cout << "trace is not running" << endl;
448 cout << "check " << trace_path + "/tracing_on" << endl;
449 cout << "use atrace --async_start first" << endl;
450 exit(-1);
Howard Chenc135dbc2017-03-25 17:12:59 +0800451 }
452 vector<Pipe> pipes;
453 thread_dump("main");
454 // FIXME: libjson?
455 cout << "{" << endl;
456 cout << "\"cfg\":{\"pair\":" << (no_process / 2)
457 << ",\"iterations\":" << iterations << ",\"deadline_us\":" << deadline_us
458 << "}," << endl;
459
460 // the main process fork 2 processes for each pairs
461 // 1 server + 1 client
462 // each has a pipe to communicate with
463 for (int i = 0; i < no_process; i++) {
464 pipes.push_back(make_process(i, iterations, no_process, payload_size));
465 }
466 wait_all(pipes);
467 signal_all(pipes);
468 wait_all(pipes);
469 signal_all(pipes);
470 for (int i = 0; i < no_process; i++) {
471 int status;
472 pipes[i].signal();
473 wait(&status);
474 // the exit status is number of transactions without priority inheritance
475 // detected in the child process
476 no_inherent += status;
477 }
478 // FIXME: libjson?
479 cout << "\"inheritance\": " << (no_inherent == 0 ? "\"PASS\"" : "\"FAIL\"")
480 << endl;
481 cout << "}" << endl;
482 return -no_inherent;
483}