/* * 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 "PerfTest.h" #include #include #include #include #ifdef ASSERT #undef ASSERT #endif #define ASSERT(cond) \ do { \ if (!(cond)) { \ cerr << __func__ << ":" << __LINE__ << " condition:" << #cond << " failed\n" << endl; \ exit(EXIT_FAILURE); \ } \ } while (0) // 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) // the precision used for cout to dump float #define DUMP_PRICISION 2 using std::cerr; using std::cout; using std::endl; using std::left; using std::ios; using std::min; using std::max; using std::to_string; using std::setprecision; using std::setw; using std::ofstream; using std::make_tuple; tuple 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])); } Pipe::Pipe(Pipe&& rval) noexcept { fd_read_ = rval.fd_read_; fd_write_ = rval.fd_write_; rval.fd_read_ = 0; rval.fd_write_ = 0; } Pipe::~Pipe() { if (fd_read_) { close(fd_read_); } if (fd_write_) { close(fd_write_); } } Results Results::combine(const Results& a, const Results& b) { Results ret; for (uint32_t i = 0; i < kNumBuckets; i++) { ret.buckets_[i] = a.buckets_[i] + b.buckets_[i]; } ret.worst_ = max(a.worst_, b.worst_); ret.best_ = min(a.best_, b.best_); ret.transactions_ = a.transactions_ + b.transactions_; ret.miss_ = a.miss_ + b.miss_; ret.total_time_ = a.total_time_ + b.total_time_; return ret; } static void traceStop() { ofstream file; file.open(TRACE_PATH "/tracing_on", ios::out | ios::trunc); file << '0' << endl; file.close(); } void Results::addTime(uint64_t nano) { buckets_[min(nano, kMaxTimeBucket - 1) / kTimePerBucket] += 1; best_ = min(nano, best_); worst_ = max(nano, worst_); if (raw_dump_) { raw_data_->push_back(nano); } transactions_ += 1; total_time_ += nano; if (missDeadline(nano)) { miss_++; if (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() after then has no effect. traceStop(); cerr << endl; cerr << "deadline triggered: halt & stop trace" << endl; cerr << "log:" TRACE_PATH "/trace" << endl; cerr << endl; exit(EXIT_FAILURE); } } } void Results::setupRawData() { raw_dump_ = true; if (raw_data_ == nullptr) { raw_data_ = new list; } else { raw_data_->clear(); } } void Results::flushRawData() { if (raw_dump_) { bool first = true; cout << "["; for (auto nano : *raw_data_) { cout << (first ? "" : ",") << to_string(nano); first = false; } cout << "]," << endl; delete raw_data_; raw_data_ = nullptr; } } void Results::dump() const { double best = (double)best_ / 1.0E6; double worst = (double)worst_ / 1.0E6; double average = (double)total_time_ / 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 << miss_ << ", \"meetR\":" << setprecision(DUMP_PRICISION + 3) << left << (1.0 - (double)miss_ / transactions_) << "}"; } void Results::dumpDistribution() const { uint64_t cur_total = 0; cout << "{ "; cout << std::setprecision(DUMP_PRICISION + 3); for (uint32_t i = 0; i < kNumBuckets; i++) { float cur_time = kTimePerBucketMS * i + 0.5f * kTimePerBucketMS; float accumulation = cur_total + buckets_[i]; if ((cur_total < 0.5f * transactions_) && (accumulation >= 0.5f * transactions_)) { cout << "\"p50\":" << cur_time << ", "; } if ((cur_total < 0.9f * transactions_) && (accumulation >= 0.9f * transactions_)) { cout << "\"p90\":" << cur_time << ", "; } if ((cur_total < 0.95f * transactions_) && (accumulation >= 0.95f * transactions_)) { cout << "\"p95\":" << cur_time << ", "; } if ((cur_total < 0.99f * transactions_) && (accumulation >= 0.99f * transactions_)) { cout << "\"p99\": " << cur_time; } cur_total += buckets_[i]; } cout << "}"; } PResults PResults::combine(const PResults& a, const PResults& b) { PResults ret; ret.nNotInherent = a.nNotInherent + b.nNotInherent; ret.nNotSync = a.nNotSync + b.nNotSync; ret.other = Results::combine(a.other, b.other); ret.fifo = Results::combine(a.fifo, b.fifo); return ret; } void PResults::dump() const { int no_trans = other.getTransactions() + fifo.getTransactions(); double sync_ratio = (1.0 - (double)nNotSync / no_trans); cout << "{\"SYNC\":\"" << ((sync_ratio > GOOD_SYNC_MIN) ? "GOOD" : "POOR") << "\"," << "\"S\":" << (no_trans - nNotSync) << ",\"I\":" << no_trans << "," << "\"R\":" << sync_ratio << "," << endl; cout << " \"other_ms\":"; other.dump(); cout << "," << endl; cout << " \"fifo_ms\": "; fifo.dump(); cout << "," << endl; cout << " \"otherdis\":"; other.dumpDistribution(); cout << "," << endl; cout << " \"fifodis\": "; fifo.dumpDistribution(); cout << endl; cout << "}," << endl; }