vts/performance/Latency.cpp - platform/system/libhwbinder - Git at Google

 /*
  * Copyright (C) 2016 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 <android/hardware/tests/libhwbinder/1.0/IScheduleTest.h>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <fstream>
 #include <iomanip>
 #include <iostream>
 #include <string>
 #include <tuple>
 #include <vector>

 #include <pthread.h>
 #include <sys/wait.h>
 #include <unistd.h>

 using namespace std;
 using namespace android;
 using namespace android::hardware;

 using android::hardware::tests::libhwbinder::V1_0::IScheduleTest;

 #define ASSERT(cond)                                                \
   do {                                                              \
     if (!(cond)) {                                                  \
       cerr << __func__ << ":" << __LINE__ << " condition:" << #cond \
            << " failed\n"                                           \
            << endl;                                                 \
       exit(EXIT_FAILURE);                                           \
     }                                                               \
   } while (0)

 vector<sp<IScheduleTest> > services;

 // the ratio that the service is synced on the same cpu beyond
 // GOOD_SYNC_MIN is considered as good
 #define GOOD_SYNC_MIN (0.6)

 #define DUMP_PRICISION 2

 string trace_path = "/sys/kernel/debug/tracing";

 // the default value
 int no_pair = 1;
 int iterations = 100;
 int no_inherent = 0;
 int no_sync = 0;
 int verbose = 0;
 int trace;
 bool pass_through = false;

 static bool traceIsOn() {
   fstream file;
   file.open(trace_path + "/tracing_on", ios::in);
   char on;
   file >> on;
   file.close();
   return on == '1';
 }

 static void traceStop() {
   ofstream file;
   file.open(trace_path + "/tracing_on", ios::out | ios::trunc);
   file << '0' << endl;
   file.close();
 }

 // the deadline latency that we are interested in
 uint64_t deadline_us = 2500;

 static int threadPri() {
   struct sched_param param;
   int policy;
   ASSERT(!pthread_getschedparam(pthread_self(), &policy, &param));
   return param.sched_priority;
 }

 static void threadDump(const char* prefix) {
   struct sched_param param;
   int policy;
   if (!verbose) return;
   cout << "--------------------------------------------------" << endl;
   cout << setw(12) << left << prefix << " pid: " << getpid()
        << " tid: " << gettid() << " cpu: " << sched_getcpu() << endl;
   ASSERT(!pthread_getschedparam(pthread_self(), &policy, &param));
   string s = (policy == SCHED_OTHER)
                  ? "SCHED_OTHER"
                  : (policy == SCHED_FIFO)
                        ? "SCHED_FIFO"
                        : (policy == SCHED_RR) ? "SCHED_RR" : "???";
   cout << setw(12) << left << s << param.sched_priority << endl;
   return;
 }

 // This IPC class is widely used in binder/hwbinder tests.
 // The common usage is the main process to create the Pipe and forks.
 // Both parent and child hold a object and each wait() on parent
 // needs a signal() on the child to wake up and vice versa.
 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(error >= 0);
   };
   void wait() {
     bool val = false;
     int error = read(m_readFd, &val, sizeof(val));
     ASSERT(error >= 0);
   }
   template <typename T>
   void send(const T& v) {
     int error = write(m_writeFd, &v, sizeof(T));
     ASSERT(error >= 0);
   }
   template <typename T>
   void recv(T& v) {
     int error = read(m_readFd, &v, sizeof(T));
     ASSERT(error >= 0);
   }
   static tuple<Pipe, Pipe> createPipePair() {
     int a[2];
     int b[2];

     int error1 = pipe(a);
     int error2 = pipe(b);
     ASSERT(error1 >= 0);
     ASSERT(error2 >= 0);

     return make_tuple(Pipe(a[0], b[1]), Pipe(b[0], a[1]));
   }
 };

 typedef chrono::time_point<chrono::high_resolution_clock> Tick;

 static inline Tick tickNow() { return chrono::high_resolution_clock::now(); }

 static inline uint64_t tickNano(Tick& sta, Tick& end) {
   return uint64_t(
       chrono::duration_cast<chrono::nanoseconds>(end - sta).count());
 }

 struct Results {
   uint64_t m_best = 0xffffffffffffffffULL;
   uint64_t m_worst = 0;
   uint64_t m_transactions = 0;
   uint64_t m_total_time = 0;
   uint64_t m_miss = 0;
   bool tracing;
   Results(bool _tracing) : tracing(_tracing) {}
   inline bool miss_deadline(uint64_t nano) { return nano > deadline_us * 1000; }
   void add_time(uint64_t nano) {
     m_best = min(nano, m_best);
     m_worst = max(nano, m_worst);
     m_transactions += 1;
     m_total_time += nano;
     if (miss_deadline(nano)) m_miss++;
     if (miss_deadline(nano) && tracing) {
       // There might be multiple process pair running the test concurrently
       // each may execute following statements and only the first one actually
       // stop the trace and any traceStop() afterthen has no effect.
       traceStop();
       cout << endl;
       cout << "deadline triggered: halt & stop trace" << endl;
       cout << "log:" + trace_path + "/trace" << endl;
       cout << endl;
       exit(1);
     }
   }
   void dump() {
     double best = (double)m_best / 1.0E6;
     double worst = (double)m_worst / 1.0E6;
     double average = (double)m_total_time / m_transactions / 1.0E6;
     int W = DUMP_PRICISION + 2;
     cout << std::setprecision(DUMP_PRICISION) << "{ \"avg\":" << setw(W) << left
          << average << ", \"wst\":" << setw(W) << left << worst
          << ", \"bst\":" << setw(W) << left << best << ", \"miss\":" << left
          << m_miss << ", \"meetR\":" << setprecision(DUMP_PRICISION + 3) << left
          << (1.0 - (double)m_miss / m_transactions) << "}";
   }
 };

 static string generateServiceName(int num) {
   string serviceName = "hwbinderService" + to_string(num);
   return serviceName;
 }

 // This private struct is used to pass the argument to threadStart
 // result: a pointer to Results
 // target: the terget service number
 typedef struct {
   void* result;
   int target;
 } thread_priv_t;

 static void* threadStart(void* p) {
   thread_priv_t* priv = (thread_priv_t*)p;
   int target = priv->target;
   Results* results_fifo = (Results*)priv->result;
   Tick sta, end;

   threadDump("fifo-caller");
   uint32_t call_sta = (threadPri() << 16) | sched_getcpu();
   sp<IScheduleTest> service = services[target];
   sta = tickNow();
   uint32_t ret = service->send(verbose, call_sta);
   end = tickNow();
   results_fifo->add_time(tickNano(sta, end));

   no_inherent += (ret >> 16) & 0xffff;
   no_sync += ret & 0xffff;
   return 0;
 }

 // create a fifo thread to transact and wait it to finished
 static void threadTransaction(int target, Results* results_fifo) {
   thread_priv_t thread_priv;

   void* dummy;
   pthread_t thread;
   pthread_attr_t attr;
   struct sched_param param;
   thread_priv.target = target;
   thread_priv.result = results_fifo;
   ASSERT(!pthread_attr_init(&attr));
   ASSERT(!pthread_attr_setschedpolicy(&attr, SCHED_FIFO));
   param.sched_priority = sched_get_priority_max(SCHED_FIFO);
   ASSERT(!pthread_attr_setschedparam(&attr, &param));
   ASSERT(!pthread_create(&thread, &attr, threadStart, &thread_priv));
   ASSERT(!pthread_join(thread, &dummy));
 }

 static void serviceFx(const string& serviceName, Pipe p) {
   // Start service.
   sp<IScheduleTest> server = IScheduleTest::getService(serviceName, true);
   status_t status = server->registerAsService(serviceName);
   if (status != ::android::OK) {
     cout << "Failed to register service " << serviceName.c_str() << endl;
     exit(EXIT_FAILURE);
   }
   // tell main I'm init-ed
   p.signal();
   // wait for kill
   p.wait();
   exit(EXIT_SUCCESS);
 }

 static Pipe makeServiceProces(string service_name) {
   auto pipe_pair = Pipe::createPipePair();
   pid_t pid = fork();
   if (pid) {
     // parent
     return move(get<0>(pipe_pair));
   } else {
     threadDump("service");
     // child
     serviceFx(service_name, move(get<1>(pipe_pair)));
     // never get here
     ASSERT(0);
     return move(get<0>(pipe_pair));
   }
 }

 static void clientFx(int num, int server_count, int iterations, Pipe p) {
   Results results_other(false), results_fifo(trace);

   for (int i = 0; i < server_count; i++) {
     sp<IScheduleTest> service =
         IScheduleTest::getService(generateServiceName(i), pass_through);
     ASSERT(service != nullptr);
     if (pass_through) {
       ASSERT(!service->isRemote());
     } else {
       ASSERT(service->isRemote());
     }
     services.push_back(service);
   }
   // tell main I'm init-ed
   p.signal();
   // wait for kick-off
   p.wait();

   // Client for each pair iterates here
   // each iterations contains exatcly 2 transactions
   for (int i = 0; i < iterations; i++) {
     Tick sta, end;
     // the target is paired to make it easier to diagnose
     int target = num;

     // 1. transaction by fifo thread
     threadTransaction(target, &results_fifo);
     threadDump("other-caller");

     uint32_t call_sta = (threadPri() << 16) | sched_getcpu();
     sp<IScheduleTest> service = services[target];
     // 2. transaction by other thread
     sta = tickNow();
     uint32_t ret = service->send(verbose, call_sta);
     end = tickNow();
     results_other.add_time(tickNano(sta, end));
     no_inherent += (ret >> 16) & 0xffff;
     no_sync += ret & 0xffff;
   }
   // tell main i'm done
   p.signal();
   // wait for kill
   p.wait();
   // Client for each pair dump here
   int no_trans = iterations * 2;
   double sync_ratio = (1.0 - (double)no_sync / no_trans);
   cout << "\"P" << num << "\":{\"SYNC\":\""
        << ((sync_ratio > GOOD_SYNC_MIN) ? "GOOD" : "POOR") << "\","
        << "\"S\":" << (no_trans - no_sync) << ",\"I\":" << no_trans << ","
        << "\"R\":" << sync_ratio << "," << endl;

   cout << "  \"other_ms\":";
   results_other.dump();
   cout << "," << endl;
   cout << "  \"fifo_ms\": ";
   results_fifo.dump();
   cout << endl;
   cout << "}," << endl;
   exit(no_inherent);
 }

 static Pipe makeClientProcess(int num, int iterations, int no_pair) {
   auto pipe_pair = Pipe::createPipePair();
   pid_t pid = fork();
   if (pid) {
     // parent
     return move(get<0>(pipe_pair));
   } else {
     // child
     threadDump("client");
     clientFx(num, no_pair, iterations, move(get<1>(pipe_pair)));
     // never get here
     ASSERT(0);
     return move(get<0>(pipe_pair));
   }
 }

 static void waitAll(vector<Pipe>& v) {
   for (size_t i = 0; i < v.size(); i++) {
     v[i].wait();
   }
 }

 static void signalAll(vector<Pipe>& v) {
   for (size_t i = 0; i < v.size(); i++) {
     v[i].signal();
   }
 }

 // This test is modified from frameworks/native/libs/binder/tests/sch-dbg.cpp
 // The difference is sch-dbg tests binder transaction and this one test
 // HwBinder transaction.
 int main(int argc, char** argv) {
   setenv("TREBLE_TESTING_OVERRIDE", "true", true);

   vector<Pipe> client_pipes;
   vector<Pipe> service_pipes;

   for (int i = 1; i < argc; i++) {
     if (string(argv[i]) == "-passthrough") {
       pass_through = true;
     }
     if (string(argv[i]) == "-i") {
       iterations = atoi(argv[i + 1]);
       i++;
       continue;
     }
     if (string(argv[i]) == "-pair") {
       no_pair = atoi(argv[i + 1]);
       i++;
       continue;
     }
     if (string(argv[i]) == "-deadline_us") {
       deadline_us = atoi(argv[i + 1]);
       i++;
       continue;
     }
     if (string(argv[i]) == "-v") {
       verbose = 1;
     }
     // The -trace argument is used like that:
     //
     // First start trace with atrace command as usual
     // >atrace --async_start sched freq
     //
     // then use the -trace arguments like
     // -trace -deadline_us 2500
     //
     // This makes the program to stop trace once it detects a transaction
     // duration over the deadline. By writing '0' to
     // /sys/kernel/debug/tracing and halt the process. The tracelog is
     // then available on /sys/kernel/debug/trace
     if (string(argv[i]) == "-trace") {
       trace = 1;
     }
   }
   if (!pass_through) {
     // Create services.
     for (int i = 0; i < no_pair; i++) {
       string serviceName = generateServiceName(i);
       service_pipes.push_back(makeServiceProces(serviceName));
     }
     // Wait until all services are up.
     waitAll(service_pipes);
   }
   if (trace && !traceIsOn()) {
     cout << "trace is not running" << endl;
     cout << "check " << trace_path + "/tracing_on" << endl;
     cout << "use atrace --async_start first" << endl;
     exit(-1);
   }
   threadDump("main");
   cout << "{" << endl;
   cout << "\"cfg\":{\"pair\":" << (no_pair) << ",\"iterations\":" << iterations
        << ",\"deadline_us\":" << deadline_us << "}," << endl;

   // the main process fork 2 processes for each pairs
   // 1 server + 1 client
   // each has a pipe to communicate with
   for (int i = 0; i < no_pair; i++) {
     client_pipes.push_back(makeClientProcess(i, iterations, no_pair));
   }
   // wait client to init
   waitAll(client_pipes);

   // kick off clients
   signalAll(client_pipes);

   // wait client to finished
   waitAll(client_pipes);

   if (!pass_through) {
     // Kill all the services.
     for (int i = 0; i < no_pair; i++) {
       int status;
       service_pipes[i].signal();
       wait(&status);
       if (status != 0) {
         cout << "nonzero child status" << status << endl;
       }
     }
   }
   for (int i = 0; i < no_pair; i++) {
     int status;
     client_pipes[i].signal();
     wait(&status);
     // the exit status is number of transactions without priority inheritance
     // detected in the child process
     no_inherent += status;
   }
   cout << "\"inheritance\": " << (no_inherent == 0 ? "\"PASS\"" : "\"FAIL\"")
        << endl;
   cout << "}" << endl;
   return -no_inherent;
 }
	/*
	* Copyright (C) 2016 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 <android/hardware/tests/libhwbinder/1.0/IScheduleTest.h>
	#include <cstdio>
	#include <cstdlib>
	#include <cstring>
	#include <fstream>
	#include <iomanip>
	#include <iostream>
	#include <string>
	#include <tuple>
	#include <vector>

	#include <pthread.h>
	#include <sys/wait.h>
	#include <unistd.h>

	using namespace std;
	using namespace android;
	using namespace android::hardware;

	using android::hardware::tests::libhwbinder::V1_0::IScheduleTest;

	#define ASSERT(cond) \
	do { \
	if (!(cond)) { \
	cerr << __func__ << ":" << __LINE__ << " condition:" << #cond \
	<< " failed\n" \
	<< endl; \
	exit(EXIT_FAILURE); \
	} \
	} while (0)

	vector<sp<IScheduleTest> > services;

	// the ratio that the service is synced on the same cpu beyond
	// GOOD_SYNC_MIN is considered as good
	#define GOOD_SYNC_MIN (0.6)

	#define DUMP_PRICISION 2

	string trace_path = "/sys/kernel/debug/tracing";

	// the default value
	int no_pair = 1;
	int iterations = 100;
	int no_inherent = 0;
	int no_sync = 0;
	int verbose = 0;
	int trace;
	bool pass_through = false;

	static bool traceIsOn() {
	fstream file;
	file.open(trace_path + "/tracing_on", ios::in);
	char on;
	file >> on;
	file.close();
	return on == '1';
	}

	static void traceStop() {
	ofstream file;
	file.open(trace_path + "/tracing_on", ios::out \| ios::trunc);
	file << '0' << endl;
	file.close();
	}

	// the deadline latency that we are interested in
	uint64_t deadline_us = 2500;

	static int threadPri() {
	struct sched_param param;
	int policy;
	ASSERT(!pthread_getschedparam(pthread_self(), &policy, &param));
	return param.sched_priority;
	}

	static void threadDump(const char* prefix) {
	struct sched_param param;
	int policy;
	if (!verbose) return;
	cout << "--------------------------------------------------" << endl;
	cout << setw(12) << left << prefix << " pid: " << getpid()
	<< " tid: " << gettid() << " cpu: " << sched_getcpu() << endl;
	ASSERT(!pthread_getschedparam(pthread_self(), &policy, &param));
	string s = (policy == SCHED_OTHER)
	? "SCHED_OTHER"
	: (policy == SCHED_FIFO)
	? "SCHED_FIFO"
	: (policy == SCHED_RR) ? "SCHED_RR" : "???";
	cout << setw(12) << left << s << param.sched_priority << endl;
	return;
	}

	// This IPC class is widely used in binder/hwbinder tests.
	// The common usage is the main process to create the Pipe and forks.
	// Both parent and child hold a object and each wait() on parent
	// needs a signal() on the child to wake up and vice versa.
	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(error >= 0);
	};
	void wait() {
	bool val = false;
	int error = read(m_readFd, &val, sizeof(val));
	ASSERT(error >= 0);
	}
	template <typename T>
	void send(const T& v) {
	int error = write(m_writeFd, &v, sizeof(T));
	ASSERT(error >= 0);
	}
	template <typename T>
	void recv(T& v) {
	int error = read(m_readFd, &v, sizeof(T));
	ASSERT(error >= 0);
	}
	static tuple<Pipe, Pipe> createPipePair() {
	int a[2];
	int b[2];

	int error1 = pipe(a);
	int error2 = pipe(b);
	ASSERT(error1 >= 0);
	ASSERT(error2 >= 0);

	return make_tuple(Pipe(a[0], b[1]), Pipe(b[0], a[1]));
	}
	};

	typedef chrono::time_point<chrono::high_resolution_clock> Tick;

	static inline Tick tickNow() { return chrono::high_resolution_clock::now(); }

	static inline uint64_t tickNano(Tick& sta, Tick& end) {
	return uint64_t(
	chrono::duration_cast<chrono::nanoseconds>(end - sta).count());
	}

	struct Results {
	uint64_t m_best = 0xffffffffffffffffULL;
	uint64_t m_worst = 0;
	uint64_t m_transactions = 0;
	uint64_t m_total_time = 0;
	uint64_t m_miss = 0;
	bool tracing;
	Results(bool _tracing) : tracing(_tracing) {}
	inline bool miss_deadline(uint64_t nano) { return nano > deadline_us * 1000; }
	void add_time(uint64_t nano) {
	m_best = min(nano, m_best);
	m_worst = max(nano, m_worst);
	m_transactions += 1;
	m_total_time += nano;
	if (miss_deadline(nano)) m_miss++;
	if (miss_deadline(nano) && tracing) {
	// There might be multiple process pair running the test concurrently
	// each may execute following statements and only the first one actually
	// stop the trace and any traceStop() afterthen has no effect.
	traceStop();
	cout << endl;
	cout << "deadline triggered: halt & stop trace" << endl;
	cout << "log:" + trace_path + "/trace" << endl;
	cout << endl;
	exit(1);
	}
	}
	void dump() {
	double best = (double)m_best / 1.0E6;
	double worst = (double)m_worst / 1.0E6;
	double average = (double)m_total_time / m_transactions / 1.0E6;
	int W = DUMP_PRICISION + 2;
	cout << std::setprecision(DUMP_PRICISION) << "{ \"avg\":" << setw(W) << left
	<< average << ", \"wst\":" << setw(W) << left << worst
	<< ", \"bst\":" << setw(W) << left << best << ", \"miss\":" << left
	<< m_miss << ", \"meetR\":" << setprecision(DUMP_PRICISION + 3) << left
	<< (1.0 - (double)m_miss / m_transactions) << "}";
	}
	};

	static string generateServiceName(int num) {
	string serviceName = "hwbinderService" + to_string(num);
	return serviceName;
	}

	// This private struct is used to pass the argument to threadStart
	// result: a pointer to Results
	// target: the terget service number
	typedef struct {
	void* result;
	int target;
	} thread_priv_t;

	static void* threadStart(void* p) {
	thread_priv_t* priv = (thread_priv_t*)p;
	int target = priv->target;
	Results* results_fifo = (Results*)priv->result;
	Tick sta, end;

	threadDump("fifo-caller");
	uint32_t call_sta = (threadPri() << 16) \| sched_getcpu();
	sp<IScheduleTest> service = services[target];
	sta = tickNow();
	uint32_t ret = service->send(verbose, call_sta);
	end = tickNow();
	results_fifo->add_time(tickNano(sta, end));

	no_inherent += (ret >> 16) & 0xffff;
	no_sync += ret & 0xffff;
	return 0;
	}

	// create a fifo thread to transact and wait it to finished
	static void threadTransaction(int target, Results* results_fifo) {
	thread_priv_t thread_priv;

	void* dummy;
	pthread_t thread;
	pthread_attr_t attr;
	struct sched_param param;
	thread_priv.target = target;
	thread_priv.result = results_fifo;
	ASSERT(!pthread_attr_init(&attr));
	ASSERT(!pthread_attr_setschedpolicy(&attr, SCHED_FIFO));
	param.sched_priority = sched_get_priority_max(SCHED_FIFO);
	ASSERT(!pthread_attr_setschedparam(&attr, &param));
	ASSERT(!pthread_create(&thread, &attr, threadStart, &thread_priv));
	ASSERT(!pthread_join(thread, &dummy));
	}

	static void serviceFx(const string& serviceName, Pipe p) {
	// Start service.
	sp<IScheduleTest> server = IScheduleTest::getService(serviceName, true);
	status_t status = server->registerAsService(serviceName);
	if (status != ::android::OK) {
	cout << "Failed to register service " << serviceName.c_str() << endl;
	exit(EXIT_FAILURE);
	}
	// tell main I'm init-ed
	p.signal();
	// wait for kill
	p.wait();
	exit(EXIT_SUCCESS);
	}

	static Pipe makeServiceProces(string service_name) {
	auto pipe_pair = Pipe::createPipePair();
	pid_t pid = fork();
	if (pid) {
	// parent
	return move(get<0>(pipe_pair));
	} else {
	threadDump("service");
	// child
	serviceFx(service_name, move(get<1>(pipe_pair)));
	// never get here
	ASSERT(0);
	return move(get<0>(pipe_pair));
	}
	}

	static void clientFx(int num, int server_count, int iterations, Pipe p) {
	Results results_other(false), results_fifo(trace);

	for (int i = 0; i < server_count; i++) {
	sp<IScheduleTest> service =
	IScheduleTest::getService(generateServiceName(i), pass_through);
	ASSERT(service != nullptr);
	if (pass_through) {
	ASSERT(!service->isRemote());
	} else {
	ASSERT(service->isRemote());
	}
	services.push_back(service);
	}
	// tell main I'm init-ed
	p.signal();
	// wait for kick-off
	p.wait();

	// Client for each pair iterates here
	// each iterations contains exatcly 2 transactions
	for (int i = 0; i < iterations; i++) {
	Tick sta, end;
	// the target is paired to make it easier to diagnose
	int target = num;

	// 1. transaction by fifo thread
	threadTransaction(target, &results_fifo);
	threadDump("other-caller");

	uint32_t call_sta = (threadPri() << 16) \| sched_getcpu();
	sp<IScheduleTest> service = services[target];
	// 2. transaction by other thread
	sta = tickNow();
	uint32_t ret = service->send(verbose, call_sta);
	end = tickNow();
	results_other.add_time(tickNano(sta, end));
	no_inherent += (ret >> 16) & 0xffff;
	no_sync += ret & 0xffff;
	}
	// tell main i'm done
	p.signal();
	// wait for kill
	p.wait();
	// Client for each pair dump here
	int no_trans = iterations * 2;
	double sync_ratio = (1.0 - (double)no_sync / no_trans);
	cout << "\"P" << num << "\":{\"SYNC\":\""
	<< ((sync_ratio > GOOD_SYNC_MIN) ? "GOOD" : "POOR") << "\","
	<< "\"S\":" << (no_trans - no_sync) << ",\"I\":" << no_trans << ","
	<< "\"R\":" << sync_ratio << "," << endl;

	cout << " \"other_ms\":";
	results_other.dump();
	cout << "," << endl;
	cout << " \"fifo_ms\": ";
	results_fifo.dump();
	cout << endl;
	cout << "}," << endl;
	exit(no_inherent);
	}

	static Pipe makeClientProcess(int num, int iterations, int no_pair) {
	auto pipe_pair = Pipe::createPipePair();
	pid_t pid = fork();
	if (pid) {
	// parent
	return move(get<0>(pipe_pair));
	} else {
	// child
	threadDump("client");
	clientFx(num, no_pair, iterations, move(get<1>(pipe_pair)));
	// never get here
	ASSERT(0);
	return move(get<0>(pipe_pair));
	}
	}

	static void waitAll(vector<Pipe>& v) {
	for (size_t i = 0; i < v.size(); i++) {
	v[i].wait();
	}
	}

	static void signalAll(vector<Pipe>& v) {
	for (size_t i = 0; i < v.size(); i++) {
	v[i].signal();
	}
	}

	// This test is modified from frameworks/native/libs/binder/tests/sch-dbg.cpp
	// The difference is sch-dbg tests binder transaction and this one test
	// HwBinder transaction.
	int main(int argc, char** argv) {
	setenv("TREBLE_TESTING_OVERRIDE", "true", true);

	vector<Pipe> client_pipes;
	vector<Pipe> service_pipes;

	for (int i = 1; i < argc; i++) {
	if (string(argv[i]) == "-passthrough") {
	pass_through = true;
	}
	if (string(argv[i]) == "-i") {
	iterations = atoi(argv[i + 1]);
	i++;
	continue;
	}
	if (string(argv[i]) == "-pair") {
	no_pair = atoi(argv[i + 1]);
	i++;
	continue;
	}
	if (string(argv[i]) == "-deadline_us") {
	deadline_us = atoi(argv[i + 1]);
	i++;
	continue;
	}
	if (string(argv[i]) == "-v") {
	verbose = 1;
	}
	// The -trace argument is used like that:
	//
	// First start trace with atrace command as usual
	// >atrace --async_start sched freq
	//
	// then use the -trace arguments like
	// -trace -deadline_us 2500
	//
	// This makes the program to stop trace once it detects a transaction
	// duration over the deadline. By writing '0' to
	// /sys/kernel/debug/tracing and halt the process. The tracelog is
	// then available on /sys/kernel/debug/trace
	if (string(argv[i]) == "-trace") {
	trace = 1;
	}
	}
	if (!pass_through) {
	// Create services.
	for (int i = 0; i < no_pair; i++) {
	string serviceName = generateServiceName(i);
	service_pipes.push_back(makeServiceProces(serviceName));
	}
	// Wait until all services are up.
	waitAll(service_pipes);
	}
	if (trace && !traceIsOn()) {
	cout << "trace is not running" << endl;
	cout << "check " << trace_path + "/tracing_on" << endl;
	cout << "use atrace --async_start first" << endl;
	exit(-1);
	}
	threadDump("main");
	cout << "{" << endl;
	cout << "\"cfg\":{\"pair\":" << (no_pair) << ",\"iterations\":" << iterations
	<< ",\"deadline_us\":" << deadline_us << "}," << endl;

	// the main process fork 2 processes for each pairs
	// 1 server + 1 client
	// each has a pipe to communicate with
	for (int i = 0; i < no_pair; i++) {
	client_pipes.push_back(makeClientProcess(i, iterations, no_pair));
	}
	// wait client to init
	waitAll(client_pipes);

	// kick off clients
	signalAll(client_pipes);

	// wait client to finished
	waitAll(client_pipes);

	if (!pass_through) {
	// Kill all the services.
	for (int i = 0; i < no_pair; i++) {
	int status;
	service_pipes[i].signal();
	wait(&status);
	if (status != 0) {
	cout << "nonzero child status" << status << endl;
	}
	}
	}
	for (int i = 0; i < no_pair; i++) {
	int status;
	client_pipes[i].signal();
	wait(&status);
	// the exit status is number of transactions without priority inheritance
	// detected in the child process
	no_inherent += status;
	}
	cout << "\"inheritance\": " << (no_inherent == 0 ? "\"PASS\"" : "\"FAIL\"")
	<< endl;
	cout << "}" << endl;
	return -no_inherent;
	}